@@ -303,6 +303,40 @@ A scope is one thing that was checked — a commit message, the branch, the auth
 — not one rule evaluation, so the total matches the ✔/✖ lines you can count and
 does not grow with the number of rules in your config.
 
+### Skipped Job Summary
+
+Some runs validate nothing at all — most commonly when the commit author is
+listed in `ignore_authors`, which is how Dependabot and other bots are usually
+exempted. Those runs report `⊘`, never `✔`:
+
+> <img src="https://raw.githubusercontent.com/commit-check/commit-check-action/main/assets/logo.png" width="20" align="top" alt=""> **Commit Check**
+>
+> ⊘ **All 3 checks skipped** — nothing was validated
+>
+> <details>
+> <summary>Show all 3 checks</summary>
+>
+> ```text
+> Commit message
+>   ⊘ PR title (skipped)
+>   ⊘ Commit 1/1 (skipped)
+> Branch
+>   ⊘ Branch (skipped)
+> ```
+>
+> </details>
+>
+> _commit-check &lt;version&gt; · [Rules reference](https://commit-check.com/rules/)_
+
+A skipped scope carries no checked value, because nothing was examined. When
+only some scopes skip, the verdict counts them separately —
+`✅ **3 of 5 checks passed**, 2 skipped` — so the headline never claims a pass
+that did not happen. Failures still take precedence over skips.
+
+This needs commit-check 2.13.4 or newer, which reports `"status": "skip"` in
+its JSON. Against an older engine every check is `pass` or `fail` as before,
+and the report is unchanged.
+
 ## GitHub Pull Request Comments
 
 With `pr-comments: true` the same report is posted as a pull request comment.
 
@@ -98,10 +98,24 @@ class ScopeResult:
 
     @property
     def status(self) -> str:
-        """Overall status: ``pass`` when every check passed."""
+        """Overall status: ``pass``, ``fail``, or ``skip``.
+
+        ``skip`` means every rule in this scope declined to run — the author
+        is on an ``ignore_authors`` list, or there was nothing to check. It
+        is reported separately from ``pass`` because a skipped scope
+        validated nothing, and rendering the two identically let a bypassed
+        policy read as an enforced one.
+
+        A single real verdict outranks the skips: a scope is ``skip`` only
+        when *all* of its checks skipped.
+        """
         if self.raw_text and not self.checks:
             return "fail"
-        return "fail" if any(c["status"] == "fail" for c in self.checks) else "pass"
+        if any(c["status"] == "fail" for c in self.checks):
+            return "fail"
+        if self.checks and all(c["status"] == "skip" for c in self.checks):
+            return "skip"
+        return "pass"
 
     @property
     def failures(self) -> list[dict[str, str]]:
@@ -381,6 +395,11 @@ def _render_scopes(scopes: list[ScopeResult], include_docs: bool) -> list[str]:
     """
     lines: list[str] = []
     for scope in scopes:
+        if scope.status == "skip":
+            # Deliberately not a ✔. Nothing was validated here, and a tick
+            # claiming otherwise is what made a bypassed policy look enforced.
+            lines.append(f"  ⊘ {scope.label} (skipped)")
+            continue
         if scope.status == "pass":
             value = _scope_value(scope)
             lines.append(f"  ✔ {scope.label}{f' ({value})' if value else ''}")
@@ -464,7 +483,13 @@ def render_step_log(results: list[ScopeResult]) -> None:
         )
 
     if not annotations:
-        print("\u2714 commit-check: all checks passed")
+        skipped, total = _skip_count(results), len(results)
+        if total and skipped == total:
+            print("\u2298 commit-check: all checks skipped, nothing was validated")
+        elif skipped:
+            print(f"\u2714 commit-check: all checks passed ({skipped} skipped)")
+        else:
+            print("\u2714 commit-check: all checks passed")
 
 
 def _check_counts(results: list[ScopeResult]) -> tuple[int, int]:
@@ -492,6 +517,15 @@ def _failure_count(results: list[ScopeResult]) -> int:
     return _check_counts(results)[0]
 
 
+def _skip_count(results: list[ScopeResult]) -> int:
+    """Number of scopes that never ran.
+
+    Reported separately from the pass count so the headline cannot claim
+    that checks passed when they were skipped.
+    """
+    return sum(1 for scope in results if scope.status == "skip")
+
+
 def _markdown_table(results: list[ScopeResult]) -> str:
     """Render the failure table shared by summary and PR comment.
 
@@ -589,6 +623,25 @@ def _scope_value(scope: ScopeResult, max_len: int = 60) -> str:
 #
 #   _commit-check 2.13.1 · [Rules reference](https://commit-check.com/rules/)_
 #
+# Skipped (every rule declined to run — e.g. the author is in ignore_authors):
+#
+#   ⊘ **All 5 checks skipped** — nothing was validated
+#
+#   ```text
+#   Commit message
+#     ⊘ PR title (skipped)
+#     ⊘ Commit 1/1 (skipped)
+#   Branch
+#     ⊘ Branch (skipped)
+#   Author
+#     ⊘ Author name (skipped)
+#     ⊘ Author email (skipped)
+#   ```
+#
+# A skipped scope deliberately carries no ✔ and no checked value: nothing was
+# examined, so there is no value to report and no pass to claim. When only some
+# scopes skip, the verdict reads "✅ **3 of 5 checks passed**, 2 skipped".
+#
 # Failure:
 #
 #   <!-- commit-check-action -->
@@ -663,15 +716,26 @@ def render_report(results: list[ScopeResult]) -> str:
     failure table (failures only) and the collapsible per-scope details.
     """
     failed, total = _check_counts(results)
+    skipped = _skip_count(results)
     unit = "check" if total == 1 else "checks"
 
     lines = [COMMENT_MARKER, REPORT_TITLE, ""]
-    if failed == 0:
-        lines.append(f"✅ **All {total} {unit} passed**")
-        lines.append("")
-    else:
+    if failed:
         lines.append(f"❌ **{failed} of {total} {unit} failed**")
         lines.extend(["", _markdown_table(results), ""])
+    elif skipped == total:
+        # Nothing ran, so there is no success to announce. Saying "all
+        # checks passed" here is the defect this branch exists to prevent.
+        lines.append(f"⊘ **All {total} {unit} skipped** — nothing was validated")
+        lines.append("")
+    elif skipped:
+        lines.append(
+            f"✅ **{total - skipped} of {total} {unit} passed**, {skipped} skipped"
+        )
+        lines.append("")
+    else:
+        lines.append(f"✅ **All {total} {unit} passed**")
+        lines.append("")
     lines.extend([_markdown_details(results), "", _report_footer()])
     return "\n".join(lines)
 
 
@@ -1355,3 +1355,81 @@ def test_no_comments_yields_nothing_to_update(self):
         target, stale = main._find_own_comments([])
         self.assertIsNone(target)
         self.assertEqual(stale, [])
+
+
+def skip_scope(label: str = "PR title") -> main.ScopeResult:
+    """A scope whose every rule declined to run (e.g. author in ignore_authors)."""
+    return main.ScopeResult(
+        label=label,
+        checks=[make_check("message", status="skip", rule_id="CC001", value="")],
+    )
+
+
+class TestSkippedScopes(unittest.TestCase):
+    """A skipped scope must never render as a passing one.
+
+    commit-check-action#258 is the case this guards: every rule was skipped
+    because the author is dependabot[bot], and the report announced
+    "All 5 checks passed" over five green ticks.
+    """
+
+    def test_scope_status_is_skip_not_pass(self):
+        self.assertEqual(skip_scope().status, "skip")
+
+    def test_one_real_verdict_outranks_the_skips(self):
+        """A scope only counts as skipped when nothing in it ran."""
+        mixed = main.ScopeResult(
+            label="PR title",
+            checks=[
+                make_check("message", status="skip", value=""),
+                make_check("subject_max_length", status="pass", value="feat: x"),
+            ],
+        )
+        self.assertEqual(mixed.status, "pass")
+
+    @pin_version
+    def test_all_skipped_golden_output(self):
+        """Pin the fully skipped report: no ✔, no pass claim."""
+        results = [skip_scope("PR title"), skip_scope("Commit 1/1")]
+        body = main.render_report(results)
+        self.assertEqual(
+            body,
+            f"{main.COMMENT_MARKER}\n"
+            f"{main.REPORT_TITLE}\n"
+            "\n"
+            "⊘ **All 2 checks skipped** — nothing was validated\n"
+            "\n"
+            "<details>\n"
+            "<summary>Show all 2 checks</summary>\n"
+            "\n"
+            "```text\n"
+            "Commit message\n"
+            "  ⊘ PR title (skipped)\n"
+            "  ⊘ Commit 1/1 (skipped)\n"
+            "```\n"
+            "\n"
+            "</details>\n"
+            "\n"
+            f"{FOOTER}",
+        )
+
+    def test_partial_skip_does_not_claim_all_passed(self):
+        results = [pass_scope("Branch", value="main"), skip_scope("PR title")]
+        body = main.render_report(results)
+        self.assertIn("✅ **1 of 2 checks passed**, 1 skipped", body)
+        self.assertNotIn("All 2 checks passed", body)
+
+    def test_failure_still_wins_over_skips(self):
+        results = [fail_scope("Commit 1/1"), skip_scope("PR title")]
+        body = main.render_report(results)
+        self.assertIn("❌ **1 of 2 checks failed**", body)
+
+    def test_skipped_scope_reports_no_checked_value(self):
+        """The ⊘ line carries no value, because nothing was examined."""
+        body = main.render_report([skip_scope("PR title")])
+        self.assertIn("  ⊘ PR title (skipped)", body)
+
+    def test_older_engine_without_skip_is_unaffected(self):
+        """Back-compat: engines that only emit pass/fail render as before."""
+        results = [pass_scope("Branch", value="main")]
+        self.assertIn("✅ **All 1 check passed**", main.render_report(results))