sourcecode 2.5.5__py3-none-any.whl → 2.5.7__py3-none-any.whl

sourcecode/__init__.py

@@ -4,4 +4,4 @@ ASK Engine is the product. ``ask`` is the canonical CLI command; ``sourcecode``
 the legacy compatibility alias and the Python/PyPI package name. See
 docs/PRODUCT_IDENTITY.md (normative)."""
 
-__version__ = "2.5.5"
+__version__ = "2.5.7"

sourcecode/architecture_analyzer.py

@@ -4,7 +4,11 @@ import re
 from pathlib import Path
 from typing import Literal, Optional
 
-from sourcecode.reconciliation import incoherent_layers
+from sourcecode.reconciliation import (
+    incoherent_layers,
+    pattern_contradicted,
+    unattested_layers,
+)
 
 from sourcecode.schema import (
     ArchitectureAnalysis,
@@ -41,11 +45,27 @@ _SRC_TRANSPARENT = {
     "src", "lib", "app", "pkg",
     "main", "java", "kotlin", "scala", "groovy",
 }
+
+# `src/main/java17/` is a MULTI-RELEASE source set, as transparent as `java/`
+# — JobRunr's minted a module called "java17".
+_VERSIONED_SRC_RE = re.compile(r"^(?:java|kotlin|scala)\d+$")
+
+
+def _is_transparent_segment(name: str) -> bool:
+    """A path segment that carries no architectural meaning of its own."""
+    low = name.lower()
+    return low in _SRC_TRANSPARENT or bool(_VERSIONED_SRC_RE.match(low))
 _CODE_EXTENSIONS = {
     ".py", ".js", ".ts", ".tsx", ".jsx", ".mjs", ".cjs",
     ".go", ".java", ".kt", ".rs", ".rb",
 }
-_GENERIC_NAMES = {"utils", "helpers", "common", "shared", "misc", "core", "root", ""}
+# Names that never identify a module: generic buckets, and the reverse-DNS
+# package roots every JVM repo starts its namespace with (JobRunr reported a
+# module called "org").
+_GENERIC_NAMES = {
+    "utils", "helpers", "common", "shared", "misc", "core", "root", "",
+    "org", "com", "io", "net",
+}
 
 _TEST_DIRS: frozenset[str] = frozenset({
     "tests", "test", "spec", "specs", "__tests__", "e2e",
@@ -671,14 +691,18 @@ class ArchitectureAnalyzer:
             # reconciliation rule drops layers owned by a different runtime;
             # template/asset-only layers are untouched, so a real Spring-MVC
             # `templates/` view survives.
-            for _bad in incoherent_layers(
-                pattern_name,
-                {k: [source_paths[i] for i in v] for k, v in layer_files.items()},
-                source_paths,
-            ):
+            _layer_paths = {k: [source_paths[i] for i in v] for k, v in layer_files.items()}
+            for _bad in incoherent_layers(pattern_name, _layer_paths, source_paths):
                 matched.pop(_bad, None)
                 layer_files.pop(_bad, None)
 
+            # A claim that IS a runtime split must show one: JobRunr, a JVM
+            # library, read "Fullstack with frontend, backend layers" off a
+            # `dashboard/ui/model/` package of 16 Java files. Nothing to prune —
+            # the pattern itself is what the evidence contradicts.
+            if pattern_contradicted(pattern_name, _layer_paths, source_paths):
+                continue
+
             # A pattern with unmet required keys cannot qualify (e.g. mvc needs a view).
             required = _PATTERN_REQUIRED_KEYS.get(pattern_name)
             if required and not required.issubset(matched.keys()):
@@ -842,6 +866,14 @@ class ArchitectureAnalyzer:
             k: v for k, v in layer_files.items()
             if v and (not total or len(v) / total >= _LAYER_MIN_SHARE)
         }
+        # P1-D residue: these stem patterns are Python-shaped (cli.py,
+        # *_analyzer.py, config.py). On a Java repo almost nothing matches, so
+        # the few stray hits are not a layering — petclinic's "Layered
+        # Architecture with orchestration, data layers" rested on ONE directory
+        # entry plus a settings.gradle, with 47 Java files visible and ignored.
+        # A logical code layer that holds no code of this repo is not one.
+        for _bad in unattested_layers(non_empty, paths):
+            non_empty.pop(_bad, None)
         if len(non_empty) >= 2:
             return "layered", [
                 ArchitectureLayer(name=k, pattern="layered", files=v, confidence="low")
@@ -861,13 +893,19 @@ class ArchitectureAnalyzer:
         for p in paths:
             parts = p.replace("\\", "/").split("/")
             for part in parts[:-1]:
-                if (part not in _SRC_TRANSPARENT
+                if (not _is_transparent_segment(part)
                         and part.lower() not in _NON_SOURCE_DIRS
                         and part.lower() not in _GENERIC_NAMES):
                     module_files.setdefault(part, []).append(p)
                     break
 
         meaningful = {k: v for k, v in module_files.items() if len(v) >= 3}
+        # P1-D residue: a MODULE of this repo must hold this repo's code. File
+        # count alone let build and asset directories be reported as modules —
+        # ofbiz "docker, framework, runtime, gradle", neo4j "packaging",
+        # eureka "images" (five PNGs). The real modules survive untouched.
+        for _bad in unattested_layers(meaningful, paths):
+            meaningful.pop(_bad, None)
         if len(meaningful) >= 2:
             return "modular", [
                 ArchitectureLayer(name=k, pattern="modular", files=v, confidence="low")

sourcecode/architecture_summary.py

@@ -205,6 +205,22 @@ class ArchitectureSummarizer:
                 for f in s.frameworks[:2]
             ))[:3]
 
+        # F-1 reconciliation: the headline describes ONE program, but fw_names is
+        # gathered from every stack in the repo. On a polyglot repository that
+        # welds a foreign runtime's framework onto the primary's label. Drop what
+        # the claimed stack does not attest, and never let the TYPE label — which
+        # those same frameworks drove — survive its own evidence (P2-F).
+        from sourcecode.reconciliation import type_claim_unattested, unattested_frameworks
+
+        foreign = unattested_frameworks(primary.stack, sm.project_type, sm.stacks)
+        attested = [name for name in fw_names if name not in foreign]
+        dropped = [name for name in fw_names if name in foreign]
+        if dropped and not attested and type_claim_unattested(
+            claimed_stack=primary.stack, project_type=sm.project_type, stacks=sm.stacks
+        ):
+            return self._describe_foreign_evidence(sm, stack_label, runtime, dropped)
+        fw_names = attested
+
         fw_str = f" using {', '.join(fw_names)}" if fw_names else ""
         if runtime:
             # BUG #4: never assert "rest api" in the headline unless the endpoints
@@ -237,6 +253,29 @@ class ArchitectureSummarizer:
             return f"{stack_label} {runtime.lower()}{fw_str}."
         return f"{stack_label} project{fw_str}."
 
+    def _describe_foreign_evidence(
+        self, sm: SourceMap, stack_label: str, runtime: str, dropped: list[str]
+    ) -> str:
+        """Headline for a claim whose defining evidence belongs to another stack.
+
+        Says what IS known instead of asserting a program that does not exist:
+        the primary stack, the foreign frameworks, and the stacks that actually
+        declare them. The reader gets the same facts, correctly attributed.
+        """
+        from sourcecode.context_summarizer import _STACK_LABELS
+        from sourcecode.reconciliation import framework_owner_stacks
+
+        owners = framework_owner_stacks(sm.stacks)
+        owner_ids = sorted({sid for name in dropped for sid in owners.get(name, ())})
+        owner_labels = [_STACK_LABELS.get(sid, sid) for sid in owner_ids] or ["another"]
+        plural = "s" if len(owner_labels) > 1 else ""
+        return (
+            f"{stack_label} project. Polyglot repository: the {runtime.lower()} "
+            f"evidence ({', '.join(dropped)}) is declared by the "
+            f"{', '.join(owner_labels)} stack{plural}, not by {stack_label} — no "
+            "single stack owns this repository's architecture. See `stacks`."
+        )
+
     def _endpoint_support(self) -> tuple[int, int]:
         """Return (total, high_confidence) endpoint counts from the canonical
         Java endpoint extractor — the same source the `endpoints` command uses,
@@ -412,41 +451,51 @@ class ArchitectureSummarizer:
         return None
 
     def _summarize_dotnet_entry(self, stacks: list[StackDetection]) -> list[str]:
+        # P2-F-RESIDUE(c): every line here counts .csproj files — facts about the
+        # .NET stack ALONE. Unscoped, they read as claims about the repository:
+        # the confluent examples monorepo (20+ subprojects, mostly Java/Python/Go)
+        # reported a bare "1 project detected." beside a headline that had just
+        # called it polyglot. Naming the stack costs one word and makes each line
+        # true on any repo, so no polyglot test is needed to decide the wording.
+        from sourcecode.context_summarizer import _STACK_LABELS
+
         dotnet_stacks = [s for s in stacks if s.stack == "dotnet"]
         if not dotnet_stacks:
             return []
+        label = _STACK_LABELS.get("dotnet", "dotnet")  # same table as the headline
         lines: list[str] = []
         signals = [sig for s in dotnet_stacks for sig in s.signals]
 
         for sig in signals:
             if "project" in sig and "detected" in sig:
-                lines.append(sig[0].upper() + sig[1:] + ".")
+                count = sig.split(" ", 1)[0]
+                lines.append(f"{label} projects: {count}.")
                 break
 
         for sig in signals:
             if sig.startswith("project types:"):
                 types = sig.removeprefix("project types:").strip()
-                lines.append(f"Stack: {types}.")
+                lines.append(f"{label} project types: {types}.")
                 break
 
         for sig in signals:
             if sig.startswith("target frameworks:"):
                 fws = sig.removeprefix("target frameworks:").strip()
-                lines.append(f"Target: {fws}.")
+                lines.append(f"{label} target frameworks: {fws}.")
                 break
 
         for sig in signals:
             if sig.startswith("architecture:"):
                 pattern = sig.removeprefix("architecture:").strip()
-                lines.append(f"Patrón detectado: {pattern}.")
+                lines.append(f"{label} solution pattern: {pattern}.")
                 break
 
         framework_names = [f.name for s in dotnet_stacks for f in s.frameworks]
         if framework_names:
-            lines.append(f"Frameworks: {', '.join(framework_names)}.")
+            lines.append(f"{label} frameworks: {', '.join(framework_names)}.")
 
         if not lines:
-            lines.append("Solución .NET detectada.")
+            lines.append(f"{label} solution detected.")
         return lines
 
     def _summarize_go_entry(self, path: str, content: str) -> list[str]:

sourcecode/confidence_analyzer.py

@@ -102,6 +102,45 @@ class ConfidenceAnalyzer:
         if heuristic_only and not any(s.detection_method != "heuristic" for s in sm.stacks):
             anomalies.append("All stacks detected via heuristic only — no manifest found")
 
+        # ── Anomaly: a claim attributed to a stack that does not attest it ────
+        # F-1 reconciliation, second sink. The headline degrades itself
+        # (architecture_summary), but `project_type` and `primary_stack` are
+        # separate structured fields an agent can read on their own — and they
+        # keep asserting the claim this rule refutes. Same rule, same judgement,
+        # different surface: here it becomes an anomaly + gap instead of prose.
+        if primary_stacks:
+            from sourcecode.reconciliation import (
+                reconcile_headline_evidence,
+                type_claim_unattested,
+            )
+
+            _primary = primary_stacks[0]
+            for _rf in reconcile_headline_evidence(
+                claimed_stack=_primary.stack,
+                project_type=sm.project_type,
+                stacks=sm.stacks,
+            ):
+                anomalies.append(
+                    f"{', '.join(_rf.symbols)} declared by another runtime, not by the "
+                    f"{_primary.stack} primary stack"
+                )
+                _reason = _rf.detail
+                if type_claim_unattested(
+                    claimed_stack=_primary.stack,
+                    project_type=sm.project_type,
+                    stacks=sm.stacks,
+                ):
+                    _reason += (
+                        f' project_type="{sm.project_type}" rests on that same evidence — '
+                        f"it is not attested for the {_primary.stack} primary stack, and "
+                        "the repository is polyglot rather than one program."
+                    )
+                gaps.append(AnalysisGap(
+                    area=_rf.rule,
+                    reason=_reason,
+                    impact="medium",
+                ))
+
         # ── Anomaly: entry points all low-confidence ──────────────────────────
         if normalized_entry_points and all(ep.confidence == "low" for ep in normalized_entry_points):
             anomalies.append("All entry points are low-confidence (heuristic/code_signal only)")

sourcecode/reconciliation.py

@@ -42,6 +42,15 @@ Rule registry (architecture):
         subsystems (SIM-3: keycloak's "MVC … view layer" was a React SPA, zero
         Java files, sitting beside a 1088-file Java model).
 
+Rule registry (narrative):
+    framework_stack_attestation — the headline welds a stack label to a
+        framework that no stack of that runtime declares. The stack table and
+        the framework-ownership view are contradicting each other: the sentence
+        describes one program while the evidence names two (P2-F: the confluent
+        examples repo read "C#/.NET rest api using JAX-RS" — a JVM framework,
+        declared by a Java stack in one sub-workspace, attributed to a .NET
+        primary that declares no framework at all).
+
 Never raises. Empty evidence → no findings.
 """
 from __future__ import annotations
@@ -223,6 +232,15 @@ _CROSS_RUNTIME_PATTERNS: frozenset[str] = frozenset({
     "fullstack", "microservices", "monorepo",
 })
 
+# Patterns whose meaning IS the runtime split — a "fullstack" repo names a
+# frontend TIER and a backend TIER. If every layer runs on the same runtime
+# there is no split, and the claim is a directory-name coincidence: JobRunr, a
+# JVM library, read "Fullstack with frontend, backend layers" off a
+# `dashboard/ui/model/` package holding 16 JAVA files. (Not monorepo or
+# microservices: an all-TypeScript monorepo, or same-runtime services, are
+# perfectly real.)
+_SPLIT_REQUIRED_PATTERNS: frozenset[str] = frozenset({"fullstack"})
+
 
 def runtime_census(layer_files: dict[str, list[str]]) -> dict[str, dict[str, int]]:
     """{layer -> {runtime_family -> file count}} — the language evidence view.
@@ -288,6 +306,91 @@ def _rule_layer_language_coherence(
     ]
 
 
+def _rule_layer_code_attestation(
+    census: dict[str, dict[str, int]],
+    repo_runtimes: dict[str, int],
+) -> list[ReconciliationFinding]:
+    """A claimed code module holds no code of the repo's runtime.
+
+    Stricter sibling of `layer_language_coherence`, for claims whose layers are
+    modules or logical code layers — their whole role is to hold code, so a
+    directory with none is not one of them. (`layer_language_coherence` cannot
+    serve here: it deliberately ignores layers with no runtime files at all, so
+    that a real Spring-MVC `templates/` view survives. A view may be templates;
+    a MODULE may not.)
+
+    Measured on the field-test repos: ofbiz's "modular architecture" listed
+    `docker`, `gradle`, `runtime` and `themes` (shell scripts, wrapper jars, a
+    .gitignore, images — zero Java); neo4j listed `packaging`; eureka listed
+    `images` (five PNGs); petclinic's whole "Layered Architecture with
+    orchestration, data layers" rested on one directory entry and a
+    settings.gradle.
+    """
+    if not repo_runtimes:
+        return []
+    dominant = max(sorted(repo_runtimes), key=lambda f: repo_runtimes[f])
+    unattested = sorted(
+        layer for layer, counts in census.items() if not counts.get(dominant)
+    )
+    if not unattested:
+        return []
+    return [
+        ReconciliationFinding(
+            rule="layer_code_attestation",
+            symbols=tuple(unattested),
+            detail=(
+                f"{len(unattested)} claimed layer(s) hold no {dominant} code — "
+                "a directory without the repo's code is not a module of it."
+            ),
+        )
+    ]
+
+
+def _rule_composition_runtime_split(
+    pattern: str,
+    census: dict[str, dict[str, int]],
+) -> list[ReconciliationFinding]:
+    """A pattern that names a runtime split shows none.
+
+    The mirror image of `layer_language_coherence`: a claim about one program
+    must NOT span runtimes; a claim that IS the split must show it. Silent
+    unless the pattern's layers carry runtime evidence at all.
+    """
+    if pattern not in _SPLIT_REQUIRED_PATTERNS or len(census) < 2:
+        return []
+    families = {fam for counts in census.values() for fam in counts}
+    if len(families) != 1:
+        return []  # a real split, or no runtime evidence to judge
+    only = next(iter(families))
+    return [
+        ReconciliationFinding(
+            rule="composition_runtime_split",
+            symbols=tuple(sorted(census)),
+            detail=(
+                f"the '{pattern}' claim names a runtime split but every layer is "
+                f"{only} — the layer names are a coincidence, not two tiers."
+            ),
+        )
+    ]
+
+
+def unattested_layers(
+    layer_files: dict[str, list[str]], repo_files: "list[str]"
+) -> frozenset[str]:
+    """Layers holding no code of the repo's runtime (convenience view).
+
+    For consumers claiming code modules / logical code layers. Never raises.
+    """
+    try:
+        repo_runtimes = runtime_census({"_repo": list(repo_files)})["_repo"]
+        out: set[str] = set()
+        for f in _rule_layer_code_attestation(runtime_census(layer_files), repo_runtimes):
+            out.update(f.symbols)
+        return frozenset(out)
+    except Exception:
+        return frozenset()
+
+
 def reconcile_architecture_evidence(
     *,
     pattern: str,
@@ -304,17 +407,34 @@ def reconcile_architecture_evidence(
     """
     findings: list[ReconciliationFinding] = []
     try:
+        census = runtime_census(layer_files)
         repo_runtimes = runtime_census({"_repo": list(repo_files)})["_repo"]
         findings.extend(
-            _rule_layer_language_coherence(
-                pattern, runtime_census(layer_files), repo_runtimes
-            )
+            _rule_layer_language_coherence(pattern, census, repo_runtimes)
         )
+        findings.extend(_rule_composition_runtime_split(pattern, census))
     except Exception:
         pass
     return findings
 
 
+def pattern_contradicted(
+    pattern: str, layer_files: dict[str, list[str]], repo_files: "list[str]"
+) -> bool:
+    """True when a rule rejects the PATTERN itself, not just some of its layers.
+
+    `incoherent_layers` prunes layers and lets the pattern re-qualify on what
+    is left; a split-less "fullstack" has nothing to re-qualify with — the
+    claim as a whole is the thing contradicted.
+    """
+    return any(
+        f.rule == "composition_runtime_split"
+        for f in reconcile_architecture_evidence(
+            pattern=pattern, layer_files=layer_files, repo_files=repo_files
+        )
+    )
+
+
 def incoherent_layers(
     pattern: str, layer_files: dict[str, list[str]], repo_files: "list[str]"
 ) -> frozenset[str]:
@@ -327,6 +447,188 @@ def incoherent_layers(
     return frozenset(out)
 
 
+# ---------------------------------------------------------------------------
+# Narrative reconciliation (headline claim × stack ownership)
+# ---------------------------------------------------------------------------
+
+# Stack identifier → RUNTIME FAMILY. Same reasoning as `_RUNTIME_FAMILY` above,
+# applied to the stack ontology instead of file extensions: a Kotlin framework
+# named in a Java headline is ONE program (same runtime, direct interop), while a
+# Java framework named in a .NET headline is a different one. Stacks absent here
+# are deliberately unjudgeable: an unknown stack can never prove a contradiction.
+_STACK_FAMILY: dict[str, str] = {
+    "java": "jvm", "kotlin": "jvm", "scala": "jvm", "groovy": "jvm",
+    "nodejs": "js", "deno": "js", "bun": "js",
+    "python": "python",
+    "go": "go",
+    "rust": "rust",
+    "ruby": "ruby",
+    "dotnet": "dotnet",
+    "php": "php",
+    "swift": "swift",
+    "dart": "dart",
+    "elixir": "beam", "erlang": "beam",
+}
+
+# Project types that are SUPPOSED to span runtimes — their headline names a tier
+# split, so a framework from another runtime is the point, not a contradiction.
+# Same carve-out (and same names) as `_CROSS_RUNTIME_PATTERNS` for layer claims.
+_CROSS_RUNTIME_TYPES = _CROSS_RUNTIME_PATTERNS
+
+# Project types DRIVEN by framework presence: `_classify_project_type` pools
+# frameworks across every stack to pick them, while a separate vote picks the
+# primary stack — so on a polyglot repo the type can be decided by one stack's
+# evidence and reported as another's. When the frameworks that drove the type are
+# all foreign to the primary, the type inherits their lie: the sentence
+# "C#/.NET rest api" is the same claim as "using JAX-RS", one clause shorter.
+# Lives here, not in a consumer: BOTH the headline and the confidence/gap surface
+# must judge this identically or the duplicated table lies again.
+_FRAMEWORK_DRIVEN_TYPES: frozenset[str] = frozenset({
+    "api", "webapp", "web_mvc", "angular-spa",
+})
+
+
+def framework_owner_stacks(stacks) -> dict[str, frozenset[str]]:
+    """{framework name -> stack ids that declare it} — the ownership view.
+
+    Ownership is already structural: a FrameworkDetection is discovered inside a
+    StackDetection's manifests, so which runtime a framework belongs to is
+    evidence the detector recorded, never a name lookup (VAI-safe — no rule here
+    branches on what the framework is called).
+    """
+    out: dict[str, set[str]] = {}
+    for stack in stacks or []:
+        sid = getattr(stack, "stack", "") or ""
+        if not sid:
+            continue
+        for fw in getattr(stack, "frameworks", None) or []:
+            name = getattr(fw, "name", "") or ""
+            if name:
+                out.setdefault(name, set()).add(sid)
+    return {name: frozenset(ids) for name, ids in out.items()}
+
+
+def framework_owner_families(stacks) -> dict[str, frozenset[str]]:
+    """{framework name -> runtime families that declare it} — the ownership view."""
+    return {
+        name: frozenset(
+            fam for sid in ids if (fam := _STACK_FAMILY.get(sid)) is not None
+        )
+        for name, ids in framework_owner_stacks(stacks).items()
+    }
+
+
+def _rule_framework_stack_attestation(
+    claimed_family: str | None,
+    owner_families: dict[str, frozenset[str]],
+) -> list[ReconciliationFinding]:
+    """A framework named in a headline is declared by no stack of the claimed runtime.
+
+    The headline describes ONE program: it welds a stack label ("C#/.NET") to the
+    frameworks found anywhere in the repo. On a polyglot repository those can be
+    different programs, and the sentence asserts a relationship the evidence
+    denies — the confluent examples repo read "C#/.NET rest api using JAX-RS",
+    attributing a JVM-only framework, declared by a Java stack in one
+    sub-workspace, to a .NET primary that declares no framework at all.
+
+    Fires only when ownership is PROVEN and disjoint: the framework has at least
+    one known owning family and the claimed family is not among them. An unknown
+    stack, or a framework no stack claims, yields nothing.
+    """
+    if not claimed_family:
+        return []
+    foreign = sorted(
+        name for name, fams in owner_families.items()
+        if fams and claimed_family not in fams
+    )
+    if not foreign:
+        return []
+    others = sorted({fam for name in foreign for fam in owner_families[name]})
+    return [
+        ReconciliationFinding(
+            rule="framework_stack_attestation",
+            symbols=tuple(foreign),
+            # Sink-neutral: this detail is read by a prose surface AND by a
+            # structured gap, so it states the contradiction, never "the
+            # headline says…" — the headline may already have dropped the claim.
+            detail=(
+                f"{len(foreign)} framework(s) are declared only by "
+                f"{', '.join(others)} stack(s), not by the {claimed_family} "
+                "primary stack — attributing them to it describes two separate "
+                "programs as one."
+            ),
+        )
+    ]
+
+
+def reconcile_headline_evidence(
+    *,
+    claimed_stack: str,
+    project_type: str | None,
+    stacks,
+) -> list[ReconciliationFinding]:
+    """Run headline reconciliation rules. Never raises.
+
+    Args:
+        claimed_stack: stack id the headline's label is built from (the primary).
+        project_type:  claimed type — cross-runtime types are exempt, their
+                       headline is MEANT to name another tier's framework.
+        stacks:        every StackDetection, each owning its own frameworks.
+    """
+    if project_type in _CROSS_RUNTIME_TYPES:
+        return []
+    findings: list[ReconciliationFinding] = []
+    try:
+        findings.extend(
+            _rule_framework_stack_attestation(
+                _STACK_FAMILY.get(claimed_stack or ""),
+                framework_owner_families(stacks),
+            )
+        )
+    except Exception:
+        pass
+    return findings
+
+
+def type_claim_unattested(
+    *, claimed_stack: str, project_type: str | None, stacks
+) -> bool:
+    """True when a framework-driven type label rests ONLY on foreign evidence.
+
+    The sibling of `_rule_framework_stack_attestation` for the type clause: the
+    frameworks that decided `project_type` are declared, every one of them, by
+    stacks of another runtime. The narrative consumer degrades the sentence; the
+    confidence consumer records the gap — same judgement, two sinks, one table.
+
+    Provable only: silent when the type is not framework-driven, when the claimed
+    stack's runtime is unknown, or when no framework is owned at all.
+    """
+    try:
+        if project_type not in _FRAMEWORK_DRIVEN_TYPES:
+            return False
+        family = _STACK_FAMILY.get(claimed_stack or "")
+        if not family:
+            return False
+        owners = framework_owner_families(stacks)
+        if not owners:
+            return False
+        return not any(family in fams for fams in owners.values())
+    except Exception:
+        return False
+
+
+def unattested_frameworks(
+    claimed_stack: str, project_type: str | None, stacks
+) -> frozenset[str]:
+    """Framework names the claimed stack does not attest (convenience view)."""
+    out: set[str] = set()
+    for f in reconcile_headline_evidence(
+        claimed_stack=claimed_stack, project_type=project_type, stacks=stacks
+    ):
+        out.update(f.symbols)
+    return frozenset(out)
+
+
 def reconcile_extraction_evidence(
     *,
     type_decl_files: frozenset[str],

sourcecode/summarizer.py

@@ -9,7 +9,7 @@ from pathlib import Path
 from typing import Any
 
 from sourcecode.architecture_analyzer import _LAYER_MIN_SHARE, _PATTERN_REQUIRED_KEYS
-from sourcecode.reconciliation import incoherent_layers
+from sourcecode.reconciliation import incoherent_layers, pattern_contradicted
 from sourcecode.detectors.parsers import load_json_file, load_toml_file
 from sourcecode.tree_utils import safe_read_text
 from sourcecode.entrypoint_classifier import is_production_entry_point
@@ -439,6 +439,8 @@ class ProjectSummarizer:
             # two duplicated tables leaves the other one lying.
             for _bad in incoherent_layers(pattern_name, layer_files, file_paths):
                 layer_files.pop(_bad, None)
+            if pattern_contradicted(pattern_name, layer_files, file_paths):
+                continue
             # A pattern must show its defining trait here too, or the headline
             # contradicts the architecture prose that already enforces this.
             required = _PATTERN_REQUIRED_KEYS.get(pattern_name)

{sourcecode-2.5.5.dist-info → sourcecode-2.5.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 2.5.5
+Version: 2.5.7
 Summary: Persistent structural context and ultra-fast repeated analysis for AI coding agents
 License-File: LICENSE
 Keywords: agents,ai,codebase,context,developer-tools,llm

{sourcecode-2.5.5.dist-info → sourcecode-2.5.7.dist-info}/RECORD

@@ -1,8 +1,8 @@
-sourcecode/__init__.py,sha256=RsMXFkrSEd5UuAhMfPgfXfYvqM0A43vYcSfn086K17s,308
+sourcecode/__init__.py,sha256=AYI3dPxhkPPbI6cutQ3CdTcxsveWkRyIzUZMCY7lfFs,308
 sourcecode/adaptive_scanner.py,sha256=XffluXKzJUXrMtjEiAOnSNPZnztdIcts17T9ouHeID0,10521
 sourcecode/archetype.py,sha256=d7yoN6Tj4OBj-VgSMPEKg4WF9H8FypnZ5A6AkUh5oIE,34484
-sourcecode/architecture_analyzer.py,sha256=vQQzcvmniq4go4bWNB2Xm5HlyIoW65cU7ktJqHIfDpU,53614
-sourcecode/architecture_summary.py,sha256=pkl6lIOnSy-poa9EzW43U0MkXhx2FDfAFh8pDXLpcTo,26630
+sourcecode/architecture_analyzer.py,sha256=1CEIeFtuxdzeFaeUtA5QuDmFkb5eilUK8zRmk9tcDxc,55644
+sourcecode/architecture_summary.py,sha256=oBkjx7hZxmpdKLt4EracjRKHJFOGuPTd6SadTyPxY7Q,29568
 sourcecode/ast_extractor.py,sha256=FEsYTsMCXbJfSYQZRk1k-I-PjUNGnKqO1IxMftsgA5U,51351
 sourcecode/cache.py,sha256=1V3vsaODAa2UBJAC0xpvxpmRdriCezQx5Q8JCcfgziE,31892
 sourcecode/call_surface.py,sha256=fiqYfHooxN1fX9oQoysq1LS3LoZcobhyUNjAGEZKpwk,4148
@@ -12,7 +12,7 @@ sourcecode/cir_graphs.py,sha256=9G0HHj1kw2325IDyzo2OpX73BNswEckecf4MZUXB4JM,1207
 sourcecode/classifier.py,sha256=9olDN5joeKHcwG9vf73X-t_son16hLVNib0rBbqk1vc,18865
 sourcecode/cli.py,sha256=46Chp0JsEWD_j0HUWOx4tOhrsXSWgWV8JhL5G8SyW4I,322078
 sourcecode/code_notes_analyzer.py,sha256=EJemNCNc9Dn-1RZYu-aNbK0ELzmsyC4s6FdHi3XyNEI,9392
-sourcecode/confidence_analyzer.py,sha256=_jckZSxksV-OU38vbkxfVNBnWCtlCq8Vwfg23x1uspA,19054
+sourcecode/confidence_analyzer.py,sha256=KCRg8B4WH15LpOB7oYhE4dD5nou9Xi48RT3vpaO6Ar4,20868
 sourcecode/context_cache.py,sha256=maws79rLKDwyZ7c9Q2LwlIxqZHRFlaKzErtO3mglWoA,25036
 sourcecode/context_graph.py,sha256=WFtUvfxoE8XtQxtRJLvaF4SJuS00ICjNoTk0sH2_V5U,44454
 sourcecode/context_scorer.py,sha256=QpChSpsmaAYz91rXA4Ue5xzQmNz_ZboZN09YOHScq1U,14679
@@ -51,7 +51,7 @@ sourcecode/pr_impact.py,sha256=dCDVw83EDbyVf6F9ZmEQmsFz8ruVH7d4mpeKQCIZHM0,16805
 sourcecode/prepare_context.py,sha256=PYygAKL_jwz8gGElgM9mroUSih18UKSSjv08ndfl4aA,222877
 sourcecode/progress.py,sha256=qn30sWaHOkjTgXsSBmiPkz7Rsbwc5oSlIe6JNEMYp_k,3149
 sourcecode/ranking_engine.py,sha256=ZAucq_YX2KkWUuAZf4P0lhtQ_38vEFnUhuGtSZd1S0E,12970
-sourcecode/reconciliation.py,sha256=L4r_k6c768yq4GSzSOsJHxot2y8bHREA6up68CUkzo4,13853
+sourcecode/reconciliation.py,sha256=Ulmo4cNgeBnS1KxWv7kKFkXkwgJaQ70P0x6zC4F0I_I,26342
 sourcecode/redactor.py,sha256=SB4hwIvg8h-hvcqKcDWaZvA-aSyn-at-BIRwa0tUv5E,3227
 sourcecode/relevance_scorer.py,sha256=0AgEt4KrV73nioMqBgjhGjtY7L2C7L7cSyKtj3IKcrw,9408
 sourcecode/rename_refactor.py,sha256=h6dNFlB9aZ_3q6heeHBkgXQeXaT03nvPSsYH6P8qxFg,12965
@@ -75,7 +75,7 @@ sourcecode/spring_model.py,sha256=zOAgFmrRbG4a6KLm1TJl55aWMyPNsz3OS3FSczqPG6A,16
 sourcecode/spring_security_audit.py,sha256=Rk-aSohezdc7YDYbSoJquVnwpkDB8ty1BCD-4Hc4R5A,22832
 sourcecode/spring_semantic.py,sha256=jteQ1PkY9ArFJv0embg_jBIdbOxqrk9mQ2Xz8OF_FKA,14214
 sourcecode/spring_tx_analyzer.py,sha256=QMXkxa_hrqDVN3D8WJsd0nT7vfdZCT1E8ZWNoFFbvgU,34692
-sourcecode/summarizer.py,sha256=4IPhFg3Anrqa9U17i_bBKq70Q7eVefsCEK3idFC4VsY,26217
+sourcecode/summarizer.py,sha256=E70QILQ8cCNIH485c7lVMv5dXOpUn8qx1habi1_cn6o,26340
 sourcecode/tree_utils.py,sha256=8GAkIfQAsvtEudIeW1l4ooH_oRtrWR8cpJQJsEa_Pfw,2093
 sourcecode/type_usage_surface.py,sha256=51IrKRQoIoRnlsiDjHnqpJBn2rc6E59aRhgS0HTzAF0,4428
 sourcecode/validation_inference.py,sha256=UtmYv-d4TEzT1ihGEipAhtXDrwq0XtVtjMpb3i7NsNc,10815
@@ -137,8 +137,8 @@ sourcecode/telemetry/consent.py,sha256=LIAO9ohJZF8OuZwM4u1VWtALlYfTCCKq4wV3Vwc7i
 sourcecode/telemetry/events.py,sha256=LtzYfaX9Ilckj5PTvAcTpDa9mLqDsYPDUiDkRa58piY,2580
 sourcecode/telemetry/filters.py,sha256=NHa5T-6DaZduQPFuC34jOqHWQgSizM-Ygq8aZ4j19ng,5834
 sourcecode/telemetry/transport.py,sha256=4gGHsq0WeY9VywEZXA3vUxykfiYnw9uuqfjAAec7F8o,1681
-sourcecode-2.5.5.dist-info/METADATA,sha256=jTeYMssrsUEZUxEVu8WAQq0ihp7c8FtWCT27m2eNeXo,10851
-sourcecode-2.5.5.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-2.5.5.dist-info/entry_points.txt,sha256=-JEAdChrK5We51kZcb7OaDcyil-dHBjBPL-NhuO-QY8,89
-sourcecode-2.5.5.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
-sourcecode-2.5.5.dist-info/RECORD,,
+sourcecode-2.5.7.dist-info/METADATA,sha256=WZPw6sppRfqGy5VxcYxS97BHKScBppWAW2UI8eD_TIM,10851
+sourcecode-2.5.7.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-2.5.7.dist-info/entry_points.txt,sha256=-JEAdChrK5We51kZcb7OaDcyil-dHBjBPL-NhuO-QY8,89
+sourcecode-2.5.7.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-2.5.7.dist-info/RECORD,,