sourcecode 0.25.0__py3-none-any.whl → 0.27.0__py3-none-any.whl

sourcecode/__init__.py

@@ -1,3 +1,3 @@
 """sourcecode — Genera mapas de contexto estructurado para agentes IA."""
 
-__version__ = "0.25.0"
+__version__ = "0.27.0"

sourcecode/architecture_summary.py

@@ -9,6 +9,12 @@ from sourcecode.schema import EntryPoint, SourceMap, StackDetection
 from sourcecode.tree_utils import flatten_file_tree
 
 _TOOLING_PREFIXES = (".claude/", ".vscode/", "bin/")
+_AUXILIARY_PATH_PARTS: frozenset[str] = frozenset({
+    "benchmark", "benchmarks", "bench", "benches",
+    "demo", "demos", "example", "examples",
+    "docs", "doc", "fixture", "fixtures",
+    "playground", "playgrounds", "sandbox",
+})
 _PYTHON_EXTENSIONS = {".py"}
 _NODE_EXTENSIONS = {".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"}
 _GO_EXTENSIONS = {".go"}
@@ -52,10 +58,12 @@ class ArchitectureSummarizer:
         # Rich path: use all available signals (stacks, arch analysis, graph)
         rich_lines = self._build_rich_lines(sm)
 
-        # Stack-specific entry point analysis (existing logic)
+        # Stack-specific entry point analysis: exclude tooling + auxiliary paths
         entry_points = [
             entry for entry in sm.entry_points
             if not self._is_tooling_path(entry.path)
+            and not self._is_auxiliary_path(entry.path)
+            and entry.entrypoint_type not in ("benchmark", "example")
         ]
         if not entry_points:
             fallback = self._infer_fallback_entry_points(file_paths, sm.stacks)
@@ -147,7 +155,31 @@ class ArchitectureSummarizer:
         if primary is None:
             return ""
         stack_label = _STACK_LABELS.get(primary.stack, primary.stack)
-        fw_names = [f.name for s in sm.stacks for f in s.frameworks[:2]][:3]
+
+        # For monorepos: only show frameworks from runtime-critical packages,
+        # not every framework found in every workspace (avoids "React project" misclassification)
+        if sm.project_type == "monorepo" and sm.monorepo_packages:
+            runtime_roles = {"runtime_core", "plugin_host", "backend_runtime"}
+            runtime_paths = {p.path for p in sm.monorepo_packages if p.architectural_role in runtime_roles}
+            fw_names = [
+                f.name
+                for s in sm.stacks
+                if not s.workspace or s.workspace in runtime_paths
+                for f in s.frameworks[:2]
+            ]
+            fw_names = list(dict.fromkeys(fw_names))[:3]  # dedup, preserve order
+        else:
+            # Filter out frameworks from auxiliary or tooling stacks (docs/, benchmarks/, etc.)
+            fw_names = [
+                f.name
+                for s in sm.stacks
+                if not self._is_tooling_path(s.root or "")
+                and not self._is_tooling_path(s.workspace or "")
+                and not self._is_auxiliary_path(s.root or "")
+                and not self._is_auxiliary_path(s.workspace or "")
+                for f in s.frameworks[:2]
+            ][:3]
+
         fw_str = f" using {', '.join(fw_names)}" if fw_names else ""
         if runtime:
             return f"{stack_label} {runtime.lower()}{fw_str}."
@@ -443,6 +475,12 @@ class ArchitectureSummarizer:
         except OSError:
             return None
 
+    def _is_auxiliary_path(self, path: str | None) -> bool:
+        if not path:
+            return False
+        parts = path.replace("\\", "/").strip("/").lower().split("/")
+        return any(p in _AUXILIARY_PATH_PARTS for p in parts)
+
     def _is_tooling_path(self, path: str | None) -> bool:
         if not path:
             return False

sourcecode/cli.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import time
 from pathlib import Path
 from typing import Any, Optional, cast
 
@@ -10,10 +11,53 @@ from sourcecode import __version__
 
 app = typer.Typer(
     name="sourcecode",
-    help="Genera un mapa de contexto estructurado del proyecto para agentes IA.",
+    help="Deterministic codebase context for AI coding agents.",
     add_completion=False,
 )
 
+telemetry_app = typer.Typer(help="Manage anonymous telemetry (opt-in).")
+app.add_typer(telemetry_app, name="telemetry")
+
+
+def _maybe_ask_consent() -> None:
+    """Show first-run consent prompt once, on interactive TTYs only."""
+    try:
+        from sourcecode.telemetry.config import has_been_asked, mark_asked, set_enabled
+        from sourcecode.telemetry.consent import ask_for_consent
+        if not has_been_asked():
+            enabled = ask_for_consent()
+            set_enabled(enabled)
+            if enabled:
+                typer.echo("Telemetry enabled. Thank you. Disable: sourcecode telemetry disable", err=True)
+            else:
+                typer.echo("Telemetry disabled. Enable anytime: sourcecode telemetry enable", err=True)
+    except Exception:
+        pass
+
+
+def _active_flags(
+    dependencies: bool, graph_modules: bool, docs: bool, full_metrics: bool,
+    semantics: bool, architecture: bool, git_context: bool, env_map: bool,
+    code_notes: bool, agent: bool, compact: bool, tree: bool, no_redact: bool,
+    fmt: str,
+) -> list[str]:
+    flags: list[str] = []
+    if agent: flags.append("--agent")
+    if compact: flags.append("--compact")
+    if dependencies: flags.append("--dependencies")
+    if graph_modules: flags.append("--graph-modules")
+    if docs: flags.append("--docs")
+    if full_metrics: flags.append("--full-metrics")
+    if semantics: flags.append("--semantics")
+    if architecture: flags.append("--architecture")
+    if git_context: flags.append("--git-context")
+    if env_map: flags.append("--env-map")
+    if code_notes: flags.append("--code-notes")
+    if tree: flags.append("--tree")
+    if no_redact: flags.append("--no-redact")
+    if fmt != "json": flags.append("--format")
+    return flags
+
 FORMAT_CHOICES = ["json", "yaml"]
 GRAPH_DETAIL_CHOICES = ["high", "medium", "full"]
 GRAPH_EDGE_CHOICES = {"imports", "calls", "contains", "extends"}
@@ -167,11 +211,17 @@ def main(
         help="Modo agente: output estructurado y sin ruido para consumo por IA. Incluye identidad, entrypoints, arquitectura, dependencias clave, señales operacionales y gaps. Sin arbol de ficheros ni secciones vacias.",
     ),
 ) -> None:
-    """Genera un mapa de contexto estructurado del proyecto en formato JSON o YAML."""
-    # When a subcommand (e.g. prepare-context) is invoked, skip the main analysis.
+    """Generate structured codebase context for AI coding agents."""
+    # First-run consent (skip for telemetry subcommand itself)
+    if ctx.invoked_subcommand != "telemetry":
+        _maybe_ask_consent()
+
+    # When a subcommand is invoked, skip the main analysis.
     if ctx.invoked_subcommand is not None:
         return
 
+    _t0 = time.monotonic()
+
     # Validar formato
     if format not in FORMAT_CHOICES:
         typer.echo(
@@ -555,6 +605,14 @@ def main(
                 semantic_summary=sem_sum,
             )
 
+    # Runtime architecture — classify workspace packages for structural summaries
+    if workspace_analysis.workspaces:
+        from sourcecode.runtime_classifier import RuntimeClassifier
+        sm.monorepo_packages = RuntimeClassifier().classify(
+            target,
+            [ws.path for ws in workspace_analysis.workspaces],
+        )
+
     # Phase 9: LLM Output Quality — poblar campos derivados
     from sourcecode.architecture_summary import ArchitectureSummarizer
     from sourcecode.summarizer import ProjectSummarizer
@@ -664,7 +722,26 @@ def main(
         else:
             content = json.dumps(raw_dict, indent=2, ensure_ascii=False)
 
-    # 5. Escribir output (CLI-04)
+    # 5. Telemetry (fire-and-forget, never blocks)
+    try:
+        from sourcecode import telemetry as _tel
+        _tel.record(
+            "execution_completed",
+            cmd="analyze",
+            flags=_active_flags(
+                dependencies, graph_modules, docs, full_metrics,
+                semantics, architecture, git_context, env_map,
+                code_notes, agent, compact, tree, no_redact, format,
+            ),
+            output_fmt=format,
+            file_count=len(sm.file_paths),
+            duration_s=time.monotonic() - _t0,
+            success=True,
+        )
+    except Exception:
+        pass
+
+    # 6. Escribir output (CLI-04)
     write_output(content, output=output)
 
 
@@ -796,3 +873,42 @@ def prepare_context_cmd(
         out["llm_prompt"] = builder.render_prompt(output)
 
     typer.echo(json.dumps(out, indent=2, ensure_ascii=False))
+
+
+# ── Telemetry commands ────────────────────────────────────────────────────────
+
+@telemetry_app.command("status")
+def telemetry_status() -> None:
+    """Show current telemetry setting."""
+    from sourcecode.telemetry.config import config_file_path, has_been_asked, is_enabled
+    enabled = is_enabled()
+    asked = has_been_asked()
+    status = "enabled" if enabled else "disabled"
+    typer.echo(f"Telemetry: {status}")
+    if not asked:
+        typer.echo("  (consent not yet shown — will prompt on next run)")
+    typer.echo(f"  Config: {config_file_path()}")
+    typer.echo("  Disable permanently: sourcecode telemetry disable")
+    typer.echo("  Or set env var:      SOURCECODE_TELEMETRY=0")
+
+
+@telemetry_app.command("enable")
+def telemetry_enable() -> None:
+    """Opt in to anonymous telemetry."""
+    from sourcecode.telemetry.config import set_enabled
+    from sourcecode import telemetry as _tel
+    set_enabled(True)
+    typer.echo("Telemetry enabled. Thank you — this helps improve sourcecode.")
+    typer.echo("What is collected: version, OS, commands, flags, duration, repo size range, errors.")
+    typer.echo("What is never collected: source code, paths, secrets, or any output content.")
+    typer.echo("Disable at any time: sourcecode telemetry disable")
+    _tel.record("telemetry_enabled", cmd="telemetry")
+
+
+@telemetry_app.command("disable")
+def telemetry_disable() -> None:
+    """Opt out of anonymous telemetry."""
+    from sourcecode.telemetry.config import set_enabled
+    set_enabled(False)
+    typer.echo("Telemetry disabled. No data will be collected or sent.")
+    typer.echo("Re-enable at any time: sourcecode telemetry enable")

sourcecode/detectors/nodejs.py

@@ -117,59 +117,149 @@ class NodejsDetector(AbstractDetector):
                 return package_manager
         return None
 
+    # Directories that indicate a non-production entry point
+    _AUXILIARY_DIRS: frozenset[str] = frozenset({
+        "benchmark", "benchmarks", "bench",
+        "example", "examples",
+        "demo", "demos",
+        "playground", "playgrounds",
+        "fixture", "fixtures",
+        "sandbox", "e2e", "docs",
+    })
+
     def _collect_entry_points(
         self, context: DetectionContext, package_json: dict[str, Any]
     ) -> list[EntryPoint]:
         entry_points: list[EntryPoint] = []
         seen: set[str] = set()
-        main = package_json.get("main")
-        if isinstance(main, str) and main.strip():
-            path = main.strip()
-            if path_exists_in_tree(context.file_tree, path):
-                seen.add(path)
-                entry_points.append(
-                    EntryPoint(
-                        path=path,
-                        stack="nodejs",
-                        kind="server",
-                        source="package.json",
-                        confidence="high",
-                    )
-                )
-
-        convention_candidates: list[str] = []
+
+        # Priority 1: package.json scripts — most reliable signal
+        scripts = package_json.get("scripts", {})
+        if isinstance(scripts, dict):
+            for script_name, script_cmd in scripts.items():
+                if not isinstance(script_cmd, str):
+                    continue
+                ep_type, kind = self._classify_script(script_name)
+                if ep_type is None:
+                    continue
+                # Extract file path from script command
+                path = self._extract_script_path(script_cmd, context)
+                if path and path not in seen and path_exists_in_tree(context.file_tree, path):
+                    seen.add(path)
+                    if not self._is_auxiliary_path(path):
+                        entry_points.append(EntryPoint(
+                            path=path,
+                            stack="nodejs",
+                            kind=kind,
+                            source="package.json#scripts",
+                            confidence="high",
+                            reason=f"script:{script_name}",
+                            evidence=f"scripts.{script_name} = {script_cmd!r:.80}",
+                            entrypoint_type=ep_type,
+                        ))
+
+        # Priority 2: package.json bin — CLI production entry points
         bin_field = package_json.get("bin")
+        bin_paths: list[str] = []
         if isinstance(bin_field, str) and bin_field.strip():
-            convention_candidates.append(bin_field.strip())
+            bin_paths.append(bin_field.strip())
         elif isinstance(bin_field, dict):
-            convention_candidates.extend(
-                str(value).strip() for value in bin_field.values() if isinstance(value, str) and value.strip()
+            bin_paths.extend(
+                str(v).strip() for v in bin_field.values()
+                if isinstance(v, str) and v.strip()
             )
+        for path in bin_paths:
+            if path not in seen and path_exists_in_tree(context.file_tree, path):
+                seen.add(path)
+                entry_points.append(EntryPoint(
+                    path=path,
+                    stack="nodejs",
+                    kind="cli",
+                    source="package.json#bin",
+                    confidence="high",
+                    reason="bin",
+                    evidence="declared in package.json bin field",
+                    entrypoint_type="production",
+                ))
 
-        convention_candidates.extend(
-            [
-                "server.js",
-                "src/index.js",
-                "src/index.ts",
-                "src/main.js",
-                "src/main.ts",
-                "src/main.tsx",
-                "app/page.tsx",
-                "pages/index.js",
-            ]
-        )
+        # Priority 3: package.json main (library/module entry)
+        main = package_json.get("main")
+        if isinstance(main, str) and main.strip():
+            path = main.strip()
+            if path not in seen and path_exists_in_tree(context.file_tree, path):
+                seen.add(path)
+                entry_points.append(EntryPoint(
+                    path=path,
+                    stack="nodejs",
+                    kind="server",
+                    source="package.json",
+                    confidence="high",
+                    entrypoint_type="production",
+                ))
 
-        for path in unique_strings(convention_candidates):
+        # Priority 4: filename conventions (last resort — penalize auxiliary dirs)
+        for path in [
+            "server.js", "server.ts",
+            "src/index.js", "src/index.ts",
+            "src/main.js", "src/main.ts", "src/main.tsx",
+            "app/page.tsx", "pages/index.js",
+        ]:
             if path in seen or not path_exists_in_tree(context.file_tree, path):
                 continue
+            ep_type = self._path_entrypoint_type(path)
             kind = "web" if path.startswith(("app/", "pages/")) else "server"
-            entry_points.append(
-                EntryPoint(
-                    path=path,
-                    stack="nodejs",
-                    kind=kind,
-                    source="convention",
-                    confidence="medium",
-                )
-            )
+            entry_points.append(EntryPoint(
+                path=path,
+                stack="nodejs",
+                kind=kind,
+                source="convention",
+                confidence="medium",
+                reason="convention",
+                entrypoint_type=ep_type,
+            ))
+
         return entry_points
+
+    def _classify_script(self, script_name: str) -> tuple[str | None, str]:
+        """Map script name → (entrypoint_type, kind). Returns (None, '') to skip."""
+        lower = script_name.lower()
+        if lower in ("start", "serve"):
+            return "production", "server"
+        if lower in ("dev", "develop", "watch"):
+            return "development", "server"
+        if lower in ("cli", "bin"):
+            return "production", "cli"
+        if "benchmark" in lower or lower == "bench":
+            return "benchmark", "script"
+        if lower.startswith("example") or lower.startswith("demo"):
+            return "example", "script"
+        return None, ""
+
+    def _extract_script_path(self, cmd: str, context: DetectionContext) -> str | None:
+        """Extract a likely source file path from a script command string."""
+        import shlex
+        try:
+            parts = shlex.split(cmd)
+        except ValueError:
+            parts = cmd.split()
+        # Skip executor prefixes: node, ts-node, tsx, nodemon, npx, etc.
+        _SKIP = {"node", "ts-node", "tsx", "nodemon", "npx", "pnpm", "yarn", "npm", "bun",
+                 "--inspect", "--inspect-brk", "--require", "-r", "run", "exec"}
+        for part in parts:
+            if part.startswith("-") or part in _SKIP or "=" in part:
+                continue
+            # It looks like a file path (has slash or known extension)
+            p = part.strip("'\"")
+            if ("/" in p or p.endswith((".js", ".ts", ".mjs", ".cjs"))) and not p.startswith("@"):
+                return p
+        return None
+
+    def _is_auxiliary_path(self, path: str) -> bool:
+        norm = path.replace("\\", "/")
+        parts = norm.split("/")
+        return any(p.lower() in self._AUXILIARY_DIRS for p in parts)
+
+    def _path_entrypoint_type(self, path: str) -> str:
+        if self._is_auxiliary_path(path):
+            return "example"
+        return "production"

sourcecode/graph_analyzer.py

@@ -15,6 +15,44 @@ GraphDetail = Literal["high", "medium", "full"]
 GraphImportance = Literal["high", "medium", "low"]
 
 
+# Node.js stdlib modules — omit from graph unless --graph-detail full
+_NODE_STDLIB: frozenset[str] = frozenset({
+    "fs", "fs/promises", "path", "os", "child_process", "process",
+    "net", "http", "https", "http2", "stream", "events", "util",
+    "crypto", "buffer", "url", "querystring", "string_decoder",
+    "readline", "repl", "assert", "dns", "dgram", "vm",
+    "worker_threads", "cluster", "module", "v8", "perf_hooks",
+    "async_hooks", "inspector", "tty", "zlib", "domain",
+    "timers", "timers/promises", "console", "constants",
+    "node:fs", "node:path", "node:os", "node:crypto", "node:buffer",
+    "node:stream", "node:events", "node:util", "node:http", "node:https",
+    "node:child_process", "node:process", "node:worker_threads",
+})
+
+# Python stdlib modules — omit from graph unless --graph-detail full
+_PYTHON_STDLIB: frozenset[str] = frozenset({
+    "os", "sys", "re", "io", "abc", "ast", "copy", "csv",
+    "enum", "functools", "itertools", "json", "logging", "math",
+    "pathlib", "random", "shutil", "string", "subprocess",
+    "threading", "time", "typing", "uuid", "warnings",
+    "collections", "contextlib", "dataclasses", "datetime",
+    "decimal", "difflib", "email", "glob", "hashlib", "hmac",
+    "http", "importlib", "inspect", "operator", "pickle",
+    "platform", "pprint", "queue", "signal", "socket",
+    "sqlite3", "stat", "struct", "tempfile", "textwrap",
+    "traceback", "unicodedata", "unittest", "urllib", "weakref",
+    "xml", "zipfile", "zlib",
+})
+
+# External packages that add noise without structural signal
+_NODE_NOISE_PACKAGES: frozenset[str] = frozenset({
+    "lodash", "moment", "date-fns", "uuid", "chalk", "debug",
+    "yargs", "commander", "dotenv", "cross-env",
+    "eslint", "prettier", "typescript", "ts-node",
+    "@types/node", "@types/react",
+})
+
+
 class GraphAnalyzer:
     """Construye un grafo estructural parcial y seguro del proyecto."""
 
@@ -908,7 +946,14 @@ class GraphAnalyzer:
                         )
                     )
                 else:
-                    limitations.append(f"node_external:{relative_path}:{spec}")
+                    # Silently skip stdlib and noise packages — they add no structural signal
+                    bare = spec.removeprefix("node:")
+                    root_pkg = bare.split("/")[0]
+                    if (spec not in _NODE_STDLIB
+                            and bare not in _NODE_STDLIB
+                            and root_pkg not in _NODE_STDLIB
+                            and root_pkg not in _NODE_NOISE_PACKAGES):
+                        limitations.append(f"node_external:{relative_path}:{spec}")
 
         return nodes, edges, limitations
 
@@ -1121,6 +1166,10 @@ class GraphAnalyzer:
     def _resolve_python_import(
         self, module_name: str, module_map: dict[str, str]
     ) -> Optional[str]:
+        # Skip stdlib modules — they add no structural signal to the project graph
+        root_module = module_name.split(".")[0]
+        if root_module in _PYTHON_STDLIB:
+            return None
         for path, candidate in module_map.items():
             if candidate == module_name:
                 return path

sourcecode/prepare_context.py

@@ -359,10 +359,15 @@ class TaskContextBuilder:
 
         # ── 2. Detect stacks + entry points ───────────────────────────────
         from sourcecode.detectors import ProjectDetector, build_default_detectors
+        from sourcecode.workspace import WorkspaceAnalyzer
 
         detector = ProjectDetector(build_default_detectors())
+        workspace_analysis = WorkspaceAnalyzer().analyze(self.root, manifests)
         stacks, entry_points, _ = detector.detect(self.root, file_tree, manifests)
-        stacks, project_type = detector.classify_results(file_tree, stacks, entry_points)
+        stacks, project_type = detector.classify_results(
+            file_tree, stacks, entry_points,
+            project_type_override="monorepo" if workspace_analysis.is_monorepo else None,
+        )
 
         # ── 3. Summarize ───────────────────────────────────────────────────
         from sourcecode.schema import AnalysisMetadata, SourceMap
@@ -378,6 +383,14 @@ class TaskContextBuilder:
         )
         sm.file_paths = all_paths
 
+        # Classify workspace packages for structural context
+        if workspace_analysis.workspaces:
+            from sourcecode.runtime_classifier import RuntimeClassifier
+            sm.monorepo_packages = RuntimeClassifier().classify(
+                self.root,
+                [ws.path for ws in workspace_analysis.workspaces],
+            )
+
         project_summary = ProjectSummarizer(self.root).generate(sm)
         architecture_summary = ArchitectureSummarizer(self.root).generate(sm)
 
@@ -436,13 +449,31 @@ class TaskContextBuilder:
                     for p, n in sorted(counts2.items(), key=lambda x: -x[1])[:8]
                 ]
 
+        # ── 5b. Git signals for ranking ────────────────────────────────────
+        git_hotspots: dict[str, int] = {}
+        uncommitted_files: set[str] = set()
+        try:
+            from sourcecode.git_analyzer import GitAnalyzer
+            _gc = GitAnalyzer().analyze(self.root, depth=30, days=90)
+            _bad = {"no_git_repo", "git_not_found", "git_timeout"}
+            if _gc and not (_bad & set(_gc.limitations)):
+                git_hotspots = {h.file: h.commit_count for h in _gc.change_hotspots}
+                if _gc.uncommitted_changes:
+                    _uc = _gc.uncommitted_changes
+                    uncommitted_files = set(_uc.staged) | set(_uc.unstaged)
+        except Exception:
+            pass
+
         # ── 6. Rank files ──────────────────────────────────────────────────
         entry_set = {ep.path for ep in entry_points}
         test_set = {p for p in all_paths if self._is_test(p)}
         source_set = {p for p in all_paths if not self._is_test(p) and self._is_source(p)}
 
         relevant_files = self._rank_files(
-            task_name, spec, all_paths, entry_set, test_set
+            task_name, spec, all_paths, entry_set, test_set,
+            monorepo_packages=sm.monorepo_packages if sm.monorepo_packages else None,
+            git_hotspots=git_hotspots,
+            uncommitted_files=uncommitted_files,
         )
 
         # ── 7. Test gaps (generate-tests only) ────────────────────────────
@@ -590,7 +621,21 @@ class TaskContextBuilder:
         all_paths: list[str],
         entry_set: set[str],
         test_set: set[str],
+        monorepo_packages: Optional[list] = None,
+        git_hotspots: Optional[dict[str, int]] = None,
+        uncommitted_files: Optional[set[str]] = None,
     ) -> list[RelevantFile]:
+        from sourcecode.relevance_scorer import RelevanceScorer
+        scorer = RelevanceScorer(monorepo_packages or [])
+
+        # Auxiliary entry points (benchmark, docs, examples) must not get
+        # the production entry boost — they are not runtime signals.
+        runtime_entry_set = {ep for ep in entry_set if not scorer.is_auxiliary(ep)}
+
+        _hotspots = git_hotspots or {}
+        _uncommitted = uncommitted_files or set()
+        _max_churn = max(_hotspots.values(), default=1)
+
         scored: list[tuple[float, RelevantFile]] = []
 
         for path in all_paths:
@@ -599,6 +644,10 @@ class TaskContextBuilder:
             if any(pen in path for pen in spec.ranking_penalties):
                 continue
 
+            # Hard filter: tooling/config noise
+            if scorer.is_noise(path):
+                continue
+
             is_test = path in test_set
             if is_test and task_name != "generate-tests":
                 continue
@@ -606,7 +655,8 @@ class TaskContextBuilder:
             score = 0.0
             reasons: list[str] = []
 
-            if path in entry_set:
+            # Only runtime entry points get the production boost
+            if path in runtime_entry_set:
                 score += 3.0
                 reasons.append("entry point")
 
@@ -625,11 +675,30 @@ class TaskContextBuilder:
                 if not reasons:
                     reasons.append("source file")
 
+            # Operational relevance boost/penalty from package role
+            rel = scorer.score(path)
+            score += (rel - 0.3) * 2.0  # center around 0.3 baseline
+
+            # Suppress auxiliary dirs (benchmarks, docs, examples, demos)
+            if scorer.is_auxiliary(path):
+                score -= 2.0
+
+            # Git churn: frequently changed files are high-signal for active work
+            churn = _hotspots.get(path, 0)
+            if churn > 0:
+                score += (churn / _max_churn) * 1.5
+                reasons.append(f"git churn ({churn})")
+
+            # Uncommitted changes: files actively being edited rank highest
+            if path in _uncommitted:
+                score += 1.0
+                reasons.append("uncommitted changes")
+
             if score <= 0:
                 continue
 
             role = (
-                "entrypoint" if path in entry_set
+                "entrypoint" if path in runtime_entry_set
                 else ("test" if is_test else "source")
             )
             scored.append((score, RelevantFile(