sourcecode 0.25.0__py3-none-any.whl → 0.26.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.26.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

@@ -555,6 +555,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

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(

sourcecode/relevance_scorer.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+"""Operational relevance scoring for files and directories.
+
+Returns a (relevance, noise) pair per path:
+  relevance: 0.0–1.0 — how useful is this for an agent modifying code
+  noise: bool       — should this be suppressed unless explicitly requested
+
+Key principle: signal over inventory. Tooling, config, and auxiliary content
+score low. Runtime core, entrypoints, and central modules score high.
+"""
+
+import re
+from pathlib import Path
+from typing import Optional
+
+from sourcecode.schema import MonorepoPackageInfo
+
+# --------------------------------------------------------------------------
+# Noise path patterns — suppress unless explicitly needed
+# --------------------------------------------------------------------------
+
+_NOISE_PREFIXES: frozenset[str] = frozenset({
+    "node_modules/",
+    ".git/",
+    "__pycache__/",
+    ".venv/",
+    "venv/",
+    ".mypy_cache/",
+    ".pytest_cache/",
+    "dist/",
+    "build/",
+    ".turbo/",
+    ".next/",
+    ".nuxt/",
+    "coverage/",
+    ".nyc_output/",
+})
+
+_NOISE_DIRS: frozenset[str] = frozenset({
+    "node_modules", "__pycache__", ".git", "dist", "build",
+    ".turbo", "coverage", ".nyc_output", ".next", ".nuxt",
+    ".venv", "venv", ".mypy_cache", ".pytest_cache",
+})
+
+_NOISE_SUFFIXES: frozenset[str] = frozenset({
+    ".lock", ".log", ".map", ".min.js", ".min.css",
+    ".snap", ".d.ts.map",
+})
+
+_TOOLING_FILENAMES: frozenset[str] = frozenset({
+    ".eslintrc", ".eslintrc.js", ".eslintrc.json", ".eslintrc.yaml", ".eslintrc.yml",
+    ".prettierrc", ".prettierrc.js", ".prettierrc.json",
+    "prettier.config.js", "prettier.config.ts",
+    "eslint.config.js", "eslint.config.ts",
+    ".editorconfig", ".gitignore", ".gitattributes",
+    "commitlint.config.js", "stylelint.config.js",
+    "jest.config.js", "jest.config.ts", "jest.config.json",
+    "vitest.config.ts", "vitest.config.js",
+    "webpack.config.js", "webpack.config.ts",
+    "vite.config.ts", "vite.config.js",
+    "rollup.config.js", "rollup.config.ts",
+    "babel.config.js", "babel.config.json",
+    ".babelrc", ".babelrc.js",
+    "tsconfig.json", "tsconfig.base.json",
+    ".dockerignore", "Makefile",
+    "lerna.json", "nx.json", "turbo.json",
+    "CHANGELOG.md", "LICENSE", "LICENSE.md",
+})
+
+_AUXILIARY_DIR_PATTERNS: list[re.Pattern[str]] = [
+    re.compile(r"(?:^|/)benchmark[s]?(?:/|$)"),
+    re.compile(r"(?:^|/)example[s]?(?:/|$)"),
+    re.compile(r"(?:^|/)demo[s]?(?:/|$)"),
+    re.compile(r"(?:^|/)playground[s]?(?:/|$)"),
+    re.compile(r"(?:^|/)fixture[s]?(?:/|$)"),
+    re.compile(r"(?:^|/)sandbox(?:/|$)"),
+    re.compile(r"(?:^|/)docs?(?:/|$)"),
+    re.compile(r"(?:^|/)\.github(?:/|$)"),
+    re.compile(r"(?:^|/)\.claude(?:/|$)"),
+    re.compile(r"(?:^|/)\.vscode(?:/|$)"),
+    re.compile(r"(?:^|/)scripts?(?:/|$)"),
+    re.compile(r"(?:^|/)tools?(?:/|$)"),
+    re.compile(r"(?:^|/)ci(?:/|$)"),
+]
+
+_HIGH_VALUE_SUFFIXES: frozenset[str] = frozenset({
+    ".py", ".ts", ".tsx", ".js", ".jsx", ".mjs",
+    ".go", ".java", ".kt", ".rs", ".rb", ".cs",
+})
+
+_ENTRYPOINT_STEMS: frozenset[str] = frozenset({
+    "main", "cli", "app", "server", "index", "__main__",
+    "application", "bootstrap", "entry",
+})
+
+
+class RelevanceScorer:
+    """Scores file paths by operational relevance for AI agents."""
+
+    def __init__(self, monorepo_packages: Optional[list[MonorepoPackageInfo]] = None) -> None:
+        self._pkg_roles: dict[str, str] = {}  # path_prefix → role
+        if monorepo_packages:
+            for pkg in monorepo_packages:
+                prefix = pkg.path.rstrip("/") + "/"
+                self._pkg_roles[prefix] = pkg.architectural_role
+
+    def score(self, path: str) -> float:
+        """Return operational relevance 0.0–1.0. Higher = more useful for agents."""
+        norm = path.replace("\\", "/").lstrip("/")
+
+        if self.is_noise(norm):
+            return 0.0
+
+        base = 0.3
+
+        # Package role boost
+        role = self._package_role(norm)
+        role_boost = {
+            "runtime_core": 0.4,
+            "plugin_host": 0.35,
+            "backend_runtime": 0.3,
+            "frontend_runtime": 0.25,
+            "composition_layer": 0.2,
+            "plugin_package": 0.15,
+            "infrastructure_layer": 0.15,
+            "tooling_layer": -0.1,
+            "docs_layer": -0.15,
+            "test_layer": 0.05,
+            "benchmark_layer": -0.2,
+        }.get(role, 0.0)
+        base += role_boost
+
+        # Source file boost
+        suffix = Path(norm).suffix.lower()
+        if suffix in _HIGH_VALUE_SUFFIXES:
+            base += 0.1
+
+        # Entrypoint stem boost
+        stem = Path(norm).stem.lower()
+        if stem in _ENTRYPOINT_STEMS:
+            base += 0.15
+
+        # Penalize auxiliary dirs
+        if self._is_auxiliary(norm):
+            base -= 0.2
+
+        return max(0.0, min(1.0, base))
+
+    def is_noise(self, path: str) -> bool:
+        """True if this file should be suppressed from default agent output."""
+        norm = path.replace("\\", "/").lstrip("/")
+
+        if any(norm.startswith(p) for p in _NOISE_PREFIXES):
+            return True
+
+        parts = norm.split("/")
+        if any(p in _NOISE_DIRS for p in parts):
+            return True
+
+        filename = Path(norm).name
+        if filename in _TOOLING_FILENAMES:
+            return True
+
+        for suffix in _NOISE_SUFFIXES:
+            if norm.endswith(suffix):
+                return True
+
+        return False
+
+    def is_auxiliary(self, path: str) -> bool:
+        """True if file is in a benchmark/example/demo/docs directory."""
+        return self._is_auxiliary(path.replace("\\", "/"))
+
+    def _is_auxiliary(self, norm: str) -> bool:
+        return any(p.search(norm) for p in _AUXILIARY_DIR_PATTERNS)
+
+    def _package_role(self, norm: str) -> str:
+        for prefix, role in self._pkg_roles.items():
+            if norm.startswith(prefix):
+                return role
+        return "unknown"

sourcecode/runtime_classifier.py

@@ -0,0 +1,331 @@
+from __future__ import annotations
+
+"""Classifies workspace packages into architectural roles using weighted inference.
+
+Signal priority (descending):
+  scripts.start/serve → runtime_core/backend_runtime
+  scripts.cli/bin     → runtime_core (CLI tool)
+  runtime dep imports → backend_runtime / frontend_runtime
+  name/path patterns  → specialized roles
+  fan-in              → weak corroboration only, NEVER sole driver
+"""
+
+import json
+import re
+from pathlib import Path
+from typing import Any
+
+from sourcecode.schema import MonorepoPackageInfo
+
+# --------------------------------------------------------------------------
+# Noise / negative patterns — packages matching these are NOT runtime_core
+# regardless of fan-in.
+# --------------------------------------------------------------------------
+
+_NEGATIVE_RUNTIME_CORE: list[re.Pattern[str]] = [
+    re.compile(r"(?:^|/)utils?(?:/|$)"),
+    re.compile(r"(?:^|/)shared(?:/|$)"),
+    re.compile(r"(?:^|/)types?(?:/|$)"),
+    re.compile(r"(?:^|/)config(?:s)?(?:/|$)"),
+    re.compile(r"(?:^|/)common(?:/|$)"),
+    re.compile(r"(?:^|/)helpers?(?:/|$)"),
+    re.compile(r"(?:^|/)constants?(?:/|$)"),
+    re.compile(r"(?:^|/)fixture[s]?(?:/|$)"),
+    re.compile(r"(?:^|/)tooling(?:/|$)"),
+    re.compile(r"(?:^|/)preset[s]?(?:/|$)"),
+    re.compile(r"(?:^|/)theme[s]?(?:/|$)"),
+    re.compile(r"(?:^|/)i18n(?:/|$)"),
+    re.compile(r"(?:^|/)locale[s]?(?:/|$)"),
+]
+
+_NEGATIVE_NAME_RUNTIME_CORE: list[re.Pattern[str]] = [
+    re.compile(r"\butils?\b"),
+    re.compile(r"\bshared\b"),
+    re.compile(r"\btypes?\b"),
+    re.compile(r"\bconfig\b"),
+    re.compile(r"\bcommon\b"),
+    re.compile(r"\bhelpers?\b"),
+    re.compile(r"\bconstants?\b"),
+    re.compile(r"\bfixtures?\b"),
+    re.compile(r"\btooling\b"),
+    re.compile(r"\btheme[s]?\b"),
+    re.compile(r"\bi18n\b"),
+    re.compile(r"\blocale[s]?\b"),
+    re.compile(r"\bpreset[s]?\b"),
+    re.compile(r"eslint|prettier|lint|format"),
+]
+
+# --------------------------------------------------------------------------
+# Role-determining pattern tables
+# --------------------------------------------------------------------------
+
+_PATH_SIGNALS: list[tuple[re.Pattern[str], str, int]] = [
+    (re.compile(r"benchmark|bench"),                                               "benchmark_layer",    4),
+    (re.compile(r"(?:^|/)docs?(?:/|$)"),                                          "docs_layer",         4),
+    (re.compile(r"(?:^|/)tests?(?:/|$)|(?:^|/)specs?(?:/|$)|(?:^|/)e2e(?:/|$)"), "test_layer",         4),
+    (re.compile(r"example|demo|playground|fixture|sandbox"),                       "benchmark_layer",    3),
+    (re.compile(r"(?:^|/)plugins?(?:/|$)"),                                        "plugin_package",     3),
+    (re.compile(r"(?:^|/)presets?(?:/|$)"),                                        "composition_layer",  3),
+    (re.compile(r"infra(?:structure)?"),                                            "infrastructure_layer", 2),
+    (re.compile(r"(?:^|/)client(?:/|$)|(?:^|/)web(?:/|$)|(?:^|/)ui(?:/|$)"),     "frontend_runtime",   2),
+    (re.compile(r"(?:^|/)server(?:/|$)"),                                          "backend_runtime",    3),
+    (re.compile(r"(?:^|/)app(?:/|$)"),                                             "backend_runtime",    2),
+]
+
+_NAME_SIGNALS: list[tuple[re.Pattern[str], str, int]] = [
+    (re.compile(r"benchmark|bench"),                                  "benchmark_layer",    4),
+    (re.compile(r"\bplugin"),                                         "plugin_package",     3),
+    (re.compile(r"\bpreset"),                                         "composition_layer",  3),
+    (re.compile(r"client|web|react|frontend|\bui\b"),                 "frontend_runtime",   2),
+    (re.compile(r"\bserver\b|\bapi\b|\bbackend\b"),                   "backend_runtime",    3),
+    (re.compile(r"database|db|storage|cache|queue|redis|pg|sql"),     "infrastructure_layer", 2),
+    (re.compile(r"\bcore\b|\bkernel\b|\bruntime\b|\bengine\b|\bapp\b"), "runtime_core",     2),
+    (re.compile(r"test|spec|e2e"),                                    "test_layer",         3),
+    (re.compile(r"lint|format|build|webpack|vite|eslint|prettier|tsconfig"), "tooling_layer", 3),
+    (re.compile(r"docs?$"),                                           "docs_layer",         3),
+]
+
+# Scripts that provide hard runtime evidence
+_RUNTIME_SCRIPTS: frozenset[str] = frozenset({"start", "serve", "server"})
+_DEV_SCRIPTS: frozenset[str] = frozenset({"dev", "develop", "watch"})
+_CLI_SCRIPTS: frozenset[str] = frozenset({"cli", "bin", "run"})
+
+_SCRIPT_SIGNALS: dict[str, tuple[str, int]] = {
+    "start":     ("backend_runtime", 4),
+    "serve":     ("backend_runtime", 4),
+    "server":    ("backend_runtime", 4),
+    "cli":       ("backend_runtime", 3),
+    "dev":       ("backend_runtime", 2),
+    "develop":   ("backend_runtime", 2),
+    "benchmark": ("benchmark_layer", 4),
+    "bench":     ("benchmark_layer", 4),
+    "test":      ("test_layer",      3),
+    "lint":      ("tooling_layer",   2),
+    "format":    ("tooling_layer",   2),
+}
+
+_DEP_SIGNALS: list[tuple[re.Pattern[str], str, int]] = [
+    (re.compile(r"^react$|^vue$|^@angular/core$|^svelte$"),               "frontend_runtime",    3),
+    (re.compile(r"^express$|^fastify$|^koa$|^@nestjs/core$|^hono$|^elysia$"), "backend_runtime", 3),
+    (re.compile(r"^sequelize$|^prisma$|^typeorm$|^mongoose$|^knex$|^pg$"),"infrastructure_layer",2),
+    (re.compile(r"^jest$|^mocha$|^vitest$|^cypress$|^playwright$"),       "test_layer",          3),
+    (re.compile(r"^eslint$|^prettier$"),                                   "tooling_layer",       2),
+]
+
+_ROLE_PRIORITY: dict[str, int] = {
+    "runtime_core":        10,
+    "plugin_host":          9,
+    "backend_runtime":      8,
+    "composition_layer":    7,
+    "frontend_runtime":     6,
+    "plugin_package":       5,
+    "infrastructure_layer": 4,
+    "test_layer":           3,
+    "docs_layer":           3,
+    "tooling_layer":        3,
+    "benchmark_layer":      3,
+    "unknown":              0,
+}
+
+_NOISE_ROLES = frozenset({"benchmark_layer", "test_layer", "docs_layer", "tooling_layer"})
+
+
+class RuntimeClassifier:
+    """Classifies workspace packages by architectural role."""
+
+    def classify(self, root: Path, workspace_paths: list[str]) -> list[MonorepoPackageInfo]:
+        raw: list[tuple[str, dict[str, Any]]] = []
+        for ws_path in workspace_paths:
+            pkg_root = root / ws_path
+            if pkg_root.is_dir():
+                raw.append((ws_path, self._load_pkg_json(pkg_root)))
+
+        fan_in = self._compute_fan_in(raw)
+        results: list[MonorepoPackageInfo] = []
+
+        for ws_path, pkg_json in raw:
+            name = str(pkg_json.get("name", ws_path)) if pkg_json else ws_path
+            role, signals, conf = self._score_package(ws_path, name, pkg_json, fan_in.get(ws_path, 0))
+
+            # plugin_host detection (independent of runtime_core path)
+            if role not in _NOISE_ROLES and self._detect_plugin_host(pkg_json, ws_path, fan_in.get(ws_path, 0)):
+                role = "plugin_host"
+                signals.append("plugin_host:inferred")
+
+            criticality = self._criticality(role, fan_in.get(ws_path, 0))
+            results.append(MonorepoPackageInfo(
+                path=ws_path,
+                name=name,
+                architectural_role=role,
+                criticality=criticality,
+                confidence=conf,
+                role_signals=signals,
+            ))
+
+        return results
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _load_pkg_json(self, pkg_root: Path) -> dict[str, Any]:
+        try:
+            content = (pkg_root / "package.json").read_text(encoding="utf-8", errors="replace")
+            return json.loads(content)  # type: ignore[no-any-return]
+        except Exception:
+            return {}
+
+    def _compute_fan_in(self, raw: list[tuple[str, dict[str, Any]]]) -> dict[str, int]:
+        name_to_path: dict[str, str] = {}
+        for ws_path, pkg_json in raw:
+            name = str(pkg_json.get("name", "")) if pkg_json else ""
+            if name:
+                name_to_path[name] = ws_path
+
+        fan_in: dict[str, int] = {}
+        for _, pkg_json in raw:
+            if not pkg_json:
+                continue
+            for field in ("dependencies", "devDependencies", "peerDependencies"):
+                for dep_name in pkg_json.get(field, {}):
+                    target_path = name_to_path.get(str(dep_name))
+                    if target_path:
+                        fan_in[target_path] = fan_in.get(target_path, 0) + 1
+        return fan_in
+
+    def _has_runtime_evidence(self, pkg_json: dict[str, Any], ws_path: str) -> bool:
+        """True only when package has explicit evidence of being a running process."""
+        if not pkg_json:
+            return False
+        # bin field = CLI/server executable
+        if pkg_json.get("bin"):
+            return True
+        # start/serve/server script = runtime entry point
+        scripts = pkg_json.get("scripts") or {}
+        if isinstance(scripts, dict):
+            if _RUNTIME_SCRIPTS & set(scripts.keys()):
+                return True
+        return False
+
+    def _is_utility_package(self, ws_path: str, name: str) -> bool:
+        """True for packages that are libraries/utilities, NOT runtime processes."""
+        path_lower = ws_path.lower().replace("\\", "/")
+        name_lower = (name or "").lower()
+        return (
+            any(p.search(path_lower) for p in _NEGATIVE_RUNTIME_CORE)
+            or any(p.search(name_lower) for p in _NEGATIVE_NAME_RUNTIME_CORE)
+        )
+
+    def _score_package(
+        self, ws_path: str, name: str, pkg_json: dict[str, Any], fan_in: int
+    ) -> tuple[str, list[str], str]:
+        scores: dict[str, float] = {}
+        signals: list[str] = []
+
+        path_lower = ws_path.lower().replace("\\", "/")
+        name_lower = name.lower() if name else ""
+
+        for pattern, role, weight in _PATH_SIGNALS:
+            if pattern.search(path_lower):
+                scores[role] = scores.get(role, 0) + weight
+                signals.append(f"path:{role}")
+                break  # one path signal per package
+
+        for pattern, role, weight in _NAME_SIGNALS:
+            if pattern.search(name_lower):
+                scores[role] = scores.get(role, 0) + weight
+                signals.append(f"name:{role}")
+                break
+
+        if pkg_json:
+            scripts = pkg_json.get("scripts", {}) or {}
+            if isinstance(scripts, dict):
+                for script_name, (role, weight) in _SCRIPT_SIGNALS.items():
+                    if script_name in scripts:
+                        scores[role] = scores.get(role, 0) + weight
+                        signals.append(f"script:{script_name}")
+
+            # bin = CLI tool or server executable; strong runtime signal
+            if pkg_json.get("bin"):
+                scores["backend_runtime"] = scores.get("backend_runtime", 0) + 3
+                signals.append("bin:declared")
+
+            # exports/main: weak lib signal only — do NOT boost runtime_core
+            if pkg_json.get("exports") or pkg_json.get("main"):
+                signals.append("exports:declared")
+
+            prod_deps: set[str] = set()
+            for field in ("dependencies", "peerDependencies"):
+                dep_map = pkg_json.get(field) or {}
+                if isinstance(dep_map, dict):
+                    prod_deps.update(str(k) for k in dep_map)
+
+            for dep_name in prod_deps:
+                for pattern, role, weight in _DEP_SIGNALS:
+                    if pattern.search(dep_name.lower()):
+                        scores[role] = scores.get(role, 0) + weight
+                        break
+
+        # Fan-in: weak corroboration only (+1 per point, capped at 2)
+        # Never sole driver — it boosts the CURRENT leading role, not runtime_core
+        if fan_in >= 2:
+            signals.append(f"fan_in:{fan_in}")
+            fan_boost = min(fan_in, 2)
+            if scores:
+                # Boost whatever role is currently winning
+                current_best = max(scores, key=lambda r: (scores[r], _ROLE_PRIORITY.get(r, 0)))
+                scores[current_best] = scores.get(current_best, 0) + fan_boost
+            # No scores yet (purely utility pkg): high fan-in → infrastructure_layer
+            else:
+                scores["infrastructure_layer"] = scores.get("infrastructure_layer", 0) + fan_boost
+
+        if not scores:
+            return "unknown", signals, "low"
+
+        best_role = max(scores, key=lambda r: (scores[r], _ROLE_PRIORITY.get(r, 0)))
+        best_score = scores[best_role]
+
+        # Promote backend_runtime → runtime_core only with explicit runtime evidence
+        # AND not a utility/shared package
+        if best_role == "backend_runtime" and self._has_runtime_evidence(pkg_json, ws_path):
+            if not self._is_utility_package(ws_path, name):
+                best_role = "runtime_core"
+                signals.append("promoted:has_runtime_evidence")
+
+        # Hard guard: runtime_core NEVER assigned to utility packages
+        if best_role == "runtime_core" and self._is_utility_package(ws_path, name):
+            # Downgrade: utility with high fan-in → infrastructure_layer
+            best_role = "infrastructure_layer"
+            signals.append("demoted:utility_package")
+
+        conf = "high" if best_score >= 6 else "medium" if best_score >= 3 else "low"
+        return best_role, signals, conf
+
+    def _detect_plugin_host(self, pkg_json: dict[str, Any], ws_path: str, fan_in: int) -> bool:
+        if fan_in < 2:
+            return False
+        path_lower = ws_path.lower()
+        if "plugin" in path_lower or "benchmark" in path_lower:
+            return False
+        if not pkg_json:
+            return False
+        name = str(pkg_json.get("name", "")).lower()
+        if "plugin" in name:
+            return False
+        scripts = pkg_json.get("scripts", {}) or {}
+        if isinstance(scripts, dict):
+            if any("plugin" in str(k).lower() or "plugin" in str(v).lower()
+                   for k, v in scripts.items()):
+                return True
+        exports = pkg_json.get("exports") or {}
+        if isinstance(exports, dict):
+            if any("plugin" in str(k).lower() for k in exports):
+                return True
+        return False
+
+    def _criticality(self, role: str, fan_in: int) -> str:
+        if role in {"runtime_core", "plugin_host"}:
+            return "high"
+        if role in {"backend_runtime", "frontend_runtime", "composition_layer"} or fan_in >= 3:
+            return "medium"
+        return "low"

sourcecode/schema.py

@@ -72,6 +72,7 @@ class EntryPoint:
     confidence: Literal["high", "medium", "low"] = "high"
     reason: Optional[str] = None   # console_script | entry_file_pattern | main_guard | typer_app | heuristic | convention
     evidence: Optional[str] = None  # brief evidence string
+    entrypoint_type: Optional[Literal["production", "development", "benchmark", "example"]] = None
 
 
 @dataclass
@@ -307,6 +308,36 @@ class SemanticSummary:
     limitations: list[str] = field(default_factory=list)
 
 
+# --- Runtime Architecture ---
+
+ArchitecturalRole = Literal[
+    "runtime_core",
+    "plugin_host",
+    "plugin_package",
+    "frontend_runtime",
+    "backend_runtime",
+    "composition_layer",
+    "infrastructure_layer",
+    "tooling_layer",
+    "docs_layer",
+    "test_layer",
+    "benchmark_layer",
+    "unknown",
+]
+
+
+@dataclass
+class MonorepoPackageInfo:
+    """Classified workspace package with architectural role and criticality."""
+
+    path: str
+    name: str
+    architectural_role: str  # ArchitecturalRole value
+    criticality: Literal["high", "medium", "low"] = "low"
+    confidence: Literal["high", "medium", "low"] = "low"
+    role_signals: list[str] = field(default_factory=list)
+
+
 # --- Phase 13 Plan 04: Architectural Inference ---
 
 @dataclass
@@ -547,8 +578,10 @@ class SourceMap:
     code_notes: list[CodeNote] = field(default_factory=list)
     code_adrs: list[AdrRecord] = field(default_factory=list)
     code_notes_summary: Optional[CodeNotesSummary] = None
-    # Confidence & Explainability (v0.25.0)
+    # Confidence & Explainability (v0.26.0)
     confidence_summary: Optional[ConfidenceSummary] = None
     analysis_gaps: list[AnalysisGap] = field(default_factory=list)
-    # AI context summary (v0.25.0)
+    # AI context summary (v0.26.0)
     context_summary: Optional[ContextSummary] = None
+    # Runtime architecture (v0.26.0)
+    monorepo_packages: list[MonorepoPackageInfo] = field(default_factory=list)

sourcecode/serializer.py

@@ -410,18 +410,48 @@ def agent_view(sm: SourceMap) -> dict[str, Any]:
 
     result: dict[str, Any] = {"project": project}
 
-    # ── 2. Entry points (with reason/evidence when available) ─────────────────
+    # ── 2. Entry points: production/runtime first, benchmark/example excluded ──
     if sm.entry_points:
         _ep_skip = {"workspace"}
-        result["entry_points"] = [
+        _aux_parts = frozenset({
+            "benchmark", "benchmarks", "bench", "demo", "demos",
+            "example", "examples", "docs", "doc", "fixtures", "fixture",
+        })
+
+        def _ep_priority(ep_dict: dict[str, Any]) -> int:
+            ep_type = ep_dict.get("entrypoint_type")
+            if ep_type in ("benchmark", "example"):
+                return 10
+            path_parts = ep_dict.get("path", "").replace("\\", "/").lower().split("/")
+            if any(p in _aux_parts for p in path_parts):
+                return 5
+            if ep_type == "development":
+                return 3
+            return 0
+
+        all_ep = [
             {k: v for k, v in asdict(ep).items() if v is not None and v != "" and k not in _ep_skip}
             for ep in sm.entry_points
         ]
+        all_ep.sort(key=_ep_priority)
+        operational_ep = [ep for ep in all_ep if _ep_priority(ep) < 5]
+        result["entry_points"] = operational_ep if operational_ep else all_ep
 
     # ── 3. Architecture ───────────────────────────────────────────────────────
     if sm.architecture_summary:
         result["architecture"] = sm.architecture_summary
 
+    # ── 3b. Monorepo package roles (when available) ───────────────────────────
+    if sm.monorepo_packages:
+        _noise_roles = {"benchmark_layer", "tooling_layer", "docs_layer", "test_layer"}
+        operational_pkgs = [
+            {"path": p.path, "role": p.architectural_role, "criticality": p.criticality}
+            for p in sm.monorepo_packages
+            if p.architectural_role not in _noise_roles
+        ]
+        if operational_pkgs:
+            result["runtime_packages"] = operational_pkgs
+
     # ── 4. Key dependencies (role-sorted, already computed) ───────────────────
     if sm.dependency_summary and sm.dependency_summary.requested and sm.key_dependencies:
         _dep_skip = {"parent", "manifest_path", "workspace", "source", "ecosystem"}

sourcecode/summarizer.py

@@ -6,9 +6,10 @@ Sin llamadas a API — solo templates aplicados sobre SourceMap.
 """
 
 from pathlib import Path
+from typing import Any
 
 from sourcecode.detectors.parsers import load_json_file, load_toml_file
-from sourcecode.schema import SourceMap
+from sourcecode.schema import MonorepoPackageInfo, SourceMap
 
 _TOOLING_PREFIXES = (".claude/", ".vscode/", "bin/")
 _SRC_TRANSPARENT = {"src", "lib", "app", "pkg"}
@@ -75,6 +76,11 @@ class ProjectSummarizer:
             return "Proyecto analizado."
 
     def _build_summary(self, sm: SourceMap) -> str:
+        # For monorepos with classified packages, structural inference beats README
+        if sm.project_type == "monorepo" and sm.monorepo_packages:
+            dep_part = self._build_dep_part(sm)
+            return self._build_monorepo_structural_summary(sm, dep_part)
+
         description = self._read_project_description()
         if description:
             return self._merge_description_with_structure(description, sm)
@@ -107,6 +113,9 @@ class ProjectSummarizer:
         dep_part = self._build_dep_part(sm)
 
         if project_type == "monorepo":
+            # Prefer structural inference over README for monorepos
+            if sm.monorepo_packages:
+                return self._build_monorepo_structural_summary(sm, dep_part)
             stacks_desc = ", ".join(sorted({s.stack.capitalize() for s in non_tooling_stacks}))
             n_ws = len({s.workspace for s in non_tooling_stacks if s.workspace})
             ws_part = f" con {n_ws} workspaces" if n_ws > 0 else ""
@@ -266,6 +275,71 @@ class ProjectSummarizer:
         sorted_domains = sorted(domain_counts.items(), key=lambda x: x[1], reverse=True)
         return [name for name, _ in sorted_domains[:5]]
 
+    def _build_monorepo_structural_summary(self, sm: SourceMap, dep_part: str) -> str:
+        pkgs = sm.monorepo_packages
+        total = len(pkgs)
+
+        # Group by role
+        by_role: dict[str, list[MonorepoPackageInfo]] = {}
+        for p in pkgs:
+            by_role.setdefault(p.architectural_role, []).append(p)
+
+        runtime_roles = {"runtime_core", "backend_runtime", "plugin_host"}
+        frontend_roles = {"frontend_runtime"}
+        plugin_roles = {"plugin_package"}
+        noise_roles = {"benchmark_layer", "tooling_layer", "docs_layer", "test_layer"}
+
+        runtime_pkgs = [p for r in runtime_roles for p in by_role.get(r, [])]
+        frontend_pkgs = [p for r in frontend_roles for p in by_role.get(r, [])]
+        plugin_pkgs = by_role.get("plugin_package", [])
+        composition_pkgs = by_role.get("composition_layer", [])
+        noise_count = sum(len(by_role.get(r, [])) for r in noise_roles)
+
+        # Detect plugin system
+        has_plugin_system = bool(plugin_pkgs) or bool(by_role.get("plugin_host"))
+
+        # Determine primary language
+        non_tooling = [s for s in sm.stacks if not self._is_tooling_path(s.root) and not self._is_tooling_path(s.workspace)]
+        lang_set = sorted({s.stack.capitalize() for s in non_tooling})
+        lang_desc = "/".join(lang_set[:2]) if lang_set else "TypeScript"
+
+        parts: list[str] = []
+
+        # Headline: type + language + key architecture signal
+        if has_plugin_system:
+            parts.append(f"Plugin-driven {lang_desc} monorepo with {total} packages.")
+        else:
+            ws_label = f"{total} packages" if total > 1 else "monorepo"
+            parts.append(f"{lang_desc} monorepo ({ws_label}).")
+
+        # Runtime core
+        if runtime_pkgs:
+            core_paths = ", ".join(p.path for p in runtime_pkgs[:4])
+            parts.append(f"Runtime core: {core_paths}.")
+
+        # Plugin packages (if plugin system detected)
+        if plugin_pkgs:
+            n_plugins = len(plugin_pkgs)
+            plugin_paths = ", ".join(p.path for p in plugin_pkgs[:3])
+            extra = f" (+ {n_plugins - 3} more)" if n_plugins > 3 else ""
+            parts.append(f"{n_plugins} plugin packages: {plugin_paths}{extra}.")
+
+        # Frontend
+        if frontend_pkgs:
+            fe_paths = ", ".join(p.path for p in frontend_pkgs[:3])
+            parts.append(f"Frontend runtime: {fe_paths}.")
+
+        # Composition/presets
+        if composition_pkgs:
+            comp_paths = ", ".join(p.path for p in composition_pkgs[:2])
+            parts.append(f"Composition layer: {comp_paths}.")
+
+        # Noise info (non-critical)
+        if noise_count > 0:
+            parts.append(f"{noise_count} auxiliary packages (tests/benchmarks/tooling — non-critical).")
+
+        return " ".join(parts) + dep_part
+
     def _build_dep_part(self, sm: SourceMap) -> str:
         if sm.dependency_summary and sm.dependency_summary.total_count > 0:
             ds = sm.dependency_summary

{sourcecode-0.25.0.dist-info → sourcecode-0.26.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 0.25.0
+Version: 0.26.0
 Summary: Genera un mapa de contexto estructurado de proyectos de software para agentes IA
 License: MIT
 Requires-Python: >=3.9

{sourcecode-0.25.0.dist-info → sourcecode-0.26.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
-sourcecode/__init__.py,sha256=VAs5D8vi_Ge5ynS03-USMO8DYf9wFvnsVKninR3VGz8,100
+sourcecode/__init__.py,sha256=KWokO203w00OE-dSv_Mo5TSB7XXds2ISCqZJXXjyH1k,100
 sourcecode/architecture_analyzer.py,sha256=h81uQuSlxAorHve7M4jzXLT2PStOaGRMTlEPgW9zvxo,19741
-sourcecode/architecture_summary.py,sha256=_-M0TfPAacdFdakUOWQBZZ1HjQTXp7a5EVGkX9H9sbg,18483
+sourcecode/architecture_summary.py,sha256=qolHmn6MWUIQHzY9WeHcfN41EJkQdnPQ5F_Z8pqQasA,20251
 sourcecode/classifier.py,sha256=Ft_RfYS-KOe0t7vjgUx04OoCJd1-DXK7k9-I0CFDSnU,6934
-sourcecode/cli.py,sha256=SyO5JHR0cKMoMEas-of1pnWneZMjr7JhTxURR7-Kv5w,30925
+sourcecode/cli.py,sha256=-u4HmXhrJE5II5ohFbg_uVTlFXcMPhXf3RIl1YPLhIk,31278
 sourcecode/code_notes_analyzer.py,sha256=rRd8bFYV0krjlxxQV0wenwE9K7pVpUQSR7KvSvUQKw4,9226
 sourcecode/confidence_analyzer.py,sha256=gvQ92XCeGsACskSGU-GWTB7OqU1tT0eTgV-A7XA_lGs,8968
 sourcecode/context_summarizer.py,sha256=CiQrfBEzun949bWvmLabWoj2HhPn6Lw62ofqnsy0FlQ,6503
@@ -11,15 +11,17 @@ sourcecode/dependency_analyzer.py,sha256=Exq0BfInvfS5iAg9xAr6WI2uPNuotkIudTKcYJc
 sourcecode/doc_analyzer.py,sha256=Ec3orx6vBKsh5cNM3-F4y2Got2KuKx8w3dErwtdtM-A,19891
 sourcecode/env_analyzer.py,sha256=JZxBOuIxnM0xw0IaJFL6LiPJBErL848L3XoTOHGBqZI,13554
 sourcecode/git_analyzer.py,sha256=S9PGt8RDasBQYQUsZh9-H_KWVlPvzwR4jgM7TKN9ZCk,7643
-sourcecode/graph_analyzer.py,sha256=iJa9VAOG6R234otnsqPfUS8VGrb2GuoXnhyP-p8nCxo,61701
+sourcecode/graph_analyzer.py,sha256=hMOsLLz9B0UnQ4xwbHdgr3bFvqpw0bQ8kN-xmEn3Krk,64156
 sourcecode/metrics_analyzer.py,sha256=4uh11v-Q0gdrN87BOxuFWUym3N3AOkOuy21K5N8peB8,20126
-sourcecode/prepare_context.py,sha256=ktVlTUa3VU6A0Q5r8EhZq0g97BKoFfndqwSPfeLzlqo,27701
+sourcecode/prepare_context.py,sha256=--lD2dhNkBYI8kwb14d1DlFmEN8XF1Ygtf0Qk7-Y1Bs,30911
 sourcecode/redactor.py,sha256=xuGcadGEHaPw4qZXlMDvzMCsr4VOkdp3oBQptHyJk8c,2884
+sourcecode/relevance_scorer.py,sha256=2yvxDFnz9YGrHEJubgx9soiVIDZHKv_pntOtTARtKow,5928
+sourcecode/runtime_classifier.py,sha256=zWX3r3HCKHc-qtIobErOa8aKMmaoPYREtJKvPcBGPjQ,14792
 sourcecode/scanner.py,sha256=aM3h9-DCQ3xKpeHpHYdo2vX6T5P95HA_YwZbkAVNwmo,8288
-sourcecode/schema.py,sha256=fcglVk6IklJa0UIWakZgSxTSuqpbbBORKH89GsUmBZM,18262
+sourcecode/schema.py,sha256=c2ADsc0MDtsCJ6TIFqEfjhkCsSeFhIY0XhXc8BqfrrQ,19208
 sourcecode/semantic_analyzer.py,sha256=asQfJf-EhzYaOTA-iMuZsrVXtbW7SV2WEKCxgsxa88Y,79413
-sourcecode/serializer.py,sha256=DgMHKQMF-lPtKw5ebV4OzGBAHBaoygEQwHwvZch7ePg,25385
-sourcecode/summarizer.py,sha256=YdIA5gGEc0XSctPgmTnFnuZI72bprrOYhkJNoDmvHwM,12114
+sourcecode/serializer.py,sha256=k8ffuXNkjkBSU8RNad3lv_89FdRbJ7qdEmhD988X_Sw,26756
+sourcecode/summarizer.py,sha256=YfBixsN1zWHHXdOEqaf793BylbJrsj75ST7FN6jcqRU,15424
 sourcecode/tree_utils.py,sha256=Fj9OIuUksBvgibNd3feog0sMDjVypJzPexp5lvMoYWI,1424
 sourcecode/workspace.py,sha256=fQlVoNx8S-fSHpKoJ0JBvEHCFkxszH0KZVJed1i3TRk,6845
 sourcecode/detectors/__init__.py,sha256=A0AACJFF6HWf_RgatNtWu3PUzstcKtIGM9f1PoFcJug,1987
@@ -33,7 +35,7 @@ sourcecode/detectors/heuristic.py,sha256=JWb_dXNI1YDxk9a3DFeXTbKYfAGOFqV6jVxxqou
 sourcecode/detectors/hybrid.py,sha256=IGFRUVsAZ1ooRlFdznCeJAV6vy1yVDx-VyghvLtddXc,9101
 sourcecode/detectors/java.py,sha256=cZvB13cqJ76zHDncEG-TOCuK8gJjJN2mZGS2DGEcZy8,7715
 sourcecode/detectors/jvm_ext.py,sha256=EgHJ5W8EE-ZTN9V607mVzohyKgZE8Mc2jCi-DF8RAZU,2616
-sourcecode/detectors/nodejs.py,sha256=IPcyKvOMjEFBYpBpSsgN1B0M-uEl9lcn6DJt6XzJ4Tc,6393
+sourcecode/detectors/nodejs.py,sha256=BOGaghCC0nAZRvsib9Tptvr3-dJOzASnDPicXHez80c,10550
 sourcecode/detectors/parsers.py,sha256=ugPg8yNUf0Ai1gA7Fnn6wAkYGFjTxRodSP3IeViYJJ4,2290
 sourcecode/detectors/php.py,sha256=W_AQD0WMVDdWHa9h_ilX6W8XSpz0X4ctpMK2WXfXf1I,1887
 sourcecode/detectors/project.py,sha256=YCynNC8drJutPMiDGPutlYaL49IO8M-1Ms_RwVY09ss,6221
@@ -43,7 +45,7 @@ sourcecode/detectors/rust.py,sha256=Tij1vz8BFZ332GEvVkL6vyMli2OMHJfHyDAppWfe66c,
 sourcecode/detectors/systems.py,sha256=nYaKbGDFu0EOXFcd_1doWFT3tTUdkbxc2DjHUF5TcqQ,1627
 sourcecode/detectors/terraform.py,sha256=cxORPR_zVLOJpHlh4e9JnFpkQsn_UnqMMom5yG65hZ4,1693
 sourcecode/detectors/tooling.py,sha256=hIvop80No22pqyGVJ32NKliSdjkHRePQkIRroqG01bY,1875
-sourcecode-0.25.0.dist-info/METADATA,sha256=0oCmRp0cVAVI5vdasc0ONKAq45mBtUoLmtPSFs7P1RE,30326
-sourcecode-0.25.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-0.25.0.dist-info/entry_points.txt,sha256=voDtdlGU2-jR3wCZpQoOls_0eUKaDVCKIfajGHFDATs,50
-sourcecode-0.25.0.dist-info/RECORD,,
+sourcecode-0.26.0.dist-info/METADATA,sha256=5OCyy0oIIzulSBOou5ZDGiNrcggn_VT3FNxly1gu33s,30326
+sourcecode-0.26.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-0.26.0.dist-info/entry_points.txt,sha256=voDtdlGU2-jR3wCZpQoOls_0eUKaDVCKIfajGHFDATs,50
+sourcecode-0.26.0.dist-info/RECORD,,