scip-cli 2.9.0__tar.gz → 2.10.0__tar.gz

{scip_cli-2.9.0 → scip_cli-2.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: scip-cli
-Version: 2.9.0
+Version: 2.10.0
 Summary: Fast code intelligence via SCIP indexes
 Project-URL: Homepage, https://github.com/flesler/scip-cli
 Author: Ariel Flesler
@@ -153,7 +153,7 @@ scip-cli <command> [arguments]
 - `rdeps <file>` - Find files that depend on a file (`--path`)
 - `deps <symbol|file>` - Find outbound dependencies (what a symbol or file calls) (`--path`, `--paths-only`)
 - `members <symbol>` - List members of a class/interface (`--path`)
-- `analyze [target]` - SQL health dashboards (`--limit`, `--priority`, `--check`, `--include-tests`). No target: project-wide; directory or file path; symbol name. See [Finding easy wins with `analyze`](#finding-easy-wins-with-analyze).
+- `analyze [target]` - SQL health dashboards (`--limit`, `--per-check-limit`, `--priority`, `--check`, `--include-tests`). No target: project-wide; directory or file path; symbol name. See [Finding easy wins with `analyze`](#finding-easy-wins-with-analyze).
 - `reindex` - Force re-indexing of the current project (`--path` to limit scope; repeatable)
 - `skill [path]` - Install or dump the SKILL.md
 
@@ -282,16 +282,19 @@ Use `analyze` on the repo itself before broad refactors or agent review — it s
 
 ```bash
 scip-cli analyze --limit 25
+scip-cli analyze --limit 40 --per-check-limit 5   # spread the global budget across checks
 scip-cli analyze --priority high --limit 25   # dead exports & cycles only
 scip-cli analyze --check cycles --limit 25    # one named section
 scip-cli analyze --check dead_files --limit 25
 ```
 
+`--limit` is a **global** finding-row budget (truncation markers do not count). `--per-check-limit` (default unlimited) caps each section. Directory analyze spends that same budget on per-file dumps after dashboards.
+
 Sections are tagged `[high]`, `[medium]`, `[low]` and listed in that order.
 
 |Tier|Project sections|Action|
 |---|---|---|
-|**high**|Cycles, unreferenced, dead exports, dead files, stale types|Nuke or fix cycles; delete unused; `_` prefix|
+|**high**|Cycles, dead exports, dead files, stale types (unreferenced is omitted when dead exports is on)|Nuke or fix cycles; delete unused; `_` prefix|
 |**medium**|Same-file only, change surface (file target)|Module-private by usage|
 |**low**|Test-only consumers, coupling, bottlenecks, hotspots|Noisy on Python (index omits many same-file calls); verify with `rg`|
 
@@ -302,7 +305,7 @@ Use `--priority high` for a quick gate; `--priority high,medium` adds context. F
 |Section|Easy pickings|
 |---|---|
 |**Cycles**|Import/mention cycles between production files — break the edge or extract shared code|
-|**Unreferenced**|No usage in the index at all — delete|
+|**Unreferenced**|Same survivors as dead exports; omitted unless `--check unreferenced`. Empty `rdeps` is usually a SCIP miss — verify with `rg -F STEM` (file basename in `(...)`)|
 |**Dead exports**|No external refs — delete or `_` prefix|
 |**Stale types**|Classes/types with no external consumer in the index — verify in-file or type-only use before removing|
 |**Same-file only**|Used only inside defining file — rename to `_`|

{scip_cli-2.9.0 → scip_cli-2.10.0}/README.md

@@ -132,7 +132,7 @@ scip-cli <command> [arguments]
 - `rdeps <file>` - Find files that depend on a file (`--path`)
 - `deps <symbol|file>` - Find outbound dependencies (what a symbol or file calls) (`--path`, `--paths-only`)
 - `members <symbol>` - List members of a class/interface (`--path`)
-- `analyze [target]` - SQL health dashboards (`--limit`, `--priority`, `--check`, `--include-tests`). No target: project-wide; directory or file path; symbol name. See [Finding easy wins with `analyze`](#finding-easy-wins-with-analyze).
+- `analyze [target]` - SQL health dashboards (`--limit`, `--per-check-limit`, `--priority`, `--check`, `--include-tests`). No target: project-wide; directory or file path; symbol name. See [Finding easy wins with `analyze`](#finding-easy-wins-with-analyze).
 - `reindex` - Force re-indexing of the current project (`--path` to limit scope; repeatable)
 - `skill [path]` - Install or dump the SKILL.md
 
@@ -261,16 +261,19 @@ Use `analyze` on the repo itself before broad refactors or agent review — it s
 
 ```bash
 scip-cli analyze --limit 25
+scip-cli analyze --limit 40 --per-check-limit 5   # spread the global budget across checks
 scip-cli analyze --priority high --limit 25   # dead exports & cycles only
 scip-cli analyze --check cycles --limit 25    # one named section
 scip-cli analyze --check dead_files --limit 25
 ```
 
+`--limit` is a **global** finding-row budget (truncation markers do not count). `--per-check-limit` (default unlimited) caps each section. Directory analyze spends that same budget on per-file dumps after dashboards.
+
 Sections are tagged `[high]`, `[medium]`, `[low]` and listed in that order.
 
 |Tier|Project sections|Action|
 |---|---|---|
-|**high**|Cycles, unreferenced, dead exports, dead files, stale types|Nuke or fix cycles; delete unused; `_` prefix|
+|**high**|Cycles, dead exports, dead files, stale types (unreferenced is omitted when dead exports is on)|Nuke or fix cycles; delete unused; `_` prefix|
 |**medium**|Same-file only, change surface (file target)|Module-private by usage|
 |**low**|Test-only consumers, coupling, bottlenecks, hotspots|Noisy on Python (index omits many same-file calls); verify with `rg`|
 
@@ -281,7 +284,7 @@ Use `--priority high` for a quick gate; `--priority high,medium` adds context. F
 |Section|Easy pickings|
 |---|---|
 |**Cycles**|Import/mention cycles between production files — break the edge or extract shared code|
-|**Unreferenced**|No usage in the index at all — delete|
+|**Unreferenced**|Same survivors as dead exports; omitted unless `--check unreferenced`. Empty `rdeps` is usually a SCIP miss — verify with `rg -F STEM` (file basename in `(...)`)|
 |**Dead exports**|No external refs — delete or `_` prefix|
 |**Stale types**|Classes/types with no external consumer in the index — verify in-file or type-only use before removing|
 |**Same-file only**|Used only inside defining file — rename to `_`|

{scip_cli-2.9.0 → scip_cli-2.10.0}/pyproject.toml

@@ -54,9 +54,10 @@ testpaths = ["tests"]
 python_files = ["test_*.py"]
 python_classes = ["Test*"]
 python_functions = ["test_*"]
-addopts = "-q --tb=line --no-header"
+addopts = "-q --tb=line --no-header -m 'not benchmark'"
 markers = [
     "integration: uses the shared indexed TS fixture (requires npx / scip-typescript)",
+    "benchmark: scaled :memory: query timings (run via scripts/bench.sh only)",
 ]
 
 [tool.basedpyright]

{scip_cli-2.9.0 → scip_cli-2.10.0}/scip_cli/SKILL.md

@@ -64,7 +64,7 @@ Commands emit one record per line on stdout; warnings and progress go to stderr.
 |Goal|Pipeline|
 |---|---|
 |Blast radius of a file|`scip-cli rdeps file.ts \|xargs -I{} scip-cli symbols {}`|
-|Pre-change / health briefing|`scip-cli analyze` or `scip-cli analyze path/to/file.ts` or `scip-cli analyze SymbolName`|
+|Pre-change / health briefing|`scip-cli analyze --limit 40 --per-check-limit 5` (or a file / symbol)|
 |Files that import a symbol|`scip-cli refs Foo --paths-only`|
 |Symbols in referencing files|`scip-cli refs Foo --paths-only \|xargs -I{} scip-cli symbols {}` (barrel files may have no symbols; prefer `search Foo --paths-only` for definition files)|
 |Find classes, list members|`scip-cli search Handler --kind class --names-only \|xargs -I{} scip-cli members {}`|
@@ -133,7 +133,7 @@ Returns `startLine:endLine kind name` for each member. Members are found via SCI
 ### analyze
 
 ```bash
-analyze [--limit N] [--path PATH] [--include-tests] [--priority LEVEL] [--check NAME] [target]
+analyze [--limit N] [--per-check-limit N] [--path PATH] [--include-tests] [--priority LEVEL] [--check NAME] [target]
 ```
 
 |Target|Output|
@@ -143,9 +143,11 @@ analyze [--limit N] [--path PATH] [--include-tests] [--priority LEVEL] [--check
 |**file**|Scoped project dashboards for that file + per-file sections + top symbols by external consumers|
 |**symbol**|Symbol pressure, consumers, dependencies, affected|
 
-Sections are ordered **high → medium → low**. `[high]` cycles, unreferenced, dead exports, dead files, stale types; `[medium]` same-file-only, change surface (file); `[low]` test-only consumers (noisy on Python), coupling, bottlenecks, hotspots.
+Sections are ordered **high → medium → low**. `[high]` cycles, dead exports, dead files, stale types (unreferenced is skipped when dead exports is on — same survivors; file-target unreferenced-in-file is skipped when dead-in-file is on); `[medium]` same-file-only, change surface (file); `[low]` test-only consumers (noisy on Python), coupling, bottlenecks, hotspots.
 
-`--limit` caps **result rows across the whole run** (default 20); remaining checks are skipped once the cap is reached. `(none)` sections and section headers do not count.
+`--limit` caps **result rows across the whole run** (default 20); remaining checks are skipped once the cap is reached. `(none)` sections, headers, and `… truncated` / `[note]` lines do not count as findings. `--per-check-limit N` additionally caps each section (default: unlimited) so one noisy check cannot spend the whole budget. Agents: `analyze --limit 40 --per-check-limit 5`.
+
+Directory `analyze some/dir` spends the **same global `--limit`** on per-file sections after dashboards (max 30 files). Prefer project/dir dashboards, then `analyze` one file.
 
 `--priority high` or `--priority high,medium` (also `1`/`2`/`3`) skips lower tiers.
 
@@ -153,9 +155,7 @@ Sections are ordered **high → medium → low**. `[high]` cycles, unreferenced,
 
 Directory detection uses the filesystem when present, otherwise an indexed path prefix. `--path` narrows ambiguous file/symbol resolution only (not directory scope — pass the dir as `target`).
 
-**Dogfood loop:** `reindex` → `analyze --limit 25` → `analyze scip_cli` or `analyze scip_cli/queries.py` on suspects. Skips test paths in project-wide and directory runs (`tests/`, `*.test.*`, `*.spec.*`); `--include-tests` to include them. File-target analyze always includes that file.
-
-**Easy pickings:** **Cycles**, **dead exports**, and **dead files** (production paths) — cross-file cleanup. **Stale types** — types with no external refs in the index. Ignore `analyze/*` section helpers in dead exports. “Dead” = no refs from _other_ files in the index (empty `rdeps` for files), not `vulture`. Sections with hits print a short false-positive caveat; `export const` arrows often look like dead files because SCIP indexes the module only.
+**Easy pickings:** **Cycles**, **dead exports**, and **dead files** (production paths) — cross-file cleanup. **Stale types** — types with no external refs in the index. Ignore `analyze/*` section helpers in dead exports. “Dead” = no refs from _other_ files in the index, not `vulture`. Empty `scip-cli rdeps` on a hit is usually a SCIP miss (`require()`, named imports, barrels), not proof unused. Unreferenced is omitted when dead exports is on (same survivors). Sections with hits print one `Warn:`; for each row run `rg -F STEM` where STEM is the **file basename inside `(...)`**, no extension — ignore hits in that same file. Do not `rg` the symbol name.
 
 ### reindex
 

{scip_cli-2.9.0 → scip_cli-2.10.0}/scip_cli/__init__.py

@@ -1,3 +1,3 @@
 """scip-cli: Fast code intelligence via SCIP indexes."""
 
-__version__ = "2.9.0"
+__version__ = "2.10.0"

{scip_cli-2.9.0 → scip_cli-2.10.0}/scip_cli/__main__.py

@@ -11,7 +11,13 @@ import sys
 from collections.abc import Callable
 
 from . import __version__
-from .cli_args import add_limit_argument, add_names_only_argument, add_path_argument, add_paths_only_argument
+from .cli_args import (
+    add_limit_argument,
+    add_names_only_argument,
+    add_path_argument,
+    add_paths_only_argument,
+    positive_int,
+)
 from .commands import analyze, code, deps, members, rdeps, refs, reindex, search, skill, symbols
 from .symbols import SymbolKind
 
@@ -131,6 +137,13 @@ def main() -> None:
     )
     add_path_argument(analyze_parser)
     add_limit_argument(analyze_parser, default=20, help_suffix="result rows total")
+    analyze_parser.add_argument(
+        "--per-check-limit",
+        type=positive_int(),
+        default=None,
+        metavar="N",
+        help="Max rows per check (default: unlimited). --limit remains the global row budget",
+    )
     analyze_parser.add_argument(
         "--include-tests",
         action="store_true",

scip_cli-2.10.0/scip_cli/analyze/common.py

@@ -0,0 +1,243 @@
+"""Shared SQL helpers and formatting for analyze checks."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable, Iterable
+
+from ..sql import debug_execute
+from ..symbols import extract_leaf_name, is_module_symbol
+
+DEFAULT_LIMIT = 20
+# Cap rows scanned when post-filtering SQL (filters drop many SCIP false hits).
+ANALYZE_MAX_SCAN_ROWS = 10_000
+
+
+def collect_until_limit(
+    limit: int,
+    fetch_page: Callable[[int, int], list[object]],
+    accept: Callable[[object], str | None],
+    *,
+    page_size: int | None = None,
+    max_scan: int = ANALYZE_MAX_SCAN_ROWS,
+) -> list[str]:
+    """Fetch SQL pages until `limit` rows pass `accept`, or data is exhausted.
+
+    Use only when a check post-filters SQL rows (analyze_noise, live heuristics, …).
+    Checks that format every SQL row as-is should use a single ``LIMIT ?`` instead.
+    """
+    batch = page_size or max(limit, 50)
+    lines: list[str] = []
+    offset = 0
+    scanned = 0
+    while len(lines) < limit:
+        rows = fetch_page(batch, offset)
+        if not rows:
+            break
+        for row in rows:
+            scanned += 1
+            if scanned > max_scan:
+                return lines
+            line = accept(row)
+            if line is None:
+                continue
+            lines.append(line)
+            if len(lines) >= limit:
+                return lines
+        if len(rows) < batch:
+            break
+        offset += len(rows)
+    return lines
+
+
+def collect_from_producer(
+    limit: int,
+    produce: Callable[[int], list[str]],
+    accept: Callable[[str], str | None],
+    *,
+    max_scan: int = ANALYZE_MAX_SCAN_ROWS,
+) -> list[str]:
+    """Fill ``limit`` rows from a capped producer that can return more candidates on retry.
+
+    Used when results are not SQL-paginated (e.g. graph cycle search). ``produce(cap)``
+    must return a deterministic prefix as ``cap`` grows; already-seen strings are skipped.
+    """
+    lines: list[str] = []
+    seen: set[str] = set()
+    scanned = 0
+    fetch_cap = limit
+    while len(lines) < limit and fetch_cap <= max_scan:
+        candidates = produce(fetch_cap)
+        if not candidates:
+            break
+        for candidate in candidates:
+            if candidate in seen:
+                continue
+            seen.add(candidate)
+            scanned += 1
+            if scanned > max_scan:
+                return lines
+            line = accept(candidate)
+            if line is None:
+                continue
+            lines.append(line)
+            if len(lines) >= limit:
+                return lines
+        if len(candidates) < fetch_cap:
+            break
+        fetch_cap += limit
+    return lines
+
+
+def collect_from_iterable(
+    limit: int,
+    candidates: Iterable[str],
+    accept: Callable[[str], str | None],
+    *,
+    max_scan: int = ANALYZE_MAX_SCAN_ROWS,
+) -> list[str]:
+    """Filter an in-memory candidate list until ``limit`` rows pass ``accept``."""
+    lines: list[str] = []
+    scanned = 0
+    for candidate in candidates:
+        scanned += 1
+        if scanned > max_scan:
+            break
+        line = accept(candidate)
+        if line is None:
+            continue
+        lines.append(line)
+        if len(lines) >= limit:
+            break
+    return lines
+
+
+# Definition document for a symbol (our trimmed schema uses defn_enclosing_ranges).
+SYM_DEF_JOIN = """
+    JOIN defn_enclosing_ranges sym_def ON sym_def.symbol_id = gs.id
+    JOIN documents def_d ON sym_def.document_id = def_d.id
+"""
+
+
+def fetch_all(db, sql: str, params=()):
+    return debug_execute(db, sql, params).fetchall()
+
+
+def fetch_one(db, sql: str, params=()):
+    return debug_execute(db, sql, params).fetchone()
+
+
+def short_name(symbol: str) -> str:
+    if is_module_symbol(symbol):
+        return "(module)"
+    leaf = extract_leaf_name(symbol)
+    if leaf:
+        return leaf
+    if symbol.endswith("/"):
+        return "(module)"
+    return symbol.split("/")[-1][:60]
+
+
+def is_test_path(relative_path: str) -> bool:
+    """True for common test layout paths and test-like filenames."""
+    p = relative_path.replace("\\", "/")
+    lower = p.lower()
+    if lower.startswith(("tests/", "test/")):
+        return True
+    if "/tests/" in lower or "/test/" in lower or "/__tests__/" in lower:
+        return True
+    if "/__fixtures__/" in lower or "/__mocks__/" in lower:
+        return True
+    name = lower.rsplit("/", 1)[-1]
+    if ".test." in name or ".spec." in name or ".mocha." in name:
+        return True
+    stem = name.rsplit(".", 1)[0]
+    if stem.endswith("_test") or stem.endswith("_spec"):
+        return True
+    if "test-fixture" in name or "test_fixture" in name or "test-mocks" in name:
+        return True
+    if name.startswith("test_") and name.endswith(".py"):
+        return True
+    return name == "conftest.py"
+
+
+def is_dynamic_loader_path(relative_path: str) -> bool:
+    """True for migration files typically loaded by filename; SCIP has no import edge."""
+    p = relative_path.replace("\\", "/").lower()
+    return "/migrations/" in p
+
+
+def is_python_main_entrypoint(relative_path: str, symbol: str) -> bool:
+    """True for main() in __main__.py — argparse entrypoints SCIP does not link to callers."""
+    if short_name(symbol) != "main":
+        return False
+    return relative_path.replace("\\", "/").endswith("__main__.py")
+
+
+def analyze_noise(relative_path: str, symbol: str, *, include_tests: bool = False) -> bool:
+    """True for rows that clutter analyze dashboards (test paths, module-private helpers)."""
+    if not include_tests and is_test_path(relative_path):
+        return True
+    if short_name(symbol).startswith("_"):
+        return True
+    if is_python_main_entrypoint(relative_path, symbol):
+        return True
+    if is_dynamic_loader_path(relative_path):
+        return True
+    if short_name(symbol) in {"<constructor>", "constructor"}:
+        return True
+    return is_analyze_dashboard_export(relative_path, symbol)
+
+
+_ANALYZE_DASHBOARD_SUFFIXES = (
+    "analyze/project.py",
+    "analyze/file.py",
+    "analyze/symbol.py",
+)
+
+
+def is_analyze_dashboard_export(relative_path: str, symbol: str) -> bool:
+    """Section runner functions in analyze/* (same-file only, look like dead exports)."""
+    path = relative_path.replace("\\", "/")
+    if not any(path.endswith(suffix) for suffix in _ANALYZE_DASHBOARD_SUFFIXES):
+        return False
+    name = short_name(symbol)
+    return "()." in symbol or name.endswith(")")
+
+
+def is_component_props_type(symbol: str) -> bool:
+    """React-style Props interfaces — rarely referenced outside the component file."""
+    name = short_name(symbol)
+    return bool(name and name.endswith("Props") and "#" in symbol.split("/")[-1])
+
+
+def stale_type_noise(relative_path: str, symbol: str, consumers: int) -> bool:
+    """Dataclass-style types with no SCIP consumers (typing-only)."""
+    if is_component_props_type(symbol):
+        return True
+    if consumers > 0:
+        return False
+    name = short_name(symbol)
+    if not name or name == "(module)" or not name[0].isupper():
+        return False
+    path = relative_path.replace("\\", "/")
+    return path.endswith(("config.py", "scope.py", "analyze/targets.py"))
+
+
+def file_pair_noise(file1: str, file2: str, *, include_tests: bool = False) -> bool:
+    if include_tests:
+        return False
+    return is_test_path(file1) or is_test_path(file2)
+
+
+def cycle_path_noise(cycle_line: str, *, include_tests: bool = False) -> bool:
+    if include_tests:
+        return False
+    parts = re.split(r"\s<->\s|\s->\s", cycle_line)
+    return any(is_test_path(part.strip()) for part in parts if part.strip())
+
+
+def section(title: str, lines: list[str], *, preface: str | None = None) -> tuple[str, list[str], str | None]:
+    if not lines:
+        return title, ["(none)"], None
+    return title, lines, preface

{scip_cli-2.9.0 → scip_cli-2.10.0}/scip_cli/analyze/file.py

@@ -2,8 +2,8 @@
 
 from __future__ import annotations
 
-from .common import DEFAULT_LIMIT, SYM_DEF_JOIN, analyze_noise, fetch_all, short_name
-from .live import LiveIndex, file_has_scip_importers, has_same_file_reference_usage
+from .common import DEFAULT_LIMIT, SYM_DEF_JOIN, analyze_noise, collect_until_limit, fetch_all, short_name
+from .live import file_has_scip_importers, has_same_file_reference_usage, live_for
 from .sections import FALSE_POSITIVE_PREFACES, Check, Priority, run_checks
 from .symbol import symbol_pressure
 
@@ -83,10 +83,8 @@ def file_consumers(db, relative_path: str, limit: int = DEFAULT_LIMIT) -> list[s
 
 
 def unreferenced_in_file(db, relative_path: str, limit: int = DEFAULT_LIMIT) -> list[str]:
-    live = LiveIndex(db)
-    rows = fetch_all(
-        db,
-        """
+    live = live_for(db)
+    sql = """
         SELECT gs.symbol, der.start_line, der.end_line, def_d.id
         FROM global_symbols gs
         JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
@@ -102,25 +100,25 @@ def unreferenced_in_file(db, relative_path: str, limit: int = DEFAULT_LIMIT) ->
               WHERE m.symbol_id = gs.id AND m.role != 1 AND c.document_id != def_d.id
           )
         ORDER BY der.start_line
-        LIMIT ?
-        """,
-        (relative_path, limit),
-    )
-    lines = []
-    for symbol, start, end, def_doc_id in rows:
+    """
+
+    def fetch_page(page_size: int, offset: int):
+        return fetch_all(db, sql + " LIMIT ? OFFSET ?", (relative_path, page_size, offset))
+
+    def accept(row):
+        symbol, start, end, def_doc_id = row
         if analyze_noise(relative_path, symbol, include_tests=True):
-            continue
+            return None
         if live.dead_export_noise(symbol, def_doc_id):
-            continue
-        lines.append(f"{short_name(symbol)}  {start + 1}:{end + 1}")
-    return lines
+            return None
+        return f"{short_name(symbol)}  {start + 1}:{end + 1}"
+
+    return collect_until_limit(limit, fetch_page, accept)
 
 
 def same_file_only_in_file(db, relative_path: str, limit: int = DEFAULT_LIMIT) -> list[str]:
-    live = LiveIndex(db)
-    rows = fetch_all(
-        db,
-        """
+    live = live_for(db)
+    sql = """
         SELECT gs.symbol, der.start_line, der.end_line, def_d.id
         FROM global_symbols gs
         JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
@@ -137,27 +135,27 @@ def same_file_only_in_file(db, relative_path: str, limit: int = DEFAULT_LIMIT) -
               WHERE m.symbol_id = gs.id AND m.role = 0 AND c.document_id != def_d.id
           )
         ORDER BY der.start_line
-        LIMIT ?
-        """,
-        (relative_path, limit),
-    )
-    lines = []
-    for symbol, start, end, def_doc_id in rows:
+    """
+
+    def fetch_page(page_size: int, offset: int):
+        return fetch_all(db, sql + " LIMIT ? OFFSET ?", (relative_path, page_size, offset))
+
+    def accept(row):
+        symbol, start, end, def_doc_id = row
         if analyze_noise(relative_path, symbol, include_tests=True):
-            continue
+            return None
         if live.same_file_export_noise(symbol, def_doc_id):
-            continue
+            return None
         if not file_has_scip_importers(db, relative_path, live=live, def_doc_id=def_doc_id):
-            continue
-        lines.append(f"{short_name(symbol)}  {start + 1}:{end + 1}")
-    return lines
+            return None
+        return f"{short_name(symbol)}  {start + 1}:{end + 1}"
+
+    return collect_until_limit(limit, fetch_page, accept)
 
 
 def dead_in_file(db, relative_path: str, limit: int = DEFAULT_LIMIT) -> list[str]:
-    live = LiveIndex(db)
-    rows = fetch_all(
-        db,
-        """
+    live = live_for(db)
+    sql = """
         SELECT gs.id, gs.symbol, der.start_line, der.end_line, def_d.id
         FROM global_symbols gs
         JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
@@ -172,20 +170,22 @@ def dead_in_file(db, relative_path: str, limit: int = DEFAULT_LIMIT) -> list[str
                 AND c.document_id != def_d.id
           )
         ORDER BY der.start_line
-        LIMIT ?
-        """,
-        (relative_path, limit),
-    )
-    lines = []
-    for sym_id, symbol, start, end, def_doc_id in rows:
+    """
+
+    def fetch_page(page_size: int, offset: int):
+        return fetch_all(db, sql + " LIMIT ? OFFSET ?", (relative_path, page_size, offset))
+
+    def accept(row):
+        sym_id, symbol, start, end, def_doc_id = row
         if analyze_noise(relative_path, symbol, include_tests=True):
-            continue
+            return None
         if has_same_file_reference_usage(db, sym_id, def_doc_id):
-            continue
+            return None
         if live.dead_export_noise(symbol, def_doc_id):
-            continue
-        lines.append(f"{short_name(symbol)}  {start + 1}:{end + 1}")
-    return lines
+            return None
+        return f"{short_name(symbol)}  {start + 1}:{end + 1}"
+
+    return collect_until_limit(limit, fetch_page, accept)
 
 
 def imports_summary(db, relative_path: str, limit: int = DEFAULT_LIMIT) -> list[str]:
@@ -342,8 +342,11 @@ def _run_file_checks(
     *,
     budget=None,
     check_keys=None,
+    per_check_limit=None,
 ) -> list[tuple[str, list[str], str | None]]:
-    return run_checks(checks, db, limit, priorities, budget=budget, check_keys=check_keys)
+    return run_checks(
+        checks, db, limit, priorities, budget=budget, check_keys=check_keys, per_check_limit=per_check_limit
+    )
 
 
 def run_all(
@@ -353,6 +356,7 @@ def run_all(
     priorities=None,
     budget=None,
     check_keys=None,
+    per_check_limit=None,
 ) -> list[tuple[str, list[str], str | None]]:
     return _run_file_checks(
         _file_checks(relative_path, include_top_symbols=True),
@@ -361,6 +365,7 @@ def run_all(
         priorities,
         budget=budget,
         check_keys=check_keys,
+        per_check_limit=per_check_limit,
     )
 
 
@@ -371,6 +376,7 @@ def run_all_sections_only(
     priorities=None,
     budget=None,
     check_keys=None,
+    per_check_limit=None,
 ) -> list[tuple[str, list[str], str | None]]:
     """Per-file sections without top-symbols (directory batch)."""
     return _run_file_checks(
@@ -380,4 +386,5 @@ def run_all_sections_only(
         priorities,
         budget=budget,
         check_keys=check_keys,
+        per_check_limit=per_check_limit,
     )