feat: add A.6 strict mode detection and A.7 naming consistency assessors

A.6 - TypeAnnotationsAssessor:
- Add _check_strict_mode() to detect mypy/pyright strict mode in
  pyproject.toml, mypy.ini, setup.cfg, and pyrightconfig.json
- Score combines coverage (80 pts) + strict mode bonus (20 pts)
- Add comprehensive tests for all config file formats

A.7 - StandardLayoutAssessor:
- Add _check_naming_consistency() to detect mixed snake_case/camelCase
  in the same directory, reducing 'glob-ability' for agents
- 10-point penalty per directory, capped at 20 points
- Add 10 tests covering all edge cases (venv excluded, single file, etc.)

docs/attributes.md:
- Document strict mode scoring and remediation for A.6
- Document naming consistency criteria and penalty for A.7

Author: jwm4

docs/attributes.md

@@ -266,6 +266,8 @@ Type annotations give agents reliable information about what a function expects
 - All public functions have parameter and return type hints
 - Generic types from `typing` module used appropriately
 - Coverage: >80% of functions typed
+- **Strict mode configured** (prevents new violations): mypy `strict = true` or `disallow_untyped_defs`, or pyright `strict = true` in `pyproject.toml`, `mypy.ini`, `setup.cfg`, or `pyrightconfig.json`
+- Strict mode is scored as a 20-point bonus on a 100-point scale (80 pts max for coverage + 20 pts for strict mode)
 - Tools: mypy, pyright
 
 **TypeScript**:
@@ -362,6 +364,29 @@ def create_user(email, role):
 
 4. **Fix errors iteratively**
 
+5. **Enable strict mode** in your type checker config:
+
+   ```toml
+   # pyproject.toml
+   [tool.mypy]
+   strict = true
+   ```
+
+   Or alternatively:
+
+   ```ini
+   # mypy.ini
+   [mypy]
+   disallow_untyped_defs = true
+   ```
+
+   For pyright:
+
+   ```json
+   // pyrightconfig.json
+   { "typeCheckingMode": "strict" }
+   ```
+
 **TypeScript**:
 
 1. **Enable strict mode** in `tsconfig.json`:
@@ -406,8 +431,21 @@ Using community-recognized directory structures for each language/framework (e.g
 
 Models trained on open-source code have seen the standard layouts thousands of times. When a repo uses the Python `src/` layout or Go's `cmd/internal/pkg` structure, the agent knows where to look for things and where to put new ones. Non-standard layouts force it to explore, and it may still place files in the wrong location.
 
+**Naming consistency** also matters for agent efficiency. When files in the same directory follow a consistent naming convention (e.g., all snake_case in Python), agents can use glob patterns like `src/**/*.py` reliably. Mixed conventions (snake_case and camelCase coexisting in the same directory) reduce "glob-ability" and make it harder for agents to predict file locations.
+
 #### Measurable Criteria
 
+**Python** (naming consistency applies to all languages but assessed via Python files):
+
+- Consistent naming convention within directories:
+  - snake_case (`module_name.py`) — Python community standard
+  - camelCase (`moduleHandler.py`) — also valid but must be consistent
+  - **Mixed naming in the same directory** (e.g., `module_a.py` and `moduleHandler.py` in the same directory) reduces the score
+  - 10-point penalty per directory with mixed naming, capped at 20 points
+  - Directories are checked independently: different dirs can have different conventions
+  - Single-file directories or directories with only one convention are not penalized
+  - Directories with only 1-2 files need both to be from different conventions to trigger a penalty
+
 **Python (src/ layout)**:
 
 ```

src/agentready/assessors/code_quality.py

@@ -3,6 +3,7 @@
 import ast
 import logging
 import re
+import tomllib
 
 from ..models.attribute import Attribute
 from ..models.finding import Citation, Finding, Remediation
@@ -73,7 +74,13 @@ def assess(self, repository: Repository) -> Finding:
             )
 
     def _assess_python_types(self, repository: Repository) -> Finding:
-        """Assess Python type annotations using AST parsing."""
+        """Assess Python type annotations using AST parsing.
+
+        Checks both annotation coverage (current state) and strict mode
+        configuration (prevents new violations). Both matter — strict mode
+        stops new untyped code from entering; coverage measures what's already
+        typed.
+        """
         # Use AST parsing to accurately detect type annotations
         try:
             # Security: Use safe_subprocess_run for validation and limits
@@ -130,28 +137,121 @@ def _assess_python_types(self, repository: Repository) -> Finding:
             )
 
         coverage_percent = (typed_functions / total_functions) * 100
-        score = self.calculate_proportional_score(
+
+        # Check for strict mode configuration (mypy/pyright)
+        strict_mode = self._check_strict_mode(repository)
+
+        # Score combines coverage (up to 80 pts) + strict mode bonus (up to 20 pts)
+        coverage_score = self.calculate_proportional_score(
             measured_value=coverage_percent,
             threshold=80.0,
             higher_is_better=True,
         )
+        score = min(100.0, coverage_score + (20.0 if strict_mode else 0.0))
 
         status = "pass" if score >= 75 else "fail"
 
+        evidence = [
+            f"Typed functions: {typed_functions}/{total_functions}",
+            f"Coverage: {coverage_percent:.1f}%",
+        ]
+        if strict_mode:
+            evidence.append("Strict mode configured")
+        else:
+            evidence.append("No strict mode configuration found")
+
         return Finding(
             attribute=self.attribute,
             status=status,
             score=score,
             measured_value=f"{coverage_percent:.1f}%",
-            threshold="≥80%",
-            evidence=[
-                f"Typed functions: {typed_functions}/{total_functions}",
-                f"Coverage: {coverage_percent:.1f}%",
-            ],
+            threshold="≥80% coverage + strict mode",
+            evidence=evidence,
             remediation=self._create_remediation() if status == "fail" else None,
             error_message=None,
         )
 
+    @staticmethod
+    def _check_strict_mode(repository: Repository) -> bool:
+        """Check whether the Python type checker is configured in strict mode.
+
+        Looks for mypy/pyright strict mode configuration in pyproject.toml,
+        mypy.ini, setup.cfg, or pyrightconfig.json.
+
+        ADR A.6: Strict mode prevents new violations; coverage measures
+        current state. Both matter.
+        """
+        # Check pyproject.toml for mypy/pyright strict config
+        pyproject_path = repository.path / "pyproject.toml"
+        if pyproject_path.exists():
+            try:
+                with open(pyproject_path, "rb") as f:
+                    data = tomllib.load(f)
+
+                # mypy: [tool.mypy] strict = true
+                tool = data.get("tool", {})
+                mypy_cfg = tool.get("mypy", {})
+                if mypy_cfg.get("strict", False):
+                    return True
+                if "disallow_untyped_defs" in mypy_cfg and mypy_cfg[
+                    "disallow_untyped_defs"
+                ]:
+                    return True
+
+                # pyright: [tool.pyright] strict = true
+                pyright_cfg = tool.get("pyright", {})
+                if pyright_cfg.get("strict", False):
+                    return True
+
+            except (OSError, tomllib.TOMLDecodeError):
+                pass
+
+        # Check mypy.ini
+        mypy_ini_path = repository.path / "mypy.ini"
+        if mypy_ini_path.exists():
+            try:
+                content = mypy_ini_path.read_text(encoding="utf-8")
+                if "[mypy]" in content:
+                    for line in content.splitlines():
+                        stripped = line.strip().lower()
+                        if stripped == "strict = true" or stripped == "strict=true":
+                            return True
+                        if stripped.startswith("disallow_untyped_defs"):
+                            return True
+            except OSError:
+                pass
+
+        # Check setup.cfg
+        setup_cfg_path = repository.path / "setup.cfg"
+        if setup_cfg_path.exists():
+            try:
+                content = setup_cfg_path.read_text(encoding="utf-8")
+                if "[mypy]" in content or "[mypy]" in content.lower():
+                    for line in content.splitlines():
+                        stripped = line.strip().lower()
+                        if "strict = true" in stripped or "strict=true" in stripped:
+                            return True
+                        if stripped.startswith("disallow_untyped_defs"):
+                            return True
+            except OSError:
+                pass
+
+        # Check pyrightconfig.json
+        pyright_path = repository.path / "pyrightconfig.json"
+        if pyright_path.exists():
+            try:
+                import json
+
+                content = json.loads(pyright_path.read_text(encoding="utf-8"))
+                if content.get("typeCheckingMode", "") == "strict":
+                    return True
+                if content.get("strict", False):
+                    return True
+            except (json.JSONDecodeError, OSError):
+                pass
+
+        return False
+
     def _assess_typescript_types(self, repository: Repository) -> Finding:
         """Assess TypeScript type configuration across all tsconfig.json files.
 

src/agentready/assessors/structure.py

@@ -126,6 +126,9 @@ def assess(self, repository: Repository) -> Finding:
         - Go: cmd/, internal/, pkg/ with go.mod, tests in *_test.go
 
         Fix for #246, #305: Support multiple valid Python layouts
+        ADR A.7: Adds naming consistency check for Python repos — mixed
+        naming conventions (camelCase vs snake_case in same directory) reduce
+        "glob-ability" for agents.
         """
         if self._primary_language(repository, {"Python", "Go"}) == "Go":
             return self._assess_go_layout(repository)
@@ -162,6 +165,16 @@ def assess(self, repository: Repository) -> Finding:
             higher_is_better=True,
         )
 
+        # ADR A.7: Naming consistency check for Python repos
+        naming_penalty = 0.0
+        naming_evidence = []
+        if repository.languages.get("Python", 0) > 0:
+            penalty, evidence = self._check_naming_consistency(repository)
+            naming_penalty = penalty
+            naming_evidence = evidence
+
+        score = max(0.0, score - naming_penalty)
+
         status = "pass" if score >= 75 else "fail"
 
         # Build evidence with detailed source directory info
@@ -180,7 +193,7 @@ def assess(self, repository: Repository) -> Finding:
             f"Found {found_dirs}/{required_dirs} standard directories",
             source_evidence,
             f"tests/: {'✓' if has_tests else '✗'}",
-        ]
+        ] + naming_evidence
 
         return Finding(
             attribute=self.attribute,
@@ -497,6 +510,93 @@ def _create_go_remediation(
             ],
         )
 
+    def _check_naming_consistency(self, repository: Repository) -> tuple:
+        """Check for mixed naming conventions in the same directory.
+
+        ADR A.7: Inconsistent naming (camelCase vs snake_case coexisting in
+        the same directory) reduces "glob-ability" for agents. A consistent
+        naming convention makes it easier for agents to use glob patterns like
+        `src/**/*.py` to find all relevant files.
+
+        Returns:
+            (penalty_score, evidence_list)
+            - penalty_score: 0-20, where 20 is maximum penalty for mixed conventions
+            - evidence_list: human-readable evidence strings
+        """
+        # Only check source directories, not test directories
+        # We look at Python files (.py, .pyi) in source locations
+        source_path = repository.path / "src"
+        if not source_path.exists():
+            # Try project-named directory
+            package_name = self._get_package_name_from_pyproject(repository)
+            if package_name:
+                source_path = repository.path / package_name.replace("-", "_")
+            if not source_path.exists():
+                # Fall back to root for small repos
+                source_path = repository.path
+
+        file_stats: dict = {"snake_case": 0, "camelCase": 0, "mixed": set()}
+        total_files = 0
+
+        try:
+            for py_file in source_path.rglob("*.py"):
+                # Skip venv, node_modules, etc.
+                if any(
+                    part in py_file.parts
+                    for part in [".venv", "venv", "node_modules", ".git", ".tox"]
+                ):
+                    continue
+                total_files += 1
+                dirname = py_file.parent.name
+                filename = py_file.name
+
+                # Group files by directory and check naming per directory
+                is_snake = bool(re.fullmatch(r"[a-z][a-z0-9]*(?:_[a-z0-9]+)*\.py(?:i)?$", filename))
+                is_camel = bool(re.fullmatch(r"[a-z][a-zA-Z0-9]*\.py(?:i)?$", filename))
+
+                if is_snake and is_camel:
+                    pass  # lowercase is snake_case
+                elif is_snake:
+                    key = f"{dirname}/"
+                    if key not in file_stats:
+                        file_stats[key] = {"snake_case": 0, "camelCase": 0}
+                    file_stats[key]["snake_case"] += 1
+                elif is_camel:
+                    key = f"{dirname}/"
+                    if key not in file_stats:
+                        file_stats[key] = {"snake_case": 0, "camelCase": 0}
+                    file_stats[key]["camelCase"] += 1
+
+        except OSError:
+            return 0.0, []
+
+        # Check if any directory has mixed naming
+        penalty = 0.0
+        evidence = []
+
+        for dir_key, counts in file_stats.items():
+            snake_count = counts.get("snake_case", 0)
+            camel_count = counts.get("camelCase", 0)
+
+            # Only count directories with at least 2 files (need meaningful sample)
+            if snake_count > 0 and camel_count > 0:
+                total_in_dir = snake_count + camel_count
+                if total_in_dir >= 2:
+                    penalty += 10.0
+                    evidence.append(
+                        f"Mixed naming in {dir_key}: {snake_count} snake_case, {camel_count} camelCase"
+                    )
+
+        # Cap the penalty at 20 points
+        penalty = min(20.0, penalty)
+
+        if penalty > 0:
+            evidence.insert(0, "Inconsistent naming conventions detected")
+        elif total_files > 0:
+            evidence.append("Naming convention consistent")
+
+        return penalty, evidence
+
     def _create_remediation(self, has_source: bool, has_tests: bool) -> Remediation:
         """Create context-aware remediation guidance for standard layout.