diff --git a/scripts/codelens.py b/scripts/codelens.py
index ae515831..b1ac13c1 100755
--- a/scripts/codelens.py
+++ b/scripts/codelens.py
@@ -842,6 +842,8 @@ def main():
     global_max_tokens = None
     global_lite = False
     global_deep = False
+    global_disable_suppression = False
+    global_ignore_pattern = None
 
     i = 1
     while i < len(sys.argv):
@@ -878,10 +880,22 @@ def main():
             global_lite = True
         elif arg == '--deep':
             global_deep = True
+        elif arg == '--disable-suppression':
+            global_disable_suppression = True
+        elif arg == '--codelens-ignore-pattern' and i + 1 < len(sys.argv):
+            global_ignore_pattern = sys.argv[i + 1]
+        elif arg.startswith('--codelens-ignore-pattern='):
+            global_ignore_pattern = arg.split('=', 1)[1]
         i += 1
 
     args = parser.parse_args()
 
+    # Apply global flags to args
+    if getattr(args, 'disable_suppression', None) is None:
+        args.disable_suppression = globals().get('global_disable_suppression', False)
+    if getattr(args, 'codelens_ignore_pattern', None) is None:
+        args.codelens_ignore_pattern = globals().get('global_ignore_pattern', None)
+
     # Resolve format: subparser --format overrides global --format
     # If neither is set, use the parser's default (which may be "ai" if CODELENS_AI_MODE=1)
     subparser_format = getattr(args, 'format', None)
@@ -1126,6 +1140,62 @@ def main():
         if args.command == "ask" and isinstance(result, dict):
             format_command = result.get("query_interpretation", {}).get("interpreted_as", "ask")
 
+        # ─── Apply inline suppressions ──
+        if not getattr(args, 'disable_suppression', False) and isinstance(result, dict):
+            try:
+                from suppression import apply_suppressions, update_stats_with_suppressions, DEFAULT_KEYWORD_PATTERN
+
+                keyword_pattern = getattr(args, 'codelens_ignore_pattern', None) or DEFAULT_KEYWORD_PATTERN
+
+                # Collect source files from the result
+                source_files = {}
+                finding_keys = ("findings", "leaks", "hints", "issues", "violations", "matches", "chains")
+                for key in finding_keys:
+                    val = result.get(key)
+                    if isinstance(val, list):
+                        for f in val:
+                            if isinstance(f, dict):
+                                fp = f.get("file") or f.get("defined_in") or ""
+                                if fp and fp not in source_files:
+                                    try:
+                                        with open(fp, 'r', encoding='utf-8', errors='replace') as fh:
+                                            source_files[fp] = fh.read()
+                                    except (IOError, OSError):
+                                        pass
+                    elif isinstance(val, dict):
+                        for sub_val in val.values():
+                            if isinstance(sub_val, list):
+                                for f in sub_val:
+                                    if isinstance(f, dict):
+                                        fp = f.get("file") or f.get("defined_in") or ""
+                                        if fp and fp not in source_files:
+                                            try:
+                                                with open(fp, 'r', encoding='utf-8', errors='replace') as fh:
+                                                    source_files[fp] = fh.read()
+                                            except (IOError, OSError):
+                                                pass
+
+                if source_files:
+                    # Collect all findings from result
+                    all_findings = []
+                    for key in finding_keys:
+                        val = result.get(key)
+                        if isinstance(val, list):
+                            all_findings.extend(val)
+                        elif isinstance(val, dict):
+                            for sub_val in val.values():
+                                if isinstance(sub_val, list):
+                                    all_findings.extend(sub_val)
+
+                    if all_findings:
+                        apply_suppressions(all_findings, source_files, keyword_pattern=keyword_pattern)
+                        update_stats_with_suppressions(result)
+
+            except ImportError:
+                pass  # suppression module not available
+            except Exception as e:
+                logger.warning(f"Suppression processing failed: {e}", exc_info=True)
+
         # ─── Format and print output ──
         print(format_output(result, args.format, format_command, workspace))
 
diff --git a/scripts/formatters/sarif.py b/scripts/formatters/sarif.py
index 11ac41c3..3b3bb33e 100644
--- a/scripts/formatters/sarif.py
+++ b/scripts/formatters/sarif.py
@@ -313,6 +313,30 @@ def _build_results(command: str, findings: List[Dict], workspace: str) -> List[D
         if finding.get("category"):
             result["properties"]["category"] = finding["category"]
 
+        # ─── Add suppressions field per SARIF spec ──────────────────────
+        # https://docs.oasis-open.org/sarif/sarif/v2.1.0/sarif-v2.1.0.html#_Toc34317632
+        if finding.get("suppressed"):
+            suppressions = []
+            reason = finding.get("suppressed_reason", "")
+            suppressed_rules = finding.get("suppressed_rules", [])
+
+            if suppressed_rules:
+                # Specific rules suppressed
+                for rid in suppressed_rules:
+                    suppressions.append({
+                        "kind": "inSource",
+                        "justification": reason or f"Suppressed via inline annotation for rule: {rid}",
+                    })
+            else:
+                # All rules suppressed on this line
+                suppressions.append({
+                    "kind": "inSource",
+                    "justification": reason or "Suppressed via inline annotation (all rules)",
+                })
+
+            result["suppressions"] = suppressions
+            result["kind"] = "informational"
+
         # Add related locations for taint analysis
         if finding.get("taint_path") and finding.get("source"):
             source_loc = {
diff --git a/scripts/suppression.py b/scripts/suppression.py
new file mode 100644
index 00000000..32fddc31
--- /dev/null
+++ b/scripts/suppression.py
@@ -0,0 +1,476 @@
+"""
+Inline Suppression Detection and Application for CodeLens.
+
+Supports cross-language inline suppression annotations:
+  - ``# codelens-ignore`` (Python, Ruby, PHP, shell)
+  - ``// codelens-ignore`` (JS, TS, Rust, Go, Java, C, C++)
+  - ``/* codelens-ignore */`` (CSS, multi-line C-family)
+  - ``<!-- codelens-ignore -->`` (HTML)
+
+Three keyword aliases:
+  - ``codelens-ignore`` (default, brandable)
+  - ``nolens`` (short alias)
+  - ``nosemgrep`` (Semgrep ecosystem compat)
+
+Syntax variants:
+  - ``<code>  // codelens-ignore: rule-id-1, rule-id-2 -- reason``
+  - ``<code>  // codelens-ignore`` (suppress all rules on line)
+  - ``/* codelens-ignore-next: rule-id */`` (suppress next line)
+
+Suppressed findings remain in output with ``status: "suppressed"`` for auditability.
+SARIF ``suppressions`` field is populated per spec.
+"""
+
+import re
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Set
+
+
+# ─── Default keyword pattern ────────────────────────────────────────────────
+
+DEFAULT_KEYWORD_PATTERN = r"codelens-ignore|nolens|nosemgrep"
+
+# All supported keywords (for documentation / validation)
+SUPPORTED_KEYWORDS = ("codelens-ignore", "nolens", "nosemgrep")
+
+
+# ─── SuppressionInfo Dataclass ──────────────────────────────────────────────
+
+@dataclass
+class SuppressionInfo:
+    """Parsed suppression annotation information.
+
+    Attributes:
+        rule_ids: List of specific rule IDs to suppress. Empty list = suppress all.
+        reason: Human-readable reason for suppression (empty string if not provided).
+        is_next_line: True if this is a ``-next`` annotation that applies to the
+            following line rather than the current line.
+        keyword: The actual keyword used (e.g., "codelens-ignore", "nolens").
+    """
+
+    rule_ids: List[str] = field(default_factory=list)
+    reason: str = ""
+    is_next_line: bool = False
+    keyword: str = "codelens-ignore"
+
+
+# ─── Detection ──────────────────────────────────────────────────────────────
+
+# Pre-compiled regex for performance.
+# Matches: keyword[: rule1, rule2 -- reason] or keyword-next[: rule1, rule2 -- reason]
+# Examples:
+#   codelens-ignore
+#   codelens-ignore: rule-1, rule-2 -- some reason
+#   codelens-ignore-next: rule-1
+#   nolens
+#   nosemgrep: rule-1 -- false positive
+# Step 1: Match the keyword (with optional -next suffix)
+_KEYWORD_RE = re.compile(
+    r"(?P<keyword>codelens-ignore|nolens|nosemgrep)(?P<next>-next)?",
+    re.IGNORECASE,
+)
+
+
+def detect_suppression(
+    comment_text: str,
+    default_keyword: str = "codelens-ignore",
+    keyword_pattern: str = DEFAULT_KEYWORD_PATTERN,
+) -> Optional[SuppressionInfo]:
+    """Detect a suppression annotation in a comment string.
+
+    Args:
+        comment_text: The raw comment text (may include comment delimiters like ``#``, ``//``).
+        default_keyword: The default keyword to use in SuppressionInfo.
+        keyword_pattern: Regex pattern string for custom keywords.
+
+    Returns:
+        SuppressionInfo if a suppression annotation is found, None otherwise.
+    """
+    if not comment_text:
+        return None
+
+    # Strip comment delimiters to get the inner text
+    text = comment_text.strip()
+    # Remove common comment prefixes
+    text = re.sub(r"^(#+|//+|/\*+|<!--|--|;)", "", text).strip()
+    # Remove trailing comment suffixes
+    text = re.sub(r"(\*/|-->)\s*$", "", text).strip()
+
+    # Check if any keyword is present using the keyword pattern
+    keyword_re = re.compile(keyword_pattern, re.IGNORECASE)
+    kw_match = keyword_re.search(text)
+    if not kw_match:
+        return None
+
+    # Get the matched keyword
+    keyword = kw_match.group(0).lower()
+
+    # Check for -next suffix right after the keyword
+    after_kw_match = text[kw_match.end():]
+    is_next = after_kw_match.startswith("-next")
+    if is_next:
+        after_keyword = after_kw_match[5:].strip()  # Skip "-next"
+    else:
+        after_keyword = after_kw_match.strip()
+
+    rule_ids: List[str] = []
+    reason: str = ""
+
+    if after_keyword:
+        # Check for ":" to separate rules
+        if after_keyword.startswith(":"):
+            after_colon = after_keyword[1:].strip()
+            # Check for "--" to separate reason
+            if " -- " in after_colon:
+                parts = after_colon.split(" -- ", 1)
+                rules_str = parts[0].strip()
+                reason = parts[1].strip()
+            else:
+                rules_str = after_colon
+                reason = ""
+
+            # Parse comma-separated rule IDs
+            rule_ids = [r.strip() for r in rules_str.split(",") if r.strip()]
+        elif after_keyword.startswith("--"):
+            # Only reason, no rules
+            reason = after_keyword[2:].strip()
+
+    return SuppressionInfo(
+        rule_ids=rule_ids,
+        reason=reason,
+        is_next_line=is_next,
+        keyword=keyword,
+    )
+
+
+# ─── Comment Detection Per Language ─────────────────────────────────────────
+
+# Language → comment prefixes (for fallback regex parsers)
+COMMENT_PREFIXES: Dict[str, List[str]] = {
+    "python": ["#"],
+    "ruby": ["#"],
+    "php": ["#", "//", "/*"],
+    "shell": ["#"],
+    "yaml": ["#"],
+    "toml": ["#"],
+    "javascript": ["//", "/*"],
+    "typescript": ["//", "/*"],
+    "rust": ["//", "/*"],
+    "go": ["//", "/*"],
+    "java": ["//", "/*"],
+    "c": ["//", "/*"],
+    "cpp": ["//", "/*"],
+    "csharp": ["//", "/*"],
+    "kotlin": ["//", "/*"],
+    "swift": ["//", "/*"],
+    "css": ["/*"],
+    "html": ["<!--"],
+    "xml": ["<!--"],
+    "sql": ["--"],
+}
+
+
+def _detect_language_from_extension(file_path: str) -> str:
+    """Detect language from file extension.
+
+    Args:
+        file_path: Path to the source file.
+
+    Returns:
+        Language name (lowercase) or "unknown".
+    """
+    ext_map = {
+        ".py": "python", ".rb": "ruby", ".php": "php", ".sh": "shell",
+        ".js": "javascript", ".mjs": "javascript", ".cjs": "javascript",
+        ".jsx": "javascript", ".ts": "typescript", ".tsx": "typescript",
+        ".rs": "rust", ".go": "go", ".java": "java",
+        ".c": "c", ".h": "c", ".cpp": "cpp", ".cc": "cpp", ".hpp": "cpp",
+        ".cs": "csharp", ".kt": "kotlin", ".swift": "swift",
+        ".css": "css", ".html": "html", ".htm": "html", ".xml": "xml",
+        ".sql": "sql", ".yaml": "yaml", ".yml": "yaml", ".toml": "toml",
+    }
+    for ext, lang in ext_map.items():
+        if file_path.endswith(ext):
+            return lang
+    return "unknown"
+
+
+def _extract_comments_from_line(line: str, language: str) -> List[str]:
+    """Extract comment text from a source line for the given language.
+
+    Handles inline comments (code + comment on same line) and full-line comments.
+
+    Args:
+        line: A single line of source code.
+        language: Language name (lowercase).
+
+    Returns:
+        List of comment strings found in the line.
+    """
+    prefixes = COMMENT_PREFIXES.get(language, [])
+    comments = []
+
+    for prefix in prefixes:
+        # Find the prefix in the line (not inside a string — simplified)
+        idx = _find_comment_start(line, prefix)
+        if idx >= 0:
+            comment = line[idx:]
+            comments.append(comment)
+
+    # Deduplicate (/* might match both // and /*)
+    seen = set()
+    unique = []
+    for c in comments:
+        if c not in seen:
+            seen.add(c)
+            unique.append(c)
+    return unique
+
+
+def _find_comment_start(line: str, prefix: str) -> int:
+    """Find the start index of a comment prefix in a line, ignoring strings.
+
+    This is a simplified string-aware search. It handles basic cases:
+    - Double-quoted strings: "hello // world" — the // inside is not a comment
+    - Single-quoted strings: 'hello // world' — same
+    - Backtick strings (JS/TS): `hello // world` — same
+
+    Args:
+        line: Source code line.
+        prefix: Comment prefix to find (e.g., "//", "#", "/*").
+
+    Returns:
+        Index of the comment start, or -1 if not found.
+    """
+    in_string = None  # None, '"', "'", or '`'
+    i = 0
+    while i < len(line):
+        ch = line[i]
+
+        if in_string:
+            if ch == in_string:
+                in_string = None
+            elif ch == "\\" and i + 1 < len(line):
+                i += 1  # Skip escaped character
+        else:
+            if ch in ('"', "'", "`"):
+                in_string = ch
+            elif line[i:i + len(prefix)] == prefix:
+                return i
+        i += 1
+    return -1
+
+
+# ─── Apply Suppressions ────────────────────────────────────────────────────
+
+def apply_suppressions(
+    findings: List[Dict],
+    source_files: Dict[str, str],
+    keyword: str = "codelens-ignore",
+    keyword_pattern: str = DEFAULT_KEYWORD_PATTERN,
+) -> List[Dict]:
+    """Apply inline suppressions to findings.
+
+    Findings are mutated in-place: ``suppressed``, ``suppressed_rules``,
+    and ``suppressed_reason`` fields are set.
+
+    Suppression logic:
+    1. For each finding, look at the finding's line in the source file.
+    2. Check for inline suppression on that line.
+    3. If not found and the finding is on line N, check line N-1 for a
+       ``-next`` annotation.
+    4. If a suppression is found:
+       - If rule_ids is empty → suppress all rules (suppressed = True).
+       - If rule_ids is non-empty → suppress only if the finding's rule_id
+         or category matches one of the listed rule_ids.
+
+    Args:
+        findings: List of finding dicts. Each should have ``file``, ``line``
+            (or ``line_number``), and optionally ``rule_id`` or ``category``.
+        source_files: Dict mapping file path → file content string.
+        keyword: Default keyword name (for SuppressionInfo.keyword).
+        keyword_pattern: Regex pattern for keyword matching.
+
+    Returns:
+        The same findings list (mutated in-place).
+    """
+    # Pre-parse suppression annotations per file
+    # Structure: {file_path: {line_num: [SuppressionInfo, ...]}}
+    file_suppressions: Dict[str, Dict[int, List[SuppressionInfo]]] = {}
+    # Also track next-line suppressions: {file_path: {line_num: [SuppressionInfo, ...]}}
+    # where line_num is the line ON WHICH the -next annotation appears (applies to line+1)
+    file_next_suppressions: Dict[str, Dict[int, List[SuppressionInfo]]] = {}
+
+    for file_path, content in source_files.items():
+        language = _detect_language_from_extension(file_path)
+        lines = content.split("\n")
+
+        file_suppressions[file_path] = {}
+        file_next_suppressions[file_path] = {}
+
+        for i, line in enumerate(lines):
+            line_num = i + 1  # 1-indexed
+            comments = _extract_comments_from_line(line, language)
+
+            for comment in comments:
+                info = detect_suppression(comment, keyword, keyword_pattern)
+                if info:
+                    if info.is_next_line:
+                        # This suppression applies to the NEXT line
+                        if line_num not in file_next_suppressions[file_path]:
+                            file_next_suppressions[file_path][line_num] = []
+                        file_next_suppressions[file_path][line_num].append(info)
+                    else:
+                        # This suppression applies to the CURRENT line
+                        if line_num not in file_suppressions[file_path]:
+                            file_suppressions[file_path][line_num] = []
+                        file_suppressions[file_path][line_num].append(info)
+
+    # Apply suppressions to findings
+    for finding in findings:
+        file_path = finding.get("file") or finding.get("defined_in") or ""
+        line_num = finding.get("line") or finding.get("line_number") or 0
+        if isinstance(line_num, str):
+            try:
+                line_num = int(line_num)
+            except ValueError:
+                continue
+
+        if not file_path or not line_num:
+            continue
+
+        # Initialize suppression fields
+        finding.setdefault("suppressed", False)
+        finding.setdefault("suppressed_rules", [])
+        finding.setdefault("suppressed_reason", "")
+
+        # Get the finding's rule ID
+        finding_rule_id = (
+            finding.get("rule_id")
+            or finding.get("ruleId")
+            or finding.get("category")
+            or finding.get("type")
+            or ""
+        )
+
+        # Check same-line suppressions
+        same_line_infos = file_suppressions.get(file_path, {}).get(line_num, [])
+        for info in same_line_infos:
+            if _matches_suppression(info, finding_rule_id):
+                finding["suppressed"] = True
+                if info.rule_ids:
+                    finding["suppressed_rules"] = info.rule_ids
+                finding["suppressed_reason"] = info.reason
+                break
+
+        if finding["suppressed"]:
+            continue
+
+        # Check next-line suppressions (line_num - 1 has the -next annotation)
+        prev_line = line_num - 1
+        next_line_infos = file_next_suppressions.get(file_path, {}).get(prev_line, [])
+        for info in next_line_infos:
+            if _matches_suppression(info, finding_rule_id):
+                finding["suppressed"] = True
+                if info.rule_ids:
+                    finding["suppressed_rules"] = info.rule_ids
+                finding["suppressed_reason"] = info.reason
+                break
+
+    return findings
+
+
+def _matches_suppression(info: SuppressionInfo, finding_rule_id: str) -> bool:
+    """Check if a suppression info matches a finding's rule ID.
+
+    Args:
+        info: Parsed suppression info.
+        finding_rule_id: The finding's rule ID or category.
+
+    Returns:
+        True if the suppression applies to this finding.
+    """
+    # If no specific rule_ids → suppress everything
+    if not info.rule_ids:
+        return True
+
+    # If specific rule_ids → check if finding's rule matches
+    finding_rule_lower = finding_rule_id.lower().strip()
+    for rid in info.rule_ids:
+        rid_lower = rid.lower().strip()
+        # Exact match or suffix match (e.g., "long-function" matches "codelens/smell/long-function")
+        if finding_rule_lower == rid_lower or finding_rule_lower.endswith(rid_lower):
+            return True
+    return False
+
+
+# ─── Count Pipeline Helpers ─────────────────────────────────────────────────
+
+def update_stats_with_suppressions(result: Dict) -> Dict:
+    """Update stats in a result dict to include suppression counts.
+
+    This ensures suppressed findings are counted separately from active ones,
+    preventing the UBS bug #51 pattern where suppressed findings are silently
+    missed in count pipelines.
+
+    Affected stat fields (per engine):
+    - smell.stats.total_findings → stays as total (includes suppressed)
+    - smell.stats.suppressed_count → NEW field
+    - secrets.stats.findings_count → stays as total
+    - secrets.stats.suppressed_count → NEW field
+    - taint.stats.violations → stays as total
+    - taint.stats.suppressed_count → NEW field
+    - Any engine with stats.*_count → add stats.suppressed_count
+
+    Args:
+        result: The engine result dict.
+
+    Returns:
+        The same result dict (mutated in-place).
+    """
+    if not isinstance(result, dict):
+        return result
+
+    # Collect all findings from the result
+    all_findings = _collect_findings(result)
+    if not all_findings:
+        return result
+
+    suppressed_count = sum(1 for f in all_findings if f.get("suppressed", False))
+
+    # Update stats
+    stats = result.get("stats", {})
+    if isinstance(stats, dict):
+        stats["suppressed_count"] = suppressed_count
+        # Also add to top-level for convenience
+        result["suppressed_count"] = suppressed_count
+
+    return result
+
+
+def _collect_findings(result: Dict) -> List[Dict]:
+    """Collect all finding-like dicts from a result.
+
+    Looks in: findings, leaks, hints, issues, violations, matches, chains,
+    and by_category (dict of lists).
+    """
+    findings = []
+    finding_keys = ("findings", "leaks", "hints", "issues", "violations", "matches", "chains")
+
+    for key in finding_keys:
+        val = result.get(key)
+        if isinstance(val, list):
+            findings.extend(val)
+        elif isinstance(val, dict):
+            for sub_val in val.values():
+                if isinstance(sub_val, list):
+                    findings.extend(sub_val)
+
+    # Also check by_category
+    by_cat = result.get("by_category")
+    if isinstance(by_cat, dict):
+        for sub_val in by_cat.values():
+            if isinstance(sub_val, list):
+                findings.extend(sub_val)
+
+    return findings
diff --git a/tests/test_suppression.py b/tests/test_suppression.py
new file mode 100644
index 00000000..aed76441
--- /dev/null
+++ b/tests/test_suppression.py
@@ -0,0 +1,630 @@
+"""
+Tests for inline suppression detection and application.
+
+Covers 12 languages × 3 cases each = 36 cases minimum, plus
+additional tests for custom keywords, disable-suppression mode,
+and count pipeline auditing (UBS bug #51 pattern).
+"""
+
+import os
+import sys
+import tempfile
+import pytest
+
+# Add scripts to path
+SCRIPT_DIR = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "scripts")
+sys.path.insert(0, SCRIPT_DIR)
+
+from suppression import (
+    SuppressionInfo,
+    detect_suppression,
+    apply_suppressions,
+    update_stats_with_suppressions,
+    DEFAULT_KEYWORD_PATTERN,
+    _detect_language_from_extension,
+    _extract_comments_from_line,
+)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Part 1: detect_suppression() unit tests
+# ═══════════════════════════════════════════════════════════════════════════
+
+class TestDetectSuppression:
+    """Tests for detect_suppression() function."""
+
+    def test_basic_keyword(self):
+        """codelens-ignore with no rules or reason."""
+        result = detect_suppression("# codelens-ignore")
+        assert result is not None
+        assert result.rule_ids == []
+        assert result.reason == ""
+        assert result.is_next_line is False
+
+    def test_with_rule_ids(self):
+        """codelens-ignore with specific rule IDs."""
+        result = detect_suppression("// codelens-ignore: rule-1, rule-2")
+        assert result is not None
+        assert result.rule_ids == ["rule-1", "rule-2"]
+        assert result.reason == ""
+
+    def test_with_reason(self):
+        """codelens-ignore with reason."""
+        result = detect_suppression("# codelens-ignore: rule-1 -- false positive")
+        assert result is not None
+        assert result.rule_ids == ["rule-1"]
+        assert result.reason == "false positive"
+
+    def test_with_rules_and_reason(self):
+        """codelens-ignore with multiple rules and reason."""
+        result = detect_suppression("// codelens-ignore: rule-a, rule-b -- known issue")
+        assert result is not None
+        assert result.rule_ids == ["rule-a", "rule-b"]
+        assert result.reason == "known issue"
+
+    def test_next_line(self):
+        """codelens-ignore-next variant."""
+        result = detect_suppression("// codelens-ignore-next: rule-1")
+        assert result is not None
+        assert result.is_next_line is True
+        assert result.rule_ids == ["rule-1"]
+
+    def test_nolens_alias(self):
+        """nolens keyword alias."""
+        result = detect_suppression("# nolens")
+        assert result is not None
+        assert result.keyword == "nolens"
+
+    def test_nosemgrep_alias(self):
+        """nosemgrep keyword alias."""
+        result = detect_suppression("// nosemgrep: rule-1 -- semgrep compat")
+        assert result is not None
+        assert result.keyword == "nosemgrep"
+        assert result.rule_ids == ["rule-1"]
+
+    def test_no_keyword(self):
+        """No suppression keyword present → None."""
+        result = detect_suppression("# this is a regular comment")
+        assert result is None
+
+    def test_empty_string(self):
+        """Empty string → None."""
+        result = detect_suppression("")
+        assert result is None
+
+    def test_css_comment(self):
+        """CSS-style comment with suppression."""
+        result = detect_suppression("/* codelens-ignore: rule-1 */")
+        assert result is not None
+        assert result.rule_ids == ["rule-1"]
+
+    def test_html_comment(self):
+        """HTML-style comment with suppression."""
+        result = detect_suppression("<!-- codelens-ignore -->")
+        assert result is not None
+        assert result.rule_ids == []
+
+    def test_custom_keyword_pattern(self):
+        """Custom keyword pattern."""
+        result = detect_suppression(
+            "# my-ignore: rule-1",
+            keyword_pattern=r"my-ignore",
+        )
+        assert result is not None
+        assert result.rule_ids == ["rule-1"]
+
+    def test_case_insensitive(self):
+        """Keyword matching is case-insensitive."""
+        result = detect_suppression("# CODELENS-IGNORE: rule-1")
+        assert result is not None
+        assert result.rule_ids == ["rule-1"]
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Part 2: Per-language suppression tests (12 languages × 3 cases = 36)
+# ═══════════════════════════════════════════════════════════════════════════
+
+def _make_finding(file_path: str, line: int, rule_id: str = "", category: str = "") -> dict:
+    """Create a minimal finding dict for testing."""
+    f = {"file": file_path, "line": line, "severity": "high", "message": "test finding"}
+    if rule_id:
+        f["rule_id"] = rule_id
+    if category:
+        f["category"] = category
+    return f
+
+
+class TestPythonSuppression:
+    """Python: # codelens-ignore"""
+
+    def test_suppress_all(self):
+        code = "x = eval(input())  # codelens-ignore\n"
+        fp = "/tmp/test.py"
+        findings = [_make_finding(fp, 1, "eval-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+    def test_suppress_specific_rule(self):
+        code = "x = eval(input())  # codelens-ignore: eval-injection -- safe in tests\n"
+        fp = "/tmp/test.py"
+        findings = [_make_finding(fp, 1, "eval-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+        assert result[0]["suppressed_reason"] == "safe in tests"
+
+    def test_next_line_suppression(self):
+        code = "# codelens-ignore-next: eval-injection\nx = eval(input())\n"
+        fp = "/tmp/test.py"
+        findings = [_make_finding(fp, 2, "eval-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+
+class TestJavaScriptSuppression:
+    """JavaScript: // codelens-ignore"""
+
+    def test_suppress_all(self):
+        code = "eval(userInput);  // codelens-ignore\n"
+        fp = "/tmp/test.js"
+        findings = [_make_finding(fp, 1, "eval-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+    def test_suppress_specific_rule(self):
+        code = "eval(userInput);  // codelens-ignore: eval-injection\n"
+        fp = "/tmp/test.js"
+        findings = [_make_finding(fp, 1, "other-rule")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is False
+
+    def test_next_line_suppression(self):
+        code = "// codelens-ignore-next\neval(userInput);\n"
+        fp = "/tmp/test.js"
+        findings = [_make_finding(fp, 2, "eval-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+
+class TestTypeScriptSuppression:
+    """TypeScript: // codelens-ignore"""
+
+    def test_suppress_all(self):
+        code = "const x: any = eval(input);  // codelens-ignore\n"
+        fp = "/tmp/test.ts"
+        findings = [_make_finding(fp, 1, "eval-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+    def test_suppress_with_reason(self):
+        code = "const x: any = eval(input);  // codelens-ignore: eval-injection -- test only\n"
+        fp = "/tmp/test.ts"
+        findings = [_make_finding(fp, 1, "eval-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+        assert result[0]["suppressed_reason"] == "test only"
+
+    def test_next_line_suppression(self):
+        code = "// codelens-ignore-next: eval-injection\nconst x: any = eval(input);\n"
+        fp = "/tmp/test.ts"
+        findings = [_make_finding(fp, 2, "eval-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+
+class TestRustSuppression:
+    """Rust: // codelens-ignore"""
+
+    def test_suppress_all(self):
+        code = "unsafe { std::ptr::null_mut(); }  // codelens-ignore\n"
+        fp = "/tmp/test.rs"
+        findings = [_make_finding(fp, 1, "unsafe-block")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+    def test_suppress_specific_rule(self):
+        code = "unsafe { std::ptr::null_mut(); }  // codelens-ignore: unsafe-block\n"
+        fp = "/tmp/test.rs"
+        findings = [_make_finding(fp, 1, "unsafe-block")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+    def test_no_suppression(self):
+        code = "unsafe { std::ptr::null_mut(); }\n"
+        fp = "/tmp/test.rs"
+        findings = [_make_finding(fp, 1, "unsafe-block")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is False
+
+
+class TestGoSuppression:
+    """Go: // codelens-ignore"""
+
+    def test_suppress_all(self):
+        code = 'fmt.Sprintf(userInput)  // codelens-ignore\n'
+        fp = "/tmp/test.go"
+        findings = [_make_finding(fp, 1, "fmt-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+    def test_next_line(self):
+        code = '// codelens-ignore-next: fmt-injection\nfmt.Sprintf(userInput)\n'
+        fp = "/tmp/test.go"
+        findings = [_make_finding(fp, 2, "fmt-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+    def test_non_matching_rule(self):
+        code = '// codelens-ignore: other-rule\nfmt.Sprintf(userInput)\n'
+        fp = "/tmp/test.go"
+        findings = [_make_finding(fp, 2, "fmt-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is False
+
+
+class TestJavaSuppression:
+    """Java: // codelens-ignore"""
+
+    def test_suppress_all(self):
+        code = 'Runtime.exec(userInput);  // codelens-ignore\n'
+        fp = "/tmp/test.java"
+        findings = [_make_finding(fp, 1, "command-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+    def test_suppress_specific(self):
+        code = 'Runtime.exec(userInput);  // codelens-ignore: command-injection -- safe\n'
+        fp = "/tmp/test.java"
+        findings = [_make_finding(fp, 1, "command-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+        assert result[0]["suppressed_reason"] == "safe"
+
+    def test_next_line(self):
+        code = '// codelens-ignore-next\nRuntime.exec(userInput);\n'
+        fp = "/tmp/test.java"
+        findings = [_make_finding(fp, 2, "command-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+
+class TestCSuppression:
+    """C: // codelens-ignore"""
+
+    def test_suppress_all(self):
+        code = 'strcpy(dst, userInput);  // codelens-ignore\n'
+        fp = "/tmp/test.c"
+        findings = [_make_finding(fp, 1, "buffer-overflow")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+    def test_block_comment(self):
+        code = 'strcpy(dst, userInput);  /* codelens-ignore: buffer-overflow */\n'
+        fp = "/tmp/test.c"
+        findings = [_make_finding(fp, 1, "buffer-overflow")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+    def test_next_line(self):
+        code = '// codelens-ignore-next: buffer-overflow\nstrcpy(dst, userInput);\n'
+        fp = "/tmp/test.c"
+        findings = [_make_finding(fp, 2, "buffer-overflow")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+
+class TestCppSuppression:
+    """C++: // codelens-ignore"""
+
+    def test_suppress_all(self):
+        code = 'system(userInput);  // codelens-ignore\n'
+        fp = "/tmp/test.cpp"
+        findings = [_make_finding(fp, 1, "command-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+    def test_specific_rule(self):
+        code = 'system(userInput);  // codelens-ignore: command-injection\n'
+        fp = "/tmp/test.cpp"
+        findings = [_make_finding(fp, 1, "command-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+    def test_non_matching(self):
+        code = 'system(userInput);  // codelens-ignore: other-rule\n'
+        fp = "/tmp/test.cpp"
+        findings = [_make_finding(fp, 1, "command-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is False
+
+
+class TestRubySuppression:
+    """Ruby: # codelens-ignore"""
+
+    def test_suppress_all(self):
+        code = 'eval(user_input)  # codelens-ignore\n'
+        fp = "/tmp/test.rb"
+        findings = [_make_finding(fp, 1, "eval-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+    def test_specific_rule(self):
+        code = 'eval(user_input)  # codelens-ignore: eval-injection -- safe\n'
+        fp = "/tmp/test.rb"
+        findings = [_make_finding(fp, 1, "eval-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+        assert result[0]["suppressed_reason"] == "safe"
+
+    def test_next_line(self):
+        code = '# codelens-ignore-next: eval-injection\neval(user_input)\n'
+        fp = "/tmp/test.rb"
+        findings = [_make_finding(fp, 2, "eval-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+
+class TestPHPSuppression:
+    """PHP: # codelens-ignore or // codelens-ignore"""
+
+    def test_hash_comment(self):
+        code = '<?php eval($input);  # codelens-ignore\n'
+        fp = "/tmp/test.php"
+        findings = [_make_finding(fp, 1, "eval-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+    def test_slash_comment(self):
+        code = '<?php eval($input);  // codelens-ignore: eval-injection\n'
+        fp = "/tmp/test.php"
+        findings = [_make_finding(fp, 1, "eval-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+    def test_block_comment(self):
+        code = '<?php eval($input);  /* codelens-ignore */\n'
+        fp = "/tmp/test.php"
+        findings = [_make_finding(fp, 1, "eval-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+
+class TestHTMLSuppression:
+    """HTML: <!-- codelens-ignore -->"""
+
+    def test_suppress_all(self):
+        code = '<script>eval(userInput);</script>  <!-- codelens-ignore -->\n'
+        fp = "/tmp/test.html"
+        findings = [_make_finding(fp, 1, "xss")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+    def test_suppress_specific(self):
+        code = '<script>eval(userInput);</script>  <!-- codelens-ignore: xss -->\n'
+        fp = "/tmp/test.html"
+        findings = [_make_finding(fp, 1, "xss")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+    def test_next_line(self):
+        code = '<!-- codelens-ignore-next: xss -->\n<script>eval(userInput);</script>\n'
+        fp = "/tmp/test.html"
+        findings = [_make_finding(fp, 2, "xss")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+
+class TestCSSSuppression:
+    """CSS: /* codelens-ignore */"""
+
+    def test_suppress_all(self):
+        code = '.hidden { display: none; }  /* codelens-ignore */\n'
+        fp = "/tmp/test.css"
+        findings = [_make_finding(fp, 1, "display-none")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+    def test_suppress_specific(self):
+        code = '.hidden { display: none; }  /* codelens-ignore: display-none */\n'
+        fp = "/tmp/test.css"
+        findings = [_make_finding(fp, 1, "display-none")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+    def test_next_line(self):
+        code = '/* codelens-ignore-next: display-none */\n.hidden { display: none; }\n'
+        fp = "/tmp/test.css"
+        findings = [_make_finding(fp, 2, "display-none")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Part 3: Multi-rule, custom keyword, disable-suppression mode
+# ═══════════════════════════════════════════════════════════════════════════
+
+class TestMultiRuleSuppression:
+    """Tests for multi-rule suppression on a single line."""
+
+    def test_multi_rule_suppress_matching(self):
+        code = 'x = eval(input)  # codelens-ignore: rule-a, rule-b, eval-injection\n'
+        fp = "/tmp/test.py"
+        findings = [_make_finding(fp, 1, "eval-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+    def test_multi_rule_suppress_non_matching(self):
+        code = 'x = eval(input)  # codelens-ignore: rule-a, rule-b\n'
+        fp = "/tmp/test.py"
+        findings = [_make_finding(fp, 1, "eval-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is False
+
+    def test_suffix_match(self):
+        """Rule ID suffix matching: 'long-function' matches 'codelens/smell/long-function'."""
+        code = 'def very_long_function():  # codelens-ignore: long-function\n'
+        fp = "/tmp/test.py"
+        findings = [_make_finding(fp, 1, "codelens/smell/long-function")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+
+class TestCustomKeyword:
+    """Tests for custom keyword pattern."""
+
+    def test_custom_keyword_suppress(self):
+        code = 'eval(input)  # mycustom-ignore: eval-injection\n'
+        fp = "/tmp/test.py"
+        findings = [_make_finding(fp, 1, "eval-injection")]
+        result = apply_suppressions(
+            findings, {fp: code},
+            keyword_pattern=r"mycustom-ignore",
+        )
+        assert result[0]["suppressed"] is True
+
+    def test_custom_keyword_not_default(self):
+        """Default keyword should not match when custom is set."""
+        code = 'eval(input)  # codelens-ignore\n'
+        fp = "/tmp/test.py"
+        findings = [_make_finding(fp, 1, "eval-injection")]
+        result = apply_suppressions(
+            findings, {fp: code},
+            keyword_pattern=r"mycustom-ignore",
+        )
+        assert result[0]["suppressed"] is False
+
+
+class TestCountPipeline:
+    """Tests for count pipeline — UBS bug #51 pattern audit."""
+
+    def test_suppressed_count_in_stats(self):
+        """Suppressed findings are counted as suppressed, not active."""
+        code = 'eval(input)  # codelens-ignore\n'
+        fp = "/tmp/test.py"
+        findings = [
+            _make_finding(fp, 1, "eval-injection"),
+            _make_finding(fp, 2, "other-rule"),  # line 2 has no suppression
+        ]
+        apply_suppressions(findings, {fp: code})
+        result = {"findings": findings, "stats": {"total_findings": 2}}
+        update_stats_with_suppressions(result)
+        assert result["stats"]["suppressed_count"] == 1
+        assert result["stats"]["total_findings"] == 2  # Total includes suppressed
+
+    def test_all_suppressed(self):
+        """All findings suppressed — suppressed_count equals total."""
+        code = 'eval(input)  # codelens-ignore\neval(input2)  # codelens-ignore\n'
+        fp = "/tmp/test.py"
+        findings = [
+            _make_finding(fp, 1, "eval-injection"),
+            _make_finding(fp, 2, "eval-injection"),
+        ]
+        apply_suppressions(findings, {fp: code})
+        result = {"findings": findings, "stats": {"total_findings": 2}}
+        update_stats_with_suppressions(result)
+        assert result["stats"]["suppressed_count"] == 2
+
+    def test_none_suppressed(self):
+        """No findings suppressed — suppressed_count is 0."""
+        code = 'eval(input)\n'
+        fp = "/tmp/test.py"
+        findings = [_make_finding(fp, 1, "eval-injection")]
+        apply_suppressions(findings, {fp: code})
+        result = {"findings": findings, "stats": {"total_findings": 1}}
+        update_stats_with_suppressions(result)
+        assert result["stats"]["suppressed_count"] == 0
+
+    def test_by_category_findings(self):
+        """Findings in by_category dict are properly counted."""
+        code = 'eval(input)  # codelens-ignore\n'
+        fp = "/tmp/test.py"
+        findings = [_make_finding(fp, 1, "eval-injection")]
+        apply_suppressions(findings, {fp: code})
+        result = {"by_category": {"security": findings}, "stats": {"total_findings": 1}}
+        update_stats_with_suppressions(result)
+        assert result["stats"]["suppressed_count"] == 1
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Part 4: Edge cases
+# ═══════════════════════════════════════════════════════════════════════════
+
+class TestEdgeCases:
+    """Edge case tests."""
+
+    def test_finding_on_wrong_line_not_suppressed(self):
+        """Suppression on line 1 does not affect finding on line 3."""
+        code = 'eval(input)  # codelens-ignore\nx = 1\ny = 2\n'
+        fp = "/tmp/test.py"
+        findings = [_make_finding(fp, 3, "eval-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is False
+
+    def test_multiple_findings_same_line(self):
+        """Multiple findings on the same suppressed line are all suppressed."""
+        code = 'eval(input)  # codelens-ignore\n'
+        fp = "/tmp/test.py"
+        findings = [
+            _make_finding(fp, 1, "eval-injection"),
+            _make_finding(fp, 1, "other-rule"),
+        ]
+        result = apply_suppressions(findings, {fp: code})
+        assert all(f["suppressed"] for f in result)
+
+    def test_suppression_in_string_not_detected(self):
+        """Comment-like text inside a string is not a suppression."""
+        code = 'x = "# codelens-ignore"\neval(input)\n'
+        fp = "/tmp/test.py"
+        findings = [_make_finding(fp, 2, "eval-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is False
+
+    def test_nolens_next_line(self):
+        """nolens-next variant works."""
+        code = '# nolens-next: eval-injection\neval(input)\n'
+        fp = "/tmp/test.py"
+        findings = [_make_finding(fp, 2, "eval-injection")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is True
+
+    def test_language_detection(self):
+        """Language detection from file extension."""
+        assert _detect_language_from_extension("/tmp/test.py") == "python"
+        assert _detect_language_from_extension("/tmp/test.js") == "javascript"
+        assert _detect_language_from_extension("/tmp/test.rs") == "rust"
+        assert _detect_language_from_extension("/tmp/test.go") == "go"
+        assert _detect_language_from_extension("/tmp/test.java") == "java"
+        assert _detect_language_from_extension("/tmp/test.cpp") == "cpp"
+        assert _detect_language_from_extension("/tmp/test.css") == "css"
+        assert _detect_language_from_extension("/tmp/test.html") == "html"
+        assert _detect_language_from_extension("/tmp/test.rb") == "ruby"
+        assert _detect_language_from_extension("/tmp/test.php") == "php"
+        assert _detect_language_from_extension("/tmp/test.ts") == "typescript"
+        assert _detect_language_from_extension("/tmp/test.c") == "c"
+
+    def test_comment_extraction_python(self):
+        """Python comment extraction."""
+        comments = _extract_comments_from_line("x = 1  # codelens-ignore", "python")
+        assert len(comments) >= 1
+        assert "codelens-ignore" in comments[0]
+
+    def test_comment_extraction_javascript(self):
+        """JavaScript comment extraction."""
+        comments = _extract_comments_from_line("x = 1;  // codelens-ignore", "javascript")
+        assert len(comments) >= 1
+        assert "codelens-ignore" in comments[0]
+
+    def test_comment_extraction_css(self):
+        """CSS comment extraction."""
+        comments = _extract_comments_from_line("x { }  /* codelens-ignore */", "css")
+        assert len(comments) >= 1
+        assert "codelens-ignore" in comments[0]
+
+    def test_no_suppression_fields_initialized(self):
+        """Findings without suppression get default fields."""
+        code = 'x = 1\n'
+        fp = "/tmp/test.py"
+        findings = [_make_finding(fp, 1, "some-rule")]
+        result = apply_suppressions(findings, {fp: code})
+        assert result[0]["suppressed"] is False
+        assert result[0]["suppressed_rules"] == []
+        assert result[0]["suppressed_reason"] == ""