papercheck 0.3.0__tar.gz

papercheck-0.3.0/.gitattributes

@@ -0,0 +1,3 @@
+* text=auto eol=lf
+*.png binary
+*.pdf binary

papercheck-0.3.0/.github/workflows/ci.yml

@@ -0,0 +1,26 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Install
+        run: python -m pip install -e ".[dev]"
+      - name: Ruff
+        run: ruff check .
+      - name: Pytest
+        run: pytest -q
+      - name: Privacy check
+        run: python scripts/privacy_check.py

papercheck-0.3.0/.github/workflows/example-paper-audit.yml

@@ -0,0 +1,40 @@
+name: "Papercheck Mechanical Audit"
+
+# Trigger on pull requests and manual workflow runs
+on:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  mechanical-audit:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      # USAGE OPTION 1: Use the published GitHub Action from the papercheck repo
+      # (requires papercheck to be published and the action to be in the OWNER/papercheck repo)
+      # Uncomment the step below and comment out USAGE OPTION 2:
+      #
+      # - name: Run papercheck mechanical audit
+      #   uses: OWNER/papercheck@v0.2.0
+      #   with:
+      #     paper-root: "."
+
+      # USAGE OPTION 2: Install and run papercheck directly in the workflow
+      # Use this if you haven't published the action to GitHub yet, or for testing.
+      # Replace "." with the path to your paper root (e.g., "paper/" if sources are in a subdirectory).
+      - name: Run papercheck mechanical audit
+        uses: actions/checkout@v4  # This ensures we have the latest code
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Install papercheck
+        run: pip install papercheck
+      - name: Run scan
+        run: papercheck scan "."
+      - name: Run segments
+        run: papercheck segments "."
+      - name: Run gate check
+        run: papercheck gate "." --mechanical-only

papercheck-0.3.0/.github/workflows/publish.yml

@@ -0,0 +1,42 @@
+name: Publish to PyPI
+
+# Publishes papercheck to PyPI when a GitHub Release is published, using PyPI
+# Trusted Publishing (OpenID Connect) — no API token or password is stored.
+# The matching trusted publisher must be registered on PyPI:
+#   project: papercheck   owner: cgarryZA   repo: papercheck
+#   workflow: publish.yml  environment: pypi
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  build-and-publish:
+    name: Build and publish to PyPI
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/papercheck
+    permissions:
+      id-token: write   # required for OIDC trusted publishing
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Build sdist and wheel
+        run: |
+          python -m pip install --upgrade build
+          python -m build
+
+      - name: Check the built distributions
+        run: |
+          python -m pip install --upgrade twine
+          twine check dist/*
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

papercheck-0.3.0/.gitignore

@@ -0,0 +1,18 @@
+__pycache__/
+*.egg-info/
+.pytest_cache/
+build/
+dist/
+dist_check/
+*.whl
+.ruff_cache/
+Paper_Audit/
+
+# LaTeX build products (e.g. generated by the gate's latexmk build in fixtures)
+*.aux
+*.fdb_latexmk
+*.fls
+*.log
+*.pdf
+*.out
+*.synctex.gz

papercheck-0.3.0/CHANGELOG.md

@@ -0,0 +1,84 @@
+# Changelog
+
+All notable changes to papercheck are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.3.0] — 2026-07-02
+
+### Added
+
+- **LaTeX-AST scanner** — `texscan.scan` now builds a real LaTeX node tree
+  (via `pylatexenc`) instead of regex/line matching, with a graceful regex
+  fallback on malformed input. Output schema is unchanged.
+- **Interactive web UI** — `papercheck serve <paper_root>` starts a local
+  stdlib HTTP server with a filterable issue table (by status/severity/category)
+  and click-to-source; jailed source reader, XSS-safe rendering.
+
+### Fixed
+
+- Single-line `\begin{theorem}\label{...}...\end{theorem}` now attributes the
+  label to the theorem environment; macro-defined (`\newtheorem`) and nested
+  environments are handled.
+
+## [0.2.0] — 2026-07-02
+
+### Added
+
+- **HTML audit report** — `papercheck report <paper_root>` writes a
+  self-contained HTML report to `Paper_Audit/report/index.html` with verdict
+  banner, issue table, segments, and manual checks.
+- **Version-compare command** — `papercheck compare <old_root> <new_root>`
+  produces a structural diff of two paper versions (theorems by label,
+  abstract, labels, citations, equations) and writes `Paper_Audit/version_comparison.md`.
+- **Audit profiles** — `papercheck profile [list|show <name>]` exposes advisory
+  audit profiles (quick, arxiv, full, journal, no-cloud), each with an ordered
+  sequence of recommended steps and a mechanical_only flag. Profiles are
+  advisory only; papercheck does not execute them automatically.
+- **Domain pack generator and CLI** — `papercheck packs [list|show <name>|scaffold
+  --paper-root <root>|create <file.json> --paper-root <root>]` enables building
+  paper-specific domain packs. Scaffold deterministically extracts structure;
+  create validates and persists a filled-in pack to `Paper_Audit/domain_pack.json`.
+- **Four new MCP tools** — `list_domain_packs`, `get_domain_pack`,
+  `scaffold_domain_pack`, `create_domain_pack`. Agents fill in domain knowledge;
+  papercheck validates and stores it.
+- **New shipped domain packs** — `pde`, `optimization`, `machine_learning`,
+  `general` (fully generic) join existing `stochastic_analysis`, `numerical_analysis`.
+- **End-user GitHub Action** — composite action in `action.yml` + example
+  workflow (`.github/workflows/example-paper-audit.yml`) + documentation
+  (`docs/ci.md`) for running mechanical-only checks (scan, segments, gate
+  --mechanical-only) in CI without sending the manuscript to external services.
+- **29 MCP tools** (up from 25) — all new tools wired to the stdio MCP server.
+- **118 mechanical tests** — all passing; includes 31 new tests for v0.2 features.
+
+## [0.1.0] — 2026-06-01
+
+### Added
+
+- **Deterministic LaTeX scanner** — regex-based structure extraction producing
+  `structure.json` (theorems, labels, refs, citations, draft markers) with no
+  guessing and no network calls.
+- **Stage-gated state machine** — fixed workflow stages (INIT → SCANNED →
+  SEGMENTED → INVENTORIED → AUDITING → SYNTHESIZED → ADJUDICATED →
+  PATCH_PLANNED → PATCHING → REGRESSED → GATED) enforced in code.
+- **Schema-validated ledgers** — JSON Schemas for issues, patches, segments,
+  manual checks, and state; unverifiable findings rejected as
+  `REJECTED_SOURCE_TARGET_INVALID` before entering the ledger.
+- **Verified issue intake** — exact quote verification, label/ref/cite/file
+  checking, with unverifiable issues rejected mechanically.
+- **Mechanical final gate** — code-enforced verdict (READY / NOT READY) based on
+  build status, label/ref/cite counts, draft markers, and open blockers.
+- **Markdown report rendering** — JSON-to-Markdown for all workflow stages
+  (e.g., `10_final_acceptance_gate.md`).
+- **Typer CLI** — 7 commands (scan, segments, render, init, submit-issue,
+  adjudicate, gate) with full help text.
+- **FastMCP stdio server** — 25 tools exposing the deterministic core to any
+  MCP-capable agent (e.g., Claude Code).
+- **Vendored prompt pack** — domain-agnostic auditing prompt in `prompts/`.
+- **Shipped domain packs** — `stochastic_analysis`, `numerical_analysis` in
+  `domain_packs/` with categorized theorem types and technique keywords.
+- **Evaluation fixtures** — toy papers (clean, draft-marked, unresolved refs)
+  for testing and agent-eval workflows.
+- **CI + packaging** — green `ruff` lint, 87 mechanical tests, privacy check,
+  wheel with bundled data dirs (schemas, prompts, templates, domain_packs).

papercheck-0.3.0/CITATION.cff

@@ -0,0 +1,23 @@
+cff-version: 1.2.0
+message: "If you use papercheck, please cite it using these metadata."
+title: papercheck
+type: software
+version: 0.3.0
+license: MIT
+abstract: >-
+  papercheck is a reproducible audit harness for mathematical LaTeX papers. It
+  turns a paper into a stage-gated adversarial audit: deterministic structure
+  extraction, JSON-Schema-validated issue ledgers with mechanical quote
+  verification, and a code-enforced final gate that any MCP-capable agent can
+  drive but cannot skip. It does not itself call an LLM and is not a theorem
+  prover or a replacement for peer review.
+authors:
+  - name: "papercheck contributors"
+keywords:
+  - latex
+  - mathematics
+  - research-software
+  - reproducibility
+  - paper-review
+  - mcp
+  - audit

papercheck-0.3.0/CONTRIBUTING.md

@@ -0,0 +1,77 @@
+# Contributing to papercheck
+
+Thanks for your interest. papercheck is small, deterministic, and deliberately
+scoped. Please read the discipline notes below before opening a PR — they are
+not negotiable for the v0.1 line.
+
+## Setup
+
+```bash
+python -m pip install -e ".[dev]"
+```
+
+This installs papercheck in editable mode with the dev extras (`pytest`,
+`ruff`).
+
+## Run the tests
+
+```bash
+pytest -q
+```
+
+The suite is fully mechanical — no LLM calls, no network. It must stay green on
+both Linux and Windows.
+
+## Lint
+
+```bash
+ruff check .
+```
+
+CI runs the same command; keep it clean.
+
+## Privacy check (required)
+
+```bash
+python scripts/privacy_check.py
+```
+
+This must exit 0. It scans the repository for forbidden identifiers tied to a
+specific unpublished paper. **Never add paper-specific unpublished content** —
+manuscripts, real author names, private quotes, or anything that identifies a
+non-public paper — to this repository. Toy fixtures under `tests/fixtures/` are
+synthetic and self-contained by design; keep them that way.
+
+## Phase / spec discipline (v0.1)
+
+The architecture is fixed for the v0.1 line. PRs that change these will be
+declined:
+
+- **No LLM provider code.** papercheck never calls a model API. The reasoning
+  lives in the driving agent (Claude Code or any MCP client) or in a human. Do
+  not add provider adapters, API clients, or keys.
+- **JSON is the source of truth.** Issues, patches, segments, manual checks, and
+  state are JSON validated against the schemas in `schemas/`. Markdown reports
+  are *rendered from* JSON, never authored directly.
+- **Gates are enforced in code.** Stage ordering and the final gate live in the
+  Python core, not in prompts. Do not move enforcement into agent instructions.
+
+If you have a change that needs one of these, open an issue to discuss it as a
+future major-version direction first (see the deferred list in `PROGRESS.md`).
+
+## How prompts are tested
+
+Prompts and the audit workflow are validated in two tiers:
+
+- **Tier 1 — mechanical fixtures.** The pytest suite exercises the deterministic
+  core against the toy fixtures in `tests/fixtures/` (e.g. the label/ref fixture
+  is mechanically detectable). This runs in CI.
+- **Tier 2 — agent-eval.** A human or MCP agent runs the full audit workflow
+  against the *semantic* fixtures and checks that planted defects are found and
+  survive adjudication, and that the false-positive trap is correctly rejected.
+  This is **not** run in CI (it requires an LLM). See
+  [`docs/agent_eval.md`](docs/agent_eval.md) for the exact procedure, and use
+  `scripts/agent_eval_report.py` to summarize a completed audit.
+
+When you change a prompt, describe in your PR which fixtures you re-ran under
+Tier 2 and what you observed.

papercheck-0.3.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 papercheck contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

papercheck-0.3.0/PKG-INFO

@@ -0,0 +1,177 @@
+Metadata-Version: 2.4
+Name: papercheck
+Version: 0.3.0
+Summary: A reproducible audit harness for mathematical LaTeX papers.
+Project-URL: Homepage, https://github.com/OWNER-PLACEHOLDER/papercheck
+Project-URL: Repository, https://github.com/OWNER-PLACEHOLDER/papercheck
+License: MIT
+License-File: LICENSE
+Keywords: audit,latex,mathematics,mcp,paper-review,reproducibility,research-software
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Requires-Dist: jsonschema>=4.0
+Requires-Dist: mcp>=1.0
+Requires-Dist: pylatexenc>=2.10
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+<img src="docs/assets/logo.png" alt="papercheck" width="680"/>
+
+<br/>
+
+A reproducible audit harness for mathematical LaTeX papers.
+
+<a href="https://github.com/cgarryZA/papercheck/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-22c55e"></a>
+<a href="https://www.python.org/"><img src="https://img.shields.io/badge/python-3.10%2B-3776AB?logo=python&logoColor=white"></a>
+<img src="https://img.shields.io/badge/tests-140_passing-16a34a">
+<img src="https://img.shields.io/badge/version-0.3.0-8b5cf6">
+<a href="https://modelcontextprotocol.io"><img src="https://img.shields.io/badge/MCP-server-ff6d00"></a>
+
+</div>
+
+papercheck extracts a paper's structure, records findings in schema-validated ledgers that are checked against the exact source text, and runs a final gate that reports whether the paper is ready. It runs as a command-line tool, or as an MCP server that an agent (Claude Code, Codex, Cursor, or similar) drives while you supply the mathematical judgement.
+
+The point is discipline. Instead of asking one model to "review the paper," papercheck segments the manuscript, inventories the claims, runs narrow hostile audits, verifies each finding against the source, adjudicates, patches only what was accepted, and gates. The gates are enforced in code: an agent cannot patch before adjudication, and a finding whose quote does not appear in the source never enters the ledger.
+
+The staged pipeline — segment, budget, specialist review, synthesize, adjudicate — follows the approach described in Google Research's Paper Assistant Tool (PAT) [[1]](#references), adapted into a small, open, model-agnostic harness that runs no models of its own.
+
+## What it is
+
+A deterministic Python core with two frontends — a CLI and an MCP server. papercheck itself never calls a model; the reasoning lives in the agent or in your hands at the CLI. What the core provides:
+
+- LaTeX-AST structure extraction (theorems, labels, references, citations, equations, draft markers) into `structure.json`.
+- Schema-validated issue ledgers, each finding tied to a file and line.
+- Quote verification at intake: if a finding's quoted text is not in the source, it is rejected as `REJECTED_SOURCE_TARGET_INVALID` before it reaches the proposed ledger.
+- A stage-gated state machine (`INIT → SCANNED → … → ADJUDICATED → … → GATED`) that refuses out-of-order operations.
+- A CLI, an MCP server (29 tools), and a local web UI.
+
+## Why
+
+A single "review my paper" prompt tends to fail in three ways. papercheck handles each in code rather than in prompting:
+
+| Failure mode | What usually happens | How papercheck handles it |
+| --- | --- | --- |
+| Hallucinated findings | the model invents a problem that isn't in the text | `submit_issue` matches the quoted text against the source; no match means the finding is rejected before it enters the ledger |
+| Patch before proof | the model rewrites before anyone knows what is real | patches are refused unless the state is at `ADJUDICATED` and the issue is `ACCEPTED` |
+| Skipped gate | "looks good to me" with no audit trail | the final gate is computed from mechanical signals and accepted blockers, and returns one of a fixed set of verdicts |
+
+## Quickstart
+
+```bash
+pipx install papercheck        # or: pip install papercheck
+
+papercheck scan     path/to/paper     # extract structure.json
+papercheck segments path/to/paper     # propose audit segments and budgets
+papercheck gate     path/to/paper --mechanical-only
+papercheck report   path/to/paper     # self-contained HTML report
+papercheck serve    path/to/paper     # local web UI
+```
+
+Run it on the bundled example (prints `==== READY ====`):
+
+```bash
+papercheck gate examples/toy_clean_paper --mechanical-only
+```
+
+## Driving it from an agent (MCP)
+
+papercheck ships a FastMCP server exposing 29 tools plus the audit prompt pack. Register it once:
+
+```bash
+claude mcp add papercheck -- papercheck-mcp
+```
+
+Then ask the agent to audit a paper. It walks the workflow through the MCP tools — `init_audit`, `run_scan`, `propose_segments`, `submit_issue`, `adjudicate_issue`, `run_gate` — under the same code-enforced gates as the CLI.
+
+<details>
+<summary>Generating a paper-specific domain pack</summary>
+
+<br/>
+
+papercheck does not call a model, so tailoring the audit to a paper's field is a two-step split: the agent reads the paper and drafts the pack, papercheck validates and stores it.
+
+```bash
+papercheck packs scaffold --paper-root ./paper            # deterministic draft from the scan
+papercheck packs create draft.json --paper-root ./paper   # validated -> Paper_Audit/domain_pack.json
+```
+
+The same is available through the `scaffold_domain_pack` and `create_domain_pack` MCP tools. Generic packs ship for stochastic analysis, PDE, numerical analysis, optimization, machine-learning theory, and a general fallback.
+
+</details>
+
+## How it works
+
+```mermaid
+flowchart LR
+    A[INIT] --> B[SCANNED] --> C[SEGMENTED] --> D[INVENTORIED] --> E[AUDITING]
+    E --> F[SYNTHESIZED] --> G[ADJUDICATED] --> H[PATCH_PLANNED]
+    H --> I[PATCHING] --> J[REGRESSED] --> K[GATED]
+
+    E -. submit_issue .-> V{quote and label verified?}
+    V -- no --> X[REJECTED_SOURCE_TARGET_INVALID]
+    V -- yes --> L[PROPOSED ledger]
+    style X fill:#7f1d1d,stroke:#ef4444,color:#fff
+    style K fill:#14532d,stroke:#22c55e,color:#fff
+```
+
+One deterministic core, two frontends, no LLM calls inside the harness. papercheck stays strictly an MCP server and CLI — no provider adapters, no self-orchestration — so it works with any model and makes no network calls of its own.
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `papercheck init` | create the `Paper_Audit/` workspace and state file |
+| `papercheck scan` | LaTeX-AST structure extraction into `structure.json` |
+| `papercheck segments` | heuristic segment and budget proposal |
+| `papercheck gate [--mechanical-only]` | compute the final verdict (exit 0 = READY) |
+| `papercheck verify-quote` | check a quote against a source file |
+| `papercheck report` | self-contained HTML audit report |
+| `papercheck serve` | local web UI (filter issues, click through to source) |
+| `papercheck compare old/ new/` | structural diff of two paper versions |
+| `papercheck profile list\|show` | advisory audit pipelines (`quick`, `arxiv`, `full`, …) |
+| `papercheck packs …` | list, scaffold, or create domain packs |
+| `papercheck prompts list\|show` | the vendored audit prompt pack |
+| `papercheck mcp` | run the MCP server (stdio) |
+
+For a paper repository, [`docs/ci.md`](docs/ci.md) describes a mechanical, LLM-free GitHub Action that runs `scan` and `gate --mechanical-only` on every pull request and sends nothing to any model provider.
+
+## Limitations
+
+See [`docs/limitations.md`](docs/limitations.md) for the full version.
+
+- papercheck is not a theorem prover and not a replacement for peer review.
+- Catching a semantic error depends entirely on the driving model. papercheck keeps the process disciplined and traceable, but AI findings must be checked independently.
+- papercheck makes no network calls. The agent you drive it with may transmit your manuscript to its model provider, so review the relevant data terms before auditing unpublished work ([`docs/privacy.md`](docs/privacy.md)).
+
+## About
+
+Built by Christian Garry.
+
+<a href="https://www.linkedin.com/in/christian-tt-garry/"><img src="https://img.shields.io/badge/LinkedIn-Christian_Garry-0A66C2?logo=linkedin&logoColor=white"></a>
+<a href="https://christiangarry.com"><img src="https://img.shields.io/badge/Website-christiangarry.com-22c55e"></a>
+
+## Contributing
+
+Contributions welcome — see [`CONTRIBUTING.md`](CONTRIBUTING.md). The architecture is fixed for the 0.x line: strictly MCP and CLI, JSON as the source of truth, gates enforced in code. Prompt changes are guarded by the eval fixtures described in [`docs/agent_eval.md`](docs/agent_eval.md).
+
+## References
+
+<a name="references"></a>
+
+1. Rajesh Jayaram, Drew Tyler, David Woodruff, Corinna Cortes, Yossi Matias, Vahab Mirrokni, and Vincent Cohen-Addad. *Towards Automating Scientific Review with Google's Paper Assistant Tool.* arXiv:2606.28277, 2026. <https://arxiv.org/abs/2606.28277>
+
+BibTeX for the above is in [`docs/references.bib`](docs/references.bib).
+
+## License
+
+MIT — see [`LICENSE`](LICENSE). If papercheck is useful in your work, cite it via [`CITATION.cff`](CITATION.cff).

papercheck-0.3.0/PROGRESS.md

@@ -0,0 +1,101 @@
+# Build progress
+
+A concise log of how papercheck v0.1 was built, phase by phase, with the test
+count at the end of each phase.
+
+## Phases
+
+- **P0 — Repo bootstrap.** Package skeleton, `pyproject.toml` (hatchling),
+  license, canonical `Paper_Audit/` path helpers, first smoke tests.
+  *(tests: 4)*
+- **P1 — Schemas + state machine.** JSON Schemas for issue / patch / segment /
+  manual-check / state; the stage-gated `AuditState` with `require_at_least`.
+  *(tests: 30)*
+- **P2 — Scanner.** Deterministic regex TeX scanner producing `structure.json`
+  (theorem envs, labels, refs, citations, draft markers). *(tests: 50, with P3)*
+- **P3 — Verifiers.** Whitespace-normalized quote verifier, label/ref/cite/file
+  verification, and issue intake that rejects unverifiable findings as
+  `REJECTED_SOURCE_TARGET_INVALID`. *(tests: 50, with P2)*
+- **P4 — Segments + gate + rendering.** Segment proposal, the mechanical final
+  gate (build + label/ref/cite + draft-marker + open-blocker signals), and
+  JSON→Markdown report rendering (e.g. `10_final_acceptance_gate.md`).
+  *(tests: 61)*
+- **P5 — MCP server.** FastMCP stdio server exposing 25 tools as thin wrappers
+  over the deterministic core; `papercheck-mcp` entry point. *(tests: 73)*
+- **P6 — Prompt pack + domain pack + fixtures.** Vendored prompt pack
+  (`prompts/`), domain packs (`domain_packs/`), and the toy fixtures — including
+  the semantic fixtures used for agent-eval. *(tests: 85)*
+- **P7 — Docs + release polish.** README, `docs/` (limitations, comparison,
+  privacy, agent-eval), `CITATION.cff`, `CONTRIBUTING.md`, this log, the
+  non-LLM `scripts/agent_eval_report.py` helper, and `pyproject.toml` metadata
+  (urls / keywords / classifiers). Packaging work brought the wheel data dirs
+  and CI matrix to green. *(tests: 87, incl. packaging)*
+
+Test-count progression: **P0: 4 → P1: 30 → P2/P3: 50 → P4: 61 → P5: 73 →
+P6: 85 → packaging: 87.**
+
+## Current status
+
+- **v0.1 feature-complete.** 87 mechanical tests passing.
+- **Wheel ships the data dirs** (`schemas/`, `prompts/`, `templates/`,
+  `domain_packs/`) via hatch force-include.
+- **CI is green** — lint (`ruff`) + `pytest` + privacy check, on Ubuntu and
+  Windows.
+
+## v0.2
+
+- **HTML report** — `papercheck report <paper_root>` writes a self-contained
+  HTML audit report to `Paper_Audit/report/index.html` from JSON artifacts
+  (verdict banner, issue table, segments, manual checks).
+- **Version-compare** — `papercheck compare <old_root> <new_root>` produces a
+  structural diff showing added/removed/changed theorems by label, abstract
+  changes, and label/citation/section diffs; writes to `Paper_Audit/version_comparison.md`.
+- **Audit profiles** — `papercheck profile [list|show <name>]` exposes advisory
+  audit profiles (quick, arxiv, full, journal, no-cloud), each defining an
+  ordered sequence of recommended steps and a mechanical_only flag. Profiles are
+  advisory only; papercheck does not self-orchestrate.
+- **Domain pack generator** — `papercheck packs scaffold --paper-root <root>`
+  deterministically drafts a domain pack from a scanned paper's structure;
+  `papercheck packs create <file.json> --paper-root <root>` validates and
+  persists a filled-in pack to `Paper_Audit/domain_pack.json`. Four new MCP
+  tools (`list_domain_packs`, `get_domain_pack`, `scaffold_domain_pack`,
+  `create_domain_pack`) enable agents to fill in domain knowledge while
+  papercheck validates and stores the result.
+- **New domain packs** — shipped `pde`, `optimization`, `machine_learning`,
+  `general` (fully generic) in addition to existing `stochastic_analysis`,
+  `numerical_analysis`.
+- **End-user GitHub Action** — composite action + example workflow
+  (`.github/workflows/example-paper-audit.yml`) + `docs/ci.md` for running
+  mechanical-only checks (scan, segments, gate --mechanical-only) in CI. Never
+  sends the manuscript to any external service; papercheck's own dev CI is
+  unchanged.
+- **118 mechanical tests passing** (87 in v0.1 + 31 for new features).
+
+## v0.2 — Explicitly excluded by design
+
+These are intentionally not built:
+
+- **LLM provider adapters** — papercheck never calls a model itself; the agent
+  driving the audit supplies the reasoning.
+- **Self-orchestration** — papercheck is an MCP server and CLI, not an
+  autonomous agent.
+
+## Explicitly deferred (future or out of scope)
+
+- **LLM-in-CI evals** — Tier 2 agent-eval stays manual; CI runs no model.
+- **LaTeX AST parsing** — fine-grained structural analysis via AST traversal.
+- **Web UI** — the CLI and MCP tools form the user surface.
+
+## Deviations from spec
+
+Small, deliberate departures worth recording:
+
+- **Handler `render` → `render_reports`.** The MCP/handler entry point is named
+  `render_reports` (the CLI command stays `render`) to avoid colliding with the
+  core `render` module name.
+- **Id-assign before schema-validate in `issues.py`.** `submit_issue` assigns a
+  missing/blank `issue_id` *before* JSON-Schema validation, because a blank id
+  fails the schema's id pattern; validation then runs on the completed record.
+- **`amsthm` added to the clean fixture.** `tests/fixtures/toy_clean_paper`
+  loads `amsthm` so theorem environments are well-formed and the fixture builds
+  cleanly under the gate's latexmk build.