sciwrite-lint 0.4.0__tar.gz → 0.5.0__tar.gz

{sciwrite_lint-0.4.0/sciwrite_lint.egg-info → sciwrite_lint-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sciwrite-lint
-Version: 0.4.0
+Version: 0.5.0
 Summary: A linter for scientific manuscripts — reference verification, consistency checking, and structural validation.
 Author: Sergey Samsonau
 Maintainer-email: Authentic Research Partners LLC <info@arpconnect.com>
@@ -147,7 +147,7 @@ sciwrite-lint contributions paper.pdf --format json
 
 ### Optimizations
 
-Three models — a vision model (Qwen3-VL-2B default, or 8B FP8 via `--vision-backend vllm` for +15% accuracy), an embedding model (Arctic Embed), and an 8B reasoning LLM (Qwen3 via vLLM) — share a single consumer GPU. The pipeline runs each in its own stage and explicitly stops one before starting the next, so only one ever owns GPU memory at a time (same code path on WSL2 and native Linux). FP8 weights and KV cache (Ada Lovelace+) and per-paper SQLite caching with hash-based invalidation are baseline. On top of that:
+Three models — a vision model (Qwen3-VL-2B default, or 8B FP8 via `--vision-backend vllm` for +15% accuracy), an embedding model (Arctic Embed), and an 8B reasoning LLM (Qwen3 via vLLM) — share a single consumer GPU. The pipeline runs each in its own stage and explicitly stops one before starting the next, so only one ever owns GPU memory at a time (same code path on WSL2 and native Linux). FP8 weights and KV cache (Ada Lovelace+) and per-paper SQLite caching are baseline; every cache layer pins its inputs by hash so editing the paper, replacing a figure, or refreshing a reference recomputes only what's affected (see the *Iterative editing* subsection under Usage — `--fresh` is not part of the normal loop). On top of that:
 
 - **Cost-aware verify-claim ladder** — sentence chunk → paragraph chunk → whole section. Each level fans out top-N candidates in parallel; stops on a conclusive verdict. Most claims resolve at the cheap sentence level (~200-token prompts) instead of paying for whole sections (~5K tokens), with full-section escalation reserved for hard cases
 - **Prefix-first prompt structure** — shared context placed before variable content in all prompts, maximizing vLLM's automatic prefix caching
@@ -282,7 +282,18 @@ sciwrite-lint contributions paper.pdf           # standalone file scoring
 
 `check` runs the full pipeline in one command: text checks → figure analysis → LLM consistency → reference verification via APIs → download and parse cited papers → claim verification → consistency checks on cited papers → bibliography verification → aggregate reliability scores → SciLint Score. An initial run on a 50-reference paper takes up to 30 minutes (dominated by downloads and claim verification); subsequent cached runs complete in minutes.
 
-Use `--fresh` to start from scratch (backs up the existing workspace before recreating it).
+### Iterative editing — no `--fresh` needed
+
+`sciwrite-lint check` invalidates cached results whenever the inputs they were derived from change, so rerunning after an edit just works. Concretely:
+
+- **Edit a sentence or paragraph** → the manuscript-LLM checks (prose-quality, cross-section consistency, etc.) re-run only on the touched sentences and their paragraph siblings; untouched prose stays cached
+- **Edit a paragraph around a citation** → the claim verifier reruns on the edited prose
+- **Replace a figure** (overwrite the PNG/PDF in your tree) → the vision cache re-describes it
+- **Swap the local LLM model** (e.g. `qwen3` ↔ `gemma3` via `--model`) → manuscript-check rows and claim verdicts no longer count as cache hits
+- **Overwrite a reference PDF** in your drop folder, or **re-fetch** an open-access PDF that has new bytes → the parser, embeddings, and claim verifier all rerun against the new content
+- **Upgrade a summary `.md` to a real PDF** in your drop folder → claims are re-verified against the richer evidence
+
+Use `--fresh` only when you want to wipe the workspace deliberately (it backs up the existing workspace before recreating it). It is not the answer to "I edited the paper and a finding looks stale" — if you ever see that, file an issue; a cache invariant is wrong and we'll fix it.
 
 Use `--checks ID[,ID...]` to run only the listed checks (comma-separated), disabling the rest for this invocation. Useful for fast iteration during editing (`--checks prose-quality` runs just the prose review), for debugging a single check, or for scripting a two-pass workflow. Unknown check IDs fail loudly — run `sciwrite-lint checks` to list available IDs.
 

{sciwrite_lint-0.4.0 → sciwrite_lint-0.5.0}/README.md

@@ -81,7 +81,7 @@ sciwrite-lint contributions paper.pdf --format json
 
 ### Optimizations
 
-Three models — a vision model (Qwen3-VL-2B default, or 8B FP8 via `--vision-backend vllm` for +15% accuracy), an embedding model (Arctic Embed), and an 8B reasoning LLM (Qwen3 via vLLM) — share a single consumer GPU. The pipeline runs each in its own stage and explicitly stops one before starting the next, so only one ever owns GPU memory at a time (same code path on WSL2 and native Linux). FP8 weights and KV cache (Ada Lovelace+) and per-paper SQLite caching with hash-based invalidation are baseline. On top of that:
+Three models — a vision model (Qwen3-VL-2B default, or 8B FP8 via `--vision-backend vllm` for +15% accuracy), an embedding model (Arctic Embed), and an 8B reasoning LLM (Qwen3 via vLLM) — share a single consumer GPU. The pipeline runs each in its own stage and explicitly stops one before starting the next, so only one ever owns GPU memory at a time (same code path on WSL2 and native Linux). FP8 weights and KV cache (Ada Lovelace+) and per-paper SQLite caching are baseline; every cache layer pins its inputs by hash so editing the paper, replacing a figure, or refreshing a reference recomputes only what's affected (see the *Iterative editing* subsection under Usage — `--fresh` is not part of the normal loop). On top of that:
 
 - **Cost-aware verify-claim ladder** — sentence chunk → paragraph chunk → whole section. Each level fans out top-N candidates in parallel; stops on a conclusive verdict. Most claims resolve at the cheap sentence level (~200-token prompts) instead of paying for whole sections (~5K tokens), with full-section escalation reserved for hard cases
 - **Prefix-first prompt structure** — shared context placed before variable content in all prompts, maximizing vLLM's automatic prefix caching
@@ -216,7 +216,18 @@ sciwrite-lint contributions paper.pdf           # standalone file scoring
 
 `check` runs the full pipeline in one command: text checks → figure analysis → LLM consistency → reference verification via APIs → download and parse cited papers → claim verification → consistency checks on cited papers → bibliography verification → aggregate reliability scores → SciLint Score. An initial run on a 50-reference paper takes up to 30 minutes (dominated by downloads and claim verification); subsequent cached runs complete in minutes.
 
-Use `--fresh` to start from scratch (backs up the existing workspace before recreating it).
+### Iterative editing — no `--fresh` needed
+
+`sciwrite-lint check` invalidates cached results whenever the inputs they were derived from change, so rerunning after an edit just works. Concretely:
+
+- **Edit a sentence or paragraph** → the manuscript-LLM checks (prose-quality, cross-section consistency, etc.) re-run only on the touched sentences and their paragraph siblings; untouched prose stays cached
+- **Edit a paragraph around a citation** → the claim verifier reruns on the edited prose
+- **Replace a figure** (overwrite the PNG/PDF in your tree) → the vision cache re-describes it
+- **Swap the local LLM model** (e.g. `qwen3` ↔ `gemma3` via `--model`) → manuscript-check rows and claim verdicts no longer count as cache hits
+- **Overwrite a reference PDF** in your drop folder, or **re-fetch** an open-access PDF that has new bytes → the parser, embeddings, and claim verifier all rerun against the new content
+- **Upgrade a summary `.md` to a real PDF** in your drop folder → claims are re-verified against the richer evidence
+
+Use `--fresh` only when you want to wipe the workspace deliberately (it backs up the existing workspace before recreating it). It is not the answer to "I edited the paper and a finding looks stale" — if you ever see that, file an issue; a cache invariant is wrong and we'll fix it.
 
 Use `--checks ID[,ID...]` to run only the listed checks (comma-separated), disabling the rest for this invocation. Useful for fast iteration during editing (`--checks prose-quality` runs just the prose review), for debugging a single check, or for scripting a two-pass workflow. Unknown check IDs fail loudly — run `sciwrite-lint checks` to list available IDs.
 

{sciwrite_lint-0.4.0 → sciwrite_lint-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sciwrite-lint"
-version = "0.4.0"
+version = "0.5.0"
 description = "A linter for scientific manuscripts — reference verification, consistency checking, and structural validation."
 requires-python = ">=3.13,<3.14"
 license = "MIT"
@@ -86,3 +86,5 @@ sciwrite-lint = "sciwrite_lint.__main__:main"
 [tool.setuptools.packages.find]
 include = ["sciwrite_lint*"]
 
+[tool.setuptools.package-data]
+

{sciwrite_lint-0.4.0 → sciwrite_lint-0.5.0}/sciwrite_lint/__init__.py

@@ -2,7 +2,7 @@
 
 from sciwrite_lint.exceptions import LLMConnectionError, SciWriteLintError
 
-__version__ = "0.4.0"
+__version__ = "0.5.0"
 
 from sciwrite_lint.oa import (
     DownloadResult,

{sciwrite_lint-0.4.0 → sciwrite_lint-0.5.0}/sciwrite_lint/__main__.py

@@ -14,8 +14,6 @@ import argparse
 import sys
 from pathlib import Path
 
-from loguru import logger
-
 from sciwrite_lint import __version__
 from sciwrite_lint.cli._common import (
     _classify_verify_issue as _classify_verify_issue,
@@ -42,6 +40,31 @@ _REPLACE_HELP = (
 # ---------------------------------------------------------------------------
 
 
+def _register_optional_extensions(
+    sub: argparse._SubParsersAction,  # type: ignore[type-arg]
+) -> None:
+    """Load CLI extensions discovered under ``sciwrite_lint``.
+
+    An underscore-prefixed subpackage is a CLI extension when its
+    ``__init__.py`` defines ``register_cli(sub)``. Discovery walks
+    ``sciwrite_lint.__path__`` via ``pkgutil``, so no extension package
+    names appear in this source — adding or removing one is a filesystem
+    change.
+    """
+    import importlib
+    import pkgutil
+
+    import sciwrite_lint as _pkg
+
+    for _finder, name, ispkg in pkgutil.iter_modules(_pkg.__path__):
+        if not ispkg or not name.startswith("_"):
+            continue
+        ext = importlib.import_module(f"{_pkg.__name__}.{name}")
+        register = getattr(ext, "register_cli", None)
+        if register is not None:
+            register(sub)
+
+
 def main(argv: list[str] | None = None) -> int:
     from sciwrite_lint.cli.check import run_check, run_checks_list
     from sciwrite_lint.cli.config import run_config
@@ -125,47 +148,8 @@ def main(argv: list[str] | None = None) -> int:
     p_checks = sub.add_parser("checks", help="List all registered checks")
     p_checks.set_defaults(func=run_checks_list)
 
-    # --- aicode-lint (optional — only registered when the WIP module is installed) ---
-    # ``sciwrite_lint.aicode_lint`` is excluded from the public release rsync
-    # while it stabilizes. Use ``importlib.util.find_spec`` to check whether
-    # the module is present rather than try/except ImportError (separately
-    # banned). Public installs (pip from PyPI) won't have it; dev installs
-    # do. Check the parent ``sciwrite_lint.aicode_lint`` first because
-    # ``find_spec`` raises ``ModuleNotFoundError`` on a missing intermediate
-    # path; once the parent is confirmed present, the child lookup is safe.
-    import importlib.util as _importlib_util
-
-    if _importlib_util.find_spec("sciwrite_lint.aicode_lint") is not None:
-        from sciwrite_lint.aicode_lint.cli import run_aicode_lint
-
-        p_aicode = sub.add_parser(
-            "aicode-lint",
-            help="LLM code review on Python sources via local vLLM (semantic antipatterns)",
-        )
-        p_aicode.add_argument(
-            "paths",
-            nargs="*",
-            help="Files, directories, or globs to scan (default: sciwrite_lint/**/*.py)",
-        )
-        p_aicode.add_argument(
-            "--rules",
-            default=None,
-            metavar="ID[,ID...]",
-            help="Run only the listed rule IDs (comma-separated). Default: all built-in rules.",
-        )
-        p_aicode.add_argument(
-            "--list-rules",
-            action="store_true",
-            help="Print the rule registry and exit.",
-        )
-        p_aicode.add_argument(
-            "--format",
-            choices=["terminal", "json"],
-            default=None,
-            help="Output format (default: terminal).",
-        )
-        p_aicode.add_argument("--config", help="Path to .sciwrite-lint.toml")
-        p_aicode.set_defaults(func=run_aicode_lint)
+    # Load optional underscore-prefixed CLI extension subpackages (if any).
+    _register_optional_extensions(sub)
 
     # --- init ---
     p_init = sub.add_parser(
@@ -270,12 +254,6 @@ def main(argv: list[str] | None = None) -> int:
     # --- verify-claims ---
     p_vc = sub.add_parser("verify-claims", help="Verify claims against cited sources")
     p_vc.add_argument("--paper", required=True, help="Paper to verify")
-    p_vc.add_argument(
-        "--backend",
-        choices=["vllm", "claude"],
-        default="vllm",
-        help="vllm (local LLM, fast) or claude (Claude CLI, deep)",
-    )
     p_vc.add_argument(
         "--model",
         choices=_TEXT_MODELS,
@@ -499,14 +477,32 @@ def main(argv: list[str] | None = None) -> int:
         p_vllm.print_help()
         return 0
 
-    # Set up file logging from config (stderr sink stays at INFO by default)
-    try:
-        config = load_config(
-            Path(args.config) if getattr(args, "config", None) else None
-        )
-    except Exception as e:
-        logger.debug("Config load failed, using defaults: {}", e)
+    # Set up file logging from config (stderr sink stays at INFO by default).
+    # ``load_config`` already returns ``LintConfig()`` when no config file is
+    # discovered; reaching the exception path means a file WAS found (or
+    # explicitly passed via --config) but failed to parse or validate.
+    # Surface that instead of silently substituting hardcoded defaults — a
+    # broken TOML otherwise produces results computed against the wrong
+    # workspace, paper list, or API keys.
+    #
+    # The ``init`` command is the one exception: its job is to scaffold a
+    # config, so it must run against a missing, broken, or sentinel TOML
+    # without aborting. Use ``LintConfig()`` for logging setup only and let
+    # init proceed to (over)write the file.
+    if args.command == "init":
         config = LintConfig()
+    else:
+        try:
+            config = load_config(
+                Path(args.config) if getattr(args, "config", None) else None
+            )
+        except Exception as e:
+            cfg_arg = getattr(args, "config", None)
+            cfg_hint = f" ({cfg_arg})" if cfg_arg else " (.sciwrite-lint.toml)"
+            raise SystemExit(
+                f"ERROR: failed to load configuration{cfg_hint}: {type(e).__name__}: {e}\n"
+                "  Fix the TOML or remove the file to use built-in defaults."
+            ) from e
     _setup_logging(config)
 
     return args.func(args)

{sciwrite_lint-0.4.0 → sciwrite_lint-0.5.0}/sciwrite_lint/cli/misc/parse.py

@@ -84,7 +84,7 @@ def run_parse(args: argparse.Namespace) -> int:
                         n = compute_and_store_embeddings(key, text, refs_dir)
                         print(f"    {key}: {n} chunks")
                     except Exception as e:
-                        print(f"    {key}: error — {e}")
+                        logger.warning("parse: embedding failed for {}: {}", key, e)
 
     print(f"\n  Summary: {cached} cached, {parsed} parsed, {failed} failed")
     if failed:

{sciwrite_lint-0.4.0 → sciwrite_lint-0.5.0}/sciwrite_lint/cli/verify.py

@@ -335,6 +335,7 @@ def run_ref_health(args: argparse.Namespace) -> int:
     academic_unmatched: list[Path] = []
     web_matched: dict[str, Path] = {}
     web_unmatched: list[Path] = []
+    local_match_error: str | None = None
     try:
         if tex_file:
             from sciwrite_lint.config import load_config as _load_cfg
@@ -356,8 +357,13 @@ def run_ref_health(args: argparse.Namespace) -> int:
             _cfg.local_web_dir, titles, WEB_SUFFIXES
         )
     except Exception as e:
-        logger.debug(
-            f"ref-health: local source matching skipped ({type(e).__name__}: {e})"
+        # Record the failure so the report renders a visible notice instead
+        # of silently producing a ref-health output with the local-source
+        # section missing. Log at WARNING (not DEBUG) so the operator sees
+        # it even when running with the default log level.
+        local_match_error = f"{type(e).__name__}: {e}"
+        logger.warning(
+            "ref-health: local source matching skipped ({})", local_match_error
         )
 
     # --- Output ---
@@ -398,7 +404,9 @@ def run_ref_health(args: argparse.Namespace) -> int:
     if web_count:
         print(f"    ({web_count} web resources)")
 
-    # Local sources — academic (PDFs + MD summaries) + web (MD + MHTML)
+    # Local sources — academic (PDFs + MD summaries) + web (MD + MHTML).
+    # Matching failures are surfaced via logger.warning (above) so they
+    # appear in the operator's terminal regardless of report formatting.
     if academic_matched or academic_unmatched:
         print("\n  LOCAL ACADEMIC SOURCES")
         if academic_matched:
@@ -425,7 +433,7 @@ def run_ref_health(args: argparse.Namespace) -> int:
 
 
 def run_verify_claims(args: argparse.Namespace) -> int:
-    """Verify claims against cited sources using local LLM or Claude Opus."""
+    """Verify claims against cited sources using local vLLM."""
     from sciwrite_lint.cli._common import _load_config, _resolve_paper
 
     config = _load_config(args)
@@ -446,7 +454,6 @@ def run_verify_claims(args: argparse.Namespace) -> int:
             refs_dir,
             config=config,
             bib_path=pc.bib,
-            backend=args.backend,
             model=args.model,
             key_filter=args.key,
             limit=args.limit,

{sciwrite_lint-0.4.0 → sciwrite_lint-0.5.0}/sciwrite_lint/eval_claims.py

@@ -5,8 +5,8 @@ cited source (PDF via GROBID or .md), splits into sections, and checks
 each section in parallel against the claim using a local LLM via vLLM.
 
 Only works for T1 citations (full text available). Skips T2/T3.
-Uses only local vLLM — no cloud services. For the Claude Opus backend
-(deep analysis, expensive), see sciwrite_lint.evals.eval_claims_opus.
+Uses only local vLLM — no cloud services. Manuscript text never leaves
+the local machine.
 """
 
 from __future__ import annotations
@@ -1421,16 +1421,16 @@ async def run_claim_verification(
     config: LintConfig | None = None,
     bib_format: str = "auto",
     bib_path: Path | None = None,
-    backend: str = "vllm",
     model: str = "",
     key_filter: str | None = None,
     limit: int | None = None,
     rerun: bool = False,
 ) -> list[dict]:
-    """Run claim verification for a paper.
-
-    backend: "vllm" (local LLM, default) or "claude" (Claude CLI, deep).
-    """
+    """Run claim verification for a paper against the local vLLM backend."""
+    # ``backend`` is fixed to "vllm". The column is preserved on
+    # ``claim_results`` to correctly invalidate any pre-0.5.0 rows that
+    # stored a different value.
+    backend = "vllm"
     from sciwrite_lint.references.citations import check_local_sources, extract_bibitems
     from sciwrite_lint.references.metadata import load_all_metadata
 
@@ -1449,7 +1449,7 @@ async def run_claim_verification(
         # Standalone PDF (no prior build_pdf_context call)
         from sciwrite_lint.pipeline import build_pdf_context, citations_from_pdf_context
 
-        asyncio.run(build_pdf_context(tex_path, config))
+        await build_pdf_context(tex_path, config)
         citations = citations_from_pdf_context(config)
     else:
         citations = extract_bibitems(tex_path, bib_format, bib_path=bib_path)
@@ -1532,42 +1532,52 @@ async def run_claim_verification(
     # contexts from workspace.db. The standalone path has no findings
     # list to populate, so any build-warning Finding is logged and
     # dropped — pipeline runs route it to system_issues correctly.
-    if backend != "claude":
-        from sciwrite_lint.pipeline import (
-            ensure_claim_query_vectors,
-            persist_manuscript_citations,
-        )
+    from sciwrite_lint.pipeline import (
+        ensure_claim_query_vectors,
+        persist_manuscript_citations,
+    )
 
-        _, build_finding = persist_manuscript_citations(
-            config, references_dir, tex_path=tex_path
+    _, build_finding = persist_manuscript_citations(
+        config, references_dir, tex_path=tex_path
+    )
+    if build_finding is not None:
+        logger.warning(
+            "Manuscript-context build warning surfaced (standalone "
+            "verify-claims; not surfaced as system issue): {}",
+            build_finding.context,
         )
-        if build_finding is not None:
-            logger.warning(
-                "Manuscript-context build warning surfaced (standalone "
-                "verify-claims; not surfaced as system issue): {}",
-                build_finding.context,
-            )
-        ensure_claim_query_vectors(references_dir, config)
+    ensure_claim_query_vectors(references_dir, config)
 
-    if backend == "claude":
-        vllm_model = ""
-        model_id = "claude"
-        logger.info("Backend: Claude Sonnet (via claude CLI)")
-    else:
-        vllm_model = model or config.llm_model or VLLM_DEFAULT_MODEL
-        model_id = f"vllm:{vllm_model}"
-        logger.info(f"Backend: vLLM ({VLLM_MODELS[vllm_model]['model']})")
+    vllm_model = model or config.llm_model or VLLM_DEFAULT_MODEL
+    model_id = f"vllm:{vllm_model}"
+    logger.info(f"Backend: vLLM ({VLLM_MODELS[vllm_model]['model']})")
 
     ref_paths: dict[str, Path | None] = {}
     ref_types: dict[str, str] = {}
+    ref_src_hashes: dict[str, str] = {}
     ref_sections: dict[str, list[Section]] = {}
     for key, local in local_files.items():
         ref_paths[key] = _resolve_reference_path(local, references_dir)
         meta = all_meta.get(key)
         if meta:
             ref_types[key] = meta.access.get("local_type", "none")
+            ref_src_hashes[key] = meta.access.get("local_file_src_hash", "")
         else:
             ref_types[key] = "pdf" if local.endswith(".pdf") else "summary"
+            ref_src_hashes[key] = ""
+
+    # parse_cache.pdf_hash moves whenever the GROBID-parsed PDF bytes
+    # change — covers OA-fetched refs (which have no drop-folder src
+    # hash) on top of the ref_src_hash signal for drop-folder refs.
+    from sciwrite_lint.references.workspace_db import (
+        get_db,
+        load_all_parse_cache,
+    )
+
+    ref_parse_hashes: dict[str, str] = {}
+    with get_db(references_dir) as _pc_conn:
+        for ref_key, row in load_all_parse_cache(_pc_conn).items():
+            ref_parse_hashes[ref_key] = row.get("pdf_hash", "")
 
     # Load previous results from workspace.db
     from sciwrite_lint.references.workspace_db import (
@@ -1603,8 +1613,35 @@ async def run_claim_verification(
 
     for i, claim in enumerate(verifiable):
         pk = (claim.key, claim.line)
-        if pk in previous:
-            results[i] = previous[pk]
+        cached = previous.get(pk)
+        # Reuse a cached verdict only when every input that could change
+        # it still matches: surrounding context, the backend/model that
+        # produced it, the kind of local source consulted, and the
+        # source-file hash (catches drop-folder PDF/MHTML re-ingests).
+        # Empty cached ref_src_hash is treated as "no info" — we don't
+        # invalidate on it alone, since OA-fetched refs have no ingest
+        # hash to compare.
+        cur_src_hash = ref_src_hashes.get(claim.key, "")
+        cur_parse_hash = ref_parse_hashes.get(claim.key, "")
+        cur_ref_type = ref_types.get(claim.key, "paper")
+        if (
+            cached is not None
+            and cached.get("context", "") == claim.context
+            and cached.get("backend", "") == backend
+            and cached.get("model", "") == model_id
+            and cached.get("ref_type", "") == cur_ref_type
+            and (
+                not cached.get("ref_src_hash", "")
+                or not cur_src_hash
+                or cached.get("ref_src_hash", "") == cur_src_hash
+            )
+            and (
+                not cached.get("ref_parse_hash", "")
+                or not cur_parse_hash
+                or cached.get("ref_parse_hash", "") == cur_parse_hash
+            )
+        ):
+            results[i] = cached
             skipped += 1
         elif not ref_paths.get(claim.key):
             results[i] = {
@@ -1628,11 +1665,6 @@ async def run_claim_verification(
             ref_sections[claim.key] = split_sections(ref_text) if ref_text else []
 
     _CLAIM_CONCURRENCY = 5
-    # Use the dynamic controller only when the vllm backend is active.
-    # Claude CLI has its own server-side admission, so a static
-    # semaphore is the right tool for it. ``concurrency_slot`` handles
-    # both branches uniformly so the loop body doesn't care which
-    # backend is in play.
     from sciwrite_lint.llm.concurrency_optimizer import (
         ControllerParams,
         concurrency_slot,
@@ -1643,7 +1675,7 @@ async def run_claim_verification(
         target_kv_grow=config.concurrency_target_kv_grow,
         target_kv_hi=config.concurrency_target_kv_hi,
     )
-    _use_dynamic = backend == "vllm" and config.use_dynamic_concurrency
+    _use_dynamic = config.use_dynamic_concurrency
     _slot_static_cap = (
         config.llm_max_concurrency if _use_dynamic else _CLAIM_CONCURRENCY
     )
@@ -1670,42 +1702,31 @@ async def run_claim_verification(
                 f"{ref_path.name} is a web page summary, not the actual paper"
             )
 
-        if backend == "claude":
-            # Claude CLI has its own server-side admission; use the slot
-            # as an outer per-claim throttle.
-            async with _slot():
-                from sciwrite_lint.claude_backend import verify_claim_claude
-
-                logger.debug(f"Reference: {ref_path.name}")
-                logger.info("Sending to Claude CLI...")
-                project_dir = config.project_dir if config else None
-                verdict = verify_claim_claude(claim, ref_path, project_dir=project_dir)
-        else:
-            # vLLM: the slot wraps each individual LLM call inside
-            # verify_claim_vllm, so the controller's dynamic cap bounds
-            # the actual vLLM request volume regardless of how many
-            # claims and ladder fan-outs run in parallel.
-            sections = ref_sections[claim.key]
-            if not sections:
-                results[idx] = {
-                    "key": claim.key,
-                    "line": claim.line,
-                    "context": claim.context,
-                    "verdict": "CANNOT_DETERMINE",
-                    "explanation": "Could not read reference",
-                }
-                return
-
-            logger.debug(f"Reference: {ref_path.name} ({len(sections)} sections)")
-            verdict = await verify_claim_vllm(
-                claim,
-                sections,
-                config=config,
-                model_name=vllm_model,
-                references_dir=references_dir,
-                client=vllm_client,
-                slot=_slot,
-            )
+        # vLLM: the slot wraps each individual LLM call inside
+        # verify_claim_vllm, so the controller's dynamic cap bounds
+        # the actual vLLM request volume regardless of how many
+        # claims and ladder fan-outs run in parallel.
+        sections = ref_sections[claim.key]
+        if not sections:
+            results[idx] = {
+                "key": claim.key,
+                "line": claim.line,
+                "context": claim.context,
+                "verdict": "CANNOT_DETERMINE",
+                "explanation": "Could not read reference",
+            }
+            return
+
+        logger.debug(f"Reference: {ref_path.name} ({len(sections)} sections)")
+        verdict = await verify_claim_vllm(
+            claim,
+            sections,
+            config=config,
+            model_name=vllm_model,
+            references_dir=references_dir,
+            client=vllm_client,
+            slot=_slot,
+        )
 
         if verdict:
             verdict["key"] = claim.key
@@ -1714,6 +1735,8 @@ async def run_claim_verification(
             verdict["backend"] = backend
             verdict["model"] = model_id
             verdict["ref_type"] = ref_type
+            verdict["ref_src_hash"] = ref_src_hashes.get(claim.key, "")
+            verdict["ref_parse_hash"] = ref_parse_hashes.get(claim.key, "")
             if ref_type == "web_page" and verdict.get("verdict") == "NOT_SUPPORTED":
                 verdict["verdict"] = "CANNOT_DETERMINE"
                 verdict["explanation"] = (
@@ -1744,23 +1767,18 @@ async def run_claim_verification(
             label="claim-verify",
             params=_ctrl_params,
         ) as _slot:
-            if backend == "claude":
+            # Shared vLLM client for all claim verifications — avoids
+            # creating and tearing down a connection per claim.
+            from openai import AsyncOpenAI
+
+            async with AsyncOpenAI(
+                base_url=config.llm_endpoint,
+                api_key="dummy",
+                timeout=config.llm_timeout,
+            ) as vllm_client:
                 await asyncio.gather(
-                    *[_verify_one(idx, c, None) for idx, c in to_verify]
+                    *[_verify_one(idx, c, vllm_client) for idx, c in to_verify]
                 )
-            else:
-                # Shared vLLM client for all claim verifications — avoids
-                # creating and tearing down a connection per claim.
-                from openai import AsyncOpenAI
-
-                async with AsyncOpenAI(
-                    base_url=config.llm_endpoint,
-                    api_key="dummy",
-                    timeout=config.llm_timeout,
-                ) as vllm_client:
-                    await asyncio.gather(
-                        *[_verify_one(idx, c, vllm_client) for idx, c in to_verify]
-                    )
 
     # Flatten — any None slots are claims that fell through (shouldn't happen)
     verified_results = [r for r in results if r is not None]