Clean up repo: deduplicate docs, remove stale files, fix configs

- Slim CLAUDE.md (193→87 lines): extract duplicated content into rule files
- Add rules/documentation.md for Typst paper patterns
- Update rules/adding-reductions.md to use #[reduction] macro
- Delete 21 stale plan files in docs/plans/ (-12K lines)
- Remove Cargo.lock from tracking (library crate)
- Consolidate duplicate coverage CI into ci.yml, delete coverage.yml
- Fix Makefile compare target paths (tests/julia/ → tests/data/)
- Fix book.toml repo URL (liujinguo → CodingThrust)
- Gitignore .claude/settings.local.json and Cargo.lock

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: GiggleLiu

.claude/CLAUDE.md

@@ -26,8 +26,8 @@ make test clippy export-graph  # Must pass before PR
 - `src/traits.rs` - `Problem`, `ConstraintSatisfactionProblem` traits
 - `src/rules/traits.rs` - `ReduceTo<T>`, `ReductionResult` traits
 - `src/registry/` - Compile-time reduction metadata collection
-- `src/unit_tests/` - Unit test files (extracted from inline `mod tests` blocks via `#[path]`)
-- `tests/main.rs` - User-facing integration tests only (modules in `tests/suites/`)
+- `src/unit_tests/` - Unit test files (mirroring `src/` structure, referenced via `#[path]`)
+- `tests/main.rs` - Integration tests (modules in `tests/suites/`)
 
 ### Trait Hierarchy
 
@@ -56,80 +56,11 @@ ConstraintSatisfactionProblem : Problem (extension for CSPs)
 └── ... (default methods: is_satisfied, compute_objective)
 ```
 
-### Problem Implementations
-
-| Problem | `Problem` | `ConstraintSatisfactionProblem` |
-|---------|:---------:|:-------------------------------:|
-| IndependentSet | ✓ | ✓ |
-| VertexCovering | ✓ | ✓ |
-| DominatingSet | ✓ | ✓ |
-| Matching | ✓ | ✓ |
-| MaxCut | ✓ | ✗ |
-| Coloring | ✓ | ✓ |
-| Satisfiability | ✓ | ✓ |
-| KSatisfiability | ✓ | ✓ |
-| SetPacking | ✓ | ✓ |
-| SetCovering | ✓ | ✓ |
-| SpinGlass | ✓ | ✗ |
-| QUBO | ✓ | ✗ |
-| ILP | ✓ | ✗ |
-| CircuitSAT | ✓ | ✗ |
-| Factoring | ✓ | ✗ |
-
 ### Key Patterns
 - Problems parameterized by weight type `W` and graph type `G`
 - `ReductionResult` provides `target_problem()` and `extract_solution()`
 - Graph types: SimpleGraph, GridGraph, UnitDiskGraph, Hypergraph
-
-## Conventions
-
-### File Naming
-- Reduction files: `src/rules/<source>_<target>.rs`
-- Model files: `src/models/<category>/<name>.rs`
-- Test naming: `test_<source>_to_<target>_closed_loop`
-
-### Reduction Pattern (Recommended: Using Macro)
-```rust
-use problemreductions::reduction;
-
-#[reduction(
-    overhead = { ReductionOverhead::new(vec![...]) }
-)]
-impl ReduceTo<TargetProblem<Unweighted>> for SourceProblem<Unweighted> {
-    type Result = ReductionSourceToTarget;
-    fn reduce_to(&self) -> Self::Result { ... }
-}
-```
-
-The `#[reduction]` macro automatically:
-- Extracts type names from the impl signature
-- Detects weighted vs unweighted from type parameters (`Unweighted` vs `i32`/`f64`)
-- Detects graph types from type parameters (e.g., `GridGraph`, `SimpleGraph`)
-- Generates the `inventory::submit!` call
-
-Optional macro attributes:
-- `source_graph = "..."` - Override detected source graph type
-- `target_graph = "..."` - Override detected target graph type
-- `source_weighted = true/false` - Override weighted detection
-- `target_weighted = true/false` - Override weighted detection
-- `overhead = { ... }` - Specify reduction overhead
-
-### Manual Registration (Alternative)
-```rust
-inventory::submit! {
-    ReductionEntry {
-        source_name: "SourceProblem",
-        target_name: "TargetProblem",
-        source_variant: &[("graph", "SimpleGraph"), ("weight", "Unweighted")],
-        target_variant: &[("graph", "SimpleGraph"), ("weight", "Unweighted")],
-        overhead_fn: || ReductionOverhead::new(...),
-    }
-}
-```
-
-### Weight Types
-- `Unweighted` - Marker type for unweighted problems (all weights = 1)
-- `i32`, `f64`, etc. - Concrete weight types for weighted problems
+- Weight types: `Unweighted` (marker), `i32`, `f64`
 
 ### Problem Variant IDs
 Reduction graph nodes use variant IDs: `ProblemName[/GraphType][/Weighted]`
@@ -138,55 +69,18 @@ Reduction graph nodes use variant IDs: `ProblemName[/GraphType][/Weighted]`
 - Weighted variant: `IndependentSet/Weighted`
 - Both: `IndependentSet/GridGraph/Weighted`
 
-## Anti-patterns
-- Don't create reductions without closed-loop tests
-- Don't forget `inventory::submit!` registration (graph won't update)
-- Don't hardcode weights - use generic `W` parameter
-- Don't skip `make clippy` before PR
-
-## Documentation Requirements
-
-The technical paper (`docs/paper/reductions.typ`) must include:
-
-1. **Table of Contents** - Auto-generated outline of all sections
-2. **Problem Data Structures** - For each problem definition, include the Rust struct with fields in a code block
-3. **Reduction Examples** - For each reduction theorem, include a minimal working example showing:
-   - Creating the source problem
-   - Reducing to target problem
-   - Solving and extracting solution back
-   - Based on closed-loop tests from `tests/reduction_tests.rs`
-
-### Documentation Pattern
-```typst
-#definition("Problem Name")[
-  Mathematical definition...
-]
-
-// Rust data structure
-```rust
-pub struct ProblemName<W = i32> {
-    field1: Type1,
-    field2: Type2,
-}
-`` `
-
-#theorem[
-  *(Source → Target)* Reduction description...
-]
+## Conventions
 
-// Minimal working example
-```rust
-let source = SourceProblem::new(...);
-let reduction = ReduceTo::<TargetProblem>::reduce_to(&source);
-let target = reduction.target_problem();
-// ... solve and extract
-`` `
-```
+### File Naming
+- Reduction files: `src/rules/<source>_<target>.rs`
+- Model files: `src/models/<category>/<name>.rs`
+- Test naming: `test_<source>_to_<target>_closed_loop`
 
 ## Contributing
 See `.claude/rules/` for detailed guides:
 - `adding-reductions.md` - How to add reduction rules
 - `adding-models.md` - How to add problem types
 - `testing.md` - Testing requirements and patterns
+- `documentation.md` - Paper documentation patterns
 
 Also see GitHub Issue #3 for coding rules.

.claude/rules/adding-reductions.md

@@ -9,59 +9,33 @@ paths:
 Create `src/rules/<source>_<target>.rs`:
 
 ```rust
-// Register reduction for automatic discovery (adds edge + metadata)
-inventory::submit! {
-    ReductionEntry {
-        source_name: "SourceProblem",
-        target_name: "TargetProblem",
-        source_graph: "SourceProblem",
-        target_graph: "TargetProblem",
-        overhead_fn: || ReductionOverhead::new(vec![
-            ("num_vars", Polynomial { terms: vec![...] }),
-            ("num_constraints", Polynomial { terms: vec![...] }),
-        ]),
-    }
-}
+use problemreductions::reduction;
 
-impl ReduceTo<TargetProblem> for SourceProblem {
+#[reduction(
+    overhead = { ReductionOverhead::new(vec![...]) }
+)]
+impl ReduceTo<TargetProblem<Unweighted>> for SourceProblem<Unweighted> {
     type Result = ReductionSourceToTarget;
     fn reduce_to(&self) -> Self::Result { ... }
 }
 ```
 
+The `#[reduction]` macro auto-generates the `inventory::submit!` call. Optional attributes: `source_graph`, `target_graph`, `source_weighted`, `target_weighted`.
+
 Register module in `src/rules/mod.rs`:
 ```rust
 mod source_target;
 pub use source_target::ReductionSourceToTarget;
 ```
 
 ## 2. Closed-Loop Test (Required)
-```rust
-#[test]
-fn test_closed_loop() {
-    // 1. Create small instance A
-    let problem = SourceProblem::new(...);
-
-    // 2. Reduce A to B
-    let reduction = ReduceTo::<TargetProblem>::reduce_to(&problem);
-    let target = reduction.target_problem();
 
-    // 3. Solve B
-    let solver = TargetSolver::new();
-    let target_solution = solver.solve(target).unwrap();
-
-    // 4. Extract solution of A
-    let extracted = reduction.extract_solution(&target_solution);
-
-    // 5. Verify solution
-    assert!(problem.is_valid_solution(&extracted));
-}
-```
+See `rules/testing.md` for the full pattern. Test name: `test_<source>_to_<target>_closed_loop`.
 
 ## 3. Documentation
-Update `docs/paper/reductions.typ`:
+Update `docs/paper/reductions.typ` (see `rules/documentation.md` for the pattern):
 - Add theorem + proof sketch
-- Add code example (note feature requirements if any)
+- Add code example
 - Add to summary table with overhead and citation
 
 Citations must be verifiable. Use `[Folklore]` or `—` for trivial reductions.

.claude/rules/documentation.md

@@ -0,0 +1,40 @@
+---
+paths:
+  - "docs/paper/**/*.typ"
+---
+
+# Documentation Requirements
+
+The technical paper (`docs/paper/reductions.typ`) must include:
+
+1. **Table of Contents** - Auto-generated outline of all sections
+2. **Problem Data Structures** - Rust struct with fields in a code block
+3. **Reduction Examples** - Minimal working example showing reduce → solve → extract
+
+## Pattern
+
+```typst
+#definition("Problem Name")[
+  Mathematical definition...
+]
+
+// Rust data structure
+```rust
+pub struct ProblemName<W = i32> {
+    field1: Type1,
+    field2: Type2,
+}
+`` `
+
+#theorem[
+  *(Source → Target)* Reduction description...
+]
+
+// Minimal working example from closed-loop tests
+```rust
+let source = SourceProblem::new(...);
+let reduction = ReduceTo::<TargetProblem>::reduce_to(&source);
+let target = reduction.target_problem();
+// ... solve and extract
+`` `
+```

.claude/skills/issue-to-pr.md

@@ -62,7 +62,7 @@ Do NOT skip brainstorming. Do NOT write a plan without user discussion.
 
 ### 4. Write Plan
 
-After brainstorming concludes, write plan to `docs/plans/issue-<number>-<slug>.md`:
+After brainstorming concludes, write plan to `issue-<number>-<slug>.md` in the repo root:
 
 ```markdown
 # <Title from brainstorming>
@@ -91,7 +91,7 @@ Issue: #<number>
 git checkout -b issue-<number>-<slug>
 
 # Stage only the plan file
-git add docs/plans/issue-<number>-<slug>.md
+git add issue-<number>-<slug>.md
 
 # Commit
 git commit -m "Add plan for #<number>: <title>"

.github/workflows/ci.yml

@@ -49,13 +49,16 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: llvm-tools-preview
       - uses: Swatinem/rust-cache@v2
-      - name: Install tarpaulin
-        run: cargo install cargo-tarpaulin
+      - name: Install cargo-llvm-cov
+        uses: taiki-e/install-action@cargo-llvm-cov
       - name: Generate coverage
-        run: cargo tarpaulin --skip-clean --ignore-tests --out xml
-      - name: Upload to Codecov
+        run: cargo llvm-cov --all-features --workspace --lcov --output-path lcov.info
+      - name: Upload to codecov.io
         uses: codecov/codecov-action@v4
         with:
-          files: cobertura.xml
-          fail_ci_if_error: false
+          files: lcov.info
+          fail_ci_if_error: false  # Don't fail CI if upload fails
+          token: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/coverage.yml

@@ -1,8 +1,12 @@
 # Rust
 /target/
+Cargo.lock
 **/*.rs.bk
 *.pdb
 
+# Developer-specific Claude Code settings
+.claude/settings.local.json
+
 # IDE
 .idea/
 .vscode/