v0.2.0: Add file-type filtering, .lintlangignore, --exclude

- Auto-skip non-prompt files: CHANGELOG, README, LICENSE, CONTRIBUTING,
  CODE_OF_CONDUCT, SECURITY, egg-info, .pytest_cache, node_modules, etc.
- .lintlangignore support (gitignore-style globs in project root)
- --exclude CLI flag for ad-hoc glob patterns
- 14 new tests for filtering logic
- Eliminates CHANGELOG.md false positive in G-Stack audit
- OpenHands noise reduced 55% (169→108 files, 94→42 REVIEW)

Total: 121 tests passing, ruff clean.

Author: roli-lpci

DELIVERABLES.md

@@ -0,0 +1,38 @@
+# DELIVERABLES — lintlang
+
+## Log
+
+| Date | Agent | What | Files | Output | Status | Notes |
+|------|-------|------|-------|--------|--------|-------|
+| 2026-03-25 | Herculit0 | v0.2.0: PASS/REVIEW/FAIL verdict system | 9 files | GitHub commit 54cc445 | ✅ COMPLETE | Breaking change: HERM score → verdict. Tested against 61 real files. |
+| 2026-03-25 | Herculit0 | 4-repository audit (OpenClaw + workspace skills) | 61 files | Audit report | ✅ COMPLETE | Found CRITICAL issue in lintlang-agent SKILL.md (unbounded retry). Ready to ship. |
+
+## v0.2.0 Summary
+
+**Released:** 2026-03-25  
+**Commit:** 54cc445  
+**Tests:** 107 passing, 0.09s, ruff clean
+
+### Changes
+- ✅ Terminal output: HERM score → PASS/REVIEW/FAIL verdict
+- ✅ Markdown output: verdict-centered, no score
+- ✅ JSON output: verdict at top level, HERM preserved under `herm` key
+- ✅ CLI: `--fail-on fail|review` for verdict-based CI gating
+- ✅ API: `compute_verdict()` exported
+- ✅ Scanning: .md files now included (SKILL.md was silently skipped)
+- ✅ Regex: `is_prompt_like` expanded for SKILL.md format detection
+
+### Testing
+- Terminal output: ✅ verified on 4 real SKILL.md files
+- JSON output: ✅ verified structure + verdicts
+- `--fail-on` flag: ✅ exit codes working
+- Directory scanning: ✅ 58 OpenClaw skills scanned in 0.3s
+- Verdict logic: ✅ 10 dedicated tests, all passing
+
+### Production Readiness
+- Zero false positives in 61-file audit
+- Actionable findings on all issues detected
+- Fast execution (0.3s for 58 files)
+- Backward-compatible (legacy `--fail-under` still works)
+
+**READY TO PUSH TO PyPI**

src/lintlang/cli.py

@@ -60,6 +60,12 @@ def main(argv: list[str] | None = None) -> int:
         default=None,
         help="Exit with code 1 on verdict: 'fail' (any CRITICAL/HIGH) or 'review' (any MEDIUM+). Default: no exit on verdict.",
     )
+    scan_parser.add_argument(
+        "--exclude",
+        nargs="+",
+        default=None,
+        help="Glob patterns to exclude (e.g., 'CHANGELOG.md' 'docs/**'). Non-prompt files (README, LICENSE, etc.) are skipped automatically.",
+    )
 
     # ── patterns command ───────────────────────────────────────────
     subparsers.add_parser("patterns", help="List all diagnostic patterns")
@@ -107,7 +113,7 @@ def _cmd_scan(args: argparse.Namespace) -> int:
             continue
 
         if path.is_dir():
-            dir_results = scan_directory(path, patterns=args.patterns)
+            dir_results = scan_directory(path, patterns=args.patterns, exclude=args.exclude)
             for fpath, result in dir_results.items():
                 result.structural_findings = [
                     f for f in result.structural_findings

src/lintlang/scanner.py

@@ -2,13 +2,93 @@
 
 from __future__ import annotations
 
+import re
 from dataclasses import dataclass, field
 from pathlib import Path
 
 from .herm import HermResult, score_text
 from .parsers import parse_file
 from .patterns import PATTERNS, AgentConfig, Finding
 
+# Files that are never agent configs — skip during directory scans
+NON_PROMPT_FILENAMES = {
+    "changelog.md", "changes.md", "history.md",
+    "readme.md", "readme.txt",
+    "contributing.md", "contributors.md",
+    "code_of_conduct.md", "conduct.md",
+    "security.md", "security.txt",
+    "license.md", "license.txt", "license",
+    "authors.md", "authors.txt",
+    "thanks.md", "acknowledgments.md",
+    "funding.md", "sponsors.md",
+    "todo.md", "todo.txt",
+    "requirements.txt", "setup.cfg",
+    "manifest.in", "sources.txt",
+    "dependency_links.txt", "top_level.txt", "requires.txt",
+}
+
+# Regex patterns for filenames that are clearly non-prompt
+NON_PROMPT_PATTERNS = [
+    re.compile(r"^changelog", re.I),
+    re.compile(r"^readme", re.I),
+    re.compile(r"^license", re.I),
+    re.compile(r"^contributing", re.I),
+    re.compile(r"^code.of.conduct", re.I),
+    re.compile(r"^security", re.I),
+]
+
+# Directory paths that indicate non-prompt content
+NON_PROMPT_DIRS = {
+    "egg-info", ".pytest_cache", "node_modules", "__pycache__",
+    ".git", ".tox", ".mypy_cache", ".ruff_cache",
+    "dist", "build", "htmlcov",
+}
+
+
+def _is_non_prompt_file(filepath: Path) -> bool:
+    """Heuristic: is this file clearly NOT an agent prompt/config?"""
+    name_lower = filepath.name.lower()
+
+    # Check exact filename matches
+    if name_lower in NON_PROMPT_FILENAMES:
+        return True
+
+    # Check filename patterns
+    for pattern in NON_PROMPT_PATTERNS:
+        if pattern.match(name_lower):
+            return True
+
+    # Check if in a non-prompt directory
+    return any(part.lower() in NON_PROMPT_DIRS or part.lower().endswith(".egg-info") for part in filepath.parts)
+
+
+def _load_ignore_patterns(directory: Path) -> list[re.Pattern]:
+    """Load .lintlangignore from directory (gitignore-style globs)."""
+    ignore_file = directory / ".lintlangignore"
+    if not ignore_file.exists():
+        return []
+
+    patterns = []
+    for line in ignore_file.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+        # Convert glob to regex
+        regex = line.replace(".", r"\.").replace("**/", "(.*/)?").replace("*", "[^/]*").replace("?", "[^/]")
+        try:
+            patterns.append(re.compile(regex))
+        except re.error:
+            continue
+    return patterns
+
+
+def _is_ignored(filepath: Path, base_dir: Path, patterns: list[re.Pattern]) -> bool:
+    """Check if filepath matches any .lintlangignore pattern."""
+    if not patterns:
+        return False
+    relative = str(filepath.relative_to(base_dir))
+    return any(p.search(relative) for p in patterns)
+
 
 @dataclass
 class ScanResult:
@@ -85,17 +165,56 @@ def scan_directory(
     directory: str | Path,
     patterns: list[str] | None = None,
     extensions: tuple[str, ...] = (".yaml", ".yml", ".json", ".txt", ".md", ".prompt"),
+    exclude: list[str] | None = None,
 ) -> dict[str, ScanResult]:
     """Scan all matching files in a directory.
 
+    Args:
+        directory: Path to scan recursively.
+        patterns: Optional list of structural pattern IDs (H1-H7).
+        extensions: File extensions to include.
+        exclude: Glob patterns to exclude (e.g., ["CHANGELOG.md", "docs/**"]).
+
+    Automatically skips:
+        - Non-prompt files (README, CHANGELOG, LICENSE, etc.)
+        - .lintlangignore patterns (gitignore-style, from directory root)
+        - Files matching --exclude patterns
+
     Returns:
         Dict mapping file paths to ScanResults.
     """
     directory = Path(directory)
     results: dict[str, ScanResult] = {}
 
+    # Load .lintlangignore
+    ignore_patterns = _load_ignore_patterns(directory)
+
+    # Compile --exclude patterns
+    exclude_patterns: list[re.Pattern] = []
+    if exclude:
+        for pattern in exclude:
+            regex = pattern.replace(".", r"\.").replace("**/", "(.*/)?").replace("*", "[^/]*").replace("?", "[^/]")
+            try:
+                exclude_patterns.append(re.compile(regex))
+            except re.error:
+                continue
+
     for ext in extensions:
         for filepath in directory.rglob(f"*{ext}"):
+            # Skip non-prompt files (CHANGELOG, README, etc.)
+            if _is_non_prompt_file(filepath):
+                continue
+
+            # Skip .lintlangignore matches
+            if _is_ignored(filepath, directory, ignore_patterns):
+                continue
+
+            # Skip --exclude matches
+            if exclude_patterns:
+                relative = str(filepath.relative_to(directory))
+                if any(p.search(relative) for p in exclude_patterns):
+                    continue
+
             try:
                 results[str(filepath)] = scan_file(filepath, patterns=patterns)
             except Exception as e:

tests/test_scanner.py

@@ -3,7 +3,14 @@
 from pathlib import Path
 
 from lintlang.patterns import Finding, Severity
-from lintlang.scanner import ScanResult, compute_health_score, scan_config, scan_directory, scan_file
+from lintlang.scanner import (
+    ScanResult,
+    _is_non_prompt_file,
+    compute_health_score,
+    scan_config,
+    scan_directory,
+    scan_file,
+)
 
 SAMPLES_DIR = Path(__file__).parent.parent / "samples"
 
@@ -91,6 +98,79 @@ def test_malformed_file_produces_error_finding(self, tmp_path):
             assert any(f.pattern_id == "ERR" for f in result.structural_findings)
 
 
+class TestFileTypeFiltering:
+    """Tests for non-prompt file detection and filtering."""
+
+    def test_changelog_is_non_prompt(self):
+        assert _is_non_prompt_file(Path("CHANGELOG.md"))
+
+    def test_readme_is_non_prompt(self):
+        assert _is_non_prompt_file(Path("README.md"))
+
+    def test_license_is_non_prompt(self):
+        assert _is_non_prompt_file(Path("LICENSE.md"))
+
+    def test_contributing_is_non_prompt(self):
+        assert _is_non_prompt_file(Path("CONTRIBUTING.md"))
+
+    def test_code_of_conduct_is_non_prompt(self):
+        assert _is_non_prompt_file(Path("CODE_OF_CONDUCT.md"))
+
+    def test_security_is_non_prompt(self):
+        assert _is_non_prompt_file(Path("SECURITY.md"))
+
+    def test_skill_md_is_prompt(self):
+        assert not _is_non_prompt_file(Path("SKILL.md"))
+
+    def test_config_yaml_is_prompt(self):
+        assert not _is_non_prompt_file(Path("agent_config.yaml"))
+
+    def test_system_prompt_is_prompt(self):
+        assert not _is_non_prompt_file(Path("system_prompt.txt"))
+
+    def test_egg_info_dir_is_non_prompt(self):
+        assert _is_non_prompt_file(Path("pkg.egg-info/SOURCES.txt"))
+
+    def test_pytest_cache_is_non_prompt(self):
+        assert _is_non_prompt_file(Path(".pytest_cache/README.md"))
+
+    def test_directory_scan_skips_non_prompt(self, tmp_path):
+        """scan_directory should skip CHANGELOG.md, README.md, etc."""
+        # Create a mix of prompt and non-prompt files
+        (tmp_path / "SKILL.md").write_text("You are an assistant. Use the tools.")
+        (tmp_path / "CHANGELOG.md").write_text("# Changelog\n\n## v1.0\n- Always maintain backward compatibility.")
+        (tmp_path / "README.md").write_text("# My Agent\n\nAn AI agent.")
+        (tmp_path / "LICENSE.md").write_text("MIT License")
+
+        results = scan_directory(tmp_path)
+        scanned_names = {Path(p).name for p in results}
+        assert "SKILL.md" in scanned_names
+        assert "CHANGELOG.md" not in scanned_names
+        assert "README.md" not in scanned_names
+        assert "LICENSE.md" not in scanned_names
+
+    def test_exclude_patterns(self, tmp_path):
+        """--exclude should filter matching files."""
+        (tmp_path / "config.yaml").write_text("system_prompt: You are helpful.")
+        (tmp_path / "test_config.yaml").write_text("system_prompt: Test mode.")
+
+        results = scan_directory(tmp_path, exclude=["test_*"])
+        scanned_names = {Path(p).name for p in results}
+        assert "config.yaml" in scanned_names
+        assert "test_config.yaml" not in scanned_names
+
+    def test_lintlangignore(self, tmp_path):
+        """.lintlangignore should filter matching files."""
+        (tmp_path / "config.yaml").write_text("system_prompt: You are helpful.")
+        (tmp_path / "draft.md").write_text("You are a draft assistant.")
+        (tmp_path / ".lintlangignore").write_text("draft.md\n")
+
+        results = scan_directory(tmp_path)
+        scanned_names = {Path(p).name for p in results}
+        assert "config.yaml" in scanned_names
+        assert "draft.md" not in scanned_names
+
+
 class TestHealthScore:
     """Legacy compute_health_score tests — kept for backward compat."""