# Algorithm Rewrite — Implementation Plan

> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.

**Goal:** Rewrite the synthesis generation pipeline: per-article LLM classify/summarize, source rotation, no rewrite pass, remove deprecated settings.

**Architecture:** Complete rewrite of `synthesis.rs` with a simpler two-phase pipeline. Phase 1: scrape personalized sources sequentially, classify/summarize each article with one LLM call. Phase 2: LLM search for gaps, scrape for validation. No batch classification, no rewrite pass.

**Tech Stack:** Rust (sqlx, reqwest, scraper), existing LLM providers

**Spec:** `docs/superpowers/specs/2026-03-25-algorithm-rewrite-design.md`
**Algorithm:** `docs/algorithm.md`

---

### Task 1: Migration — drop deprecated settings columns

**Files:**
- Create: `backend/migrations/20260325000018_drop_deprecated_settings.sql`
- Modify: `backend/src/models/settings.rs`
- Modify: `backend/src/db/settings.rs`
- Modify: `backend/src/services/prompts.rs` (test fixture)
- Modify: `CLAUDE.md`

- [ ] **Step 1: Create migration**

```sql
ALTER TABLE settings DROP COLUMN source_diversity_window;
ALTER TABLE settings DROP COLUMN use_llm_for_article_extraction;
```

- [ ] **Step 2: Remove from settings model**

In `models/settings.rs`, remove `source_diversity_window: i32` and `use_llm_for_article_extraction: bool` from `UserSettings`, `SettingsResponse`, `UpdateSettingsRequest`, `From` impl, `Default` impl, and validation.

- [ ] **Step 3: Remove from DB queries**

In `db/settings.rs`, remove both fields from `SettingsRow`, `TryFrom`, and both SQL queries (column lists, VALUES, RETURNING, ON CONFLICT SET, .bind() calls). Decrement $N placeholders carefully.

- [ ] **Step 4: Update test fixtures**

Remove both fields from `valid_request()` in settings tests and `test_settings()` in prompts tests. Remove any validation tests for these fields.

- [ ] **Step 5: Update CLAUDE.md migration count to 18**

- [ ] **Step 6: Verify + commit**

```bash
cd backend && cargo test --lib
git add backend/migrations/20260325000018_drop_deprecated_settings.sql backend/src/models/settings.rs backend/src/db/settings.rs backend/src/services/prompts.rs CLAUDE.md
git commit -m "feat: drop source_diversity_window and use_llm_for_article_extraction settings"
```

---

### Task 2: New prompt + schema for per-article classify/summarize

**Files:**
- Modify: `backend/src/services/prompts.rs`
- Modify: `backend/src/services/llm/schema.rs`

- [ ] **Step 1: Add `build_article_classify_prompt` to prompts.rs**

```rust
/// Build a prompt for per-article classification and summarization.
///
/// The LLM classifies the article into a category and generates a title + summary.
pub fn build_article_classify_prompt(
    title: &str,
    body_snippet: &str,
    categories: &[String], // includes "Autre"
) -> (String, String) {
    let system_prompt =
        "Tu es un assistant qui analyse des articles d'actualite. \
         Tu dois classer l'article dans une categorie et generer un titre et un resume. \
         Reponds uniquement au format JSON demande."
            .to_string();

    let categories_list = categories
        .iter()
        .map(|c| format!("- \"{}\"", c))
        .collect::<Vec<_>>()
        .join("\n");

    let user_prompt = format!(
        "Voici un article d'actualite.\n\n\
         Titre : {title}\n\n\
         Contenu (extrait) :\n{body}\n\n\
         Categories disponibles :\n{categories}\n\n\
         Classe cet article dans la categorie la plus appropriee.\n\
         Si aucune categorie ne correspond, utilise \"Autre\".\n\
         Genere un titre clair et un resume de 4 a 5 lignes.\n\
         Si le titre fourni est vide, genere un titre a partir du contenu.",
        title = if title.is_empty() { "(pas de titre)" } else { title },
        body = body_snippet,
        categories = categories_list,
    );

    (system_prompt, user_prompt)
}
```

- [ ] **Step 2: Add `build_article_classify_schema` to schema.rs**

```rust
/// Build a JSON Schema for per-article classification and summarization.
pub fn build_article_classify_schema() -> Value {
    serde_json::json!({
        "type": "object",
        "properties": {
            "title": { "type": "string", "description": "Article title" },
            "summary": { "type": "string", "description": "4-5 line summary of the article" },
            "category": { "type": "string", "description": "Category name from the provided list" }
        },
        "required": ["title", "summary", "category"],
        "additionalProperties": false
    })
}
```

- [ ] **Step 3: Add tests**

In prompts.rs tests:
```rust
    #[test]
    fn article_classify_prompt_includes_content() {
        let (sys, user) = build_article_classify_prompt("GPT-5 Released", "OpenAI released GPT-5", &["AI News".into(), "Autre".into()]);
        assert!(user.contains("GPT-5 Released"));
        assert!(user.contains("AI News"));
        assert!(user.contains("Autre"));
        assert!(sys.contains("classer"));
    }

    #[test]
    fn article_classify_prompt_handles_empty_title() {
        let (_, user) = build_article_classify_prompt("", "Some content", &["Tech".into(), "Autre".into()]);
        assert!(user.contains("(pas de titre)"));
    }
```

In schema.rs tests:
```rust
    #[test]
    fn article_classify_schema_has_all_fields() {
        let schema = build_article_classify_schema();
        let props = schema["properties"].as_object().unwrap();
        assert!(props.contains_key("title"));
        assert!(props.contains_key("summary"));
        assert!(props.contains_key("category"));
        assert_eq!(schema["additionalProperties"], false);
    }
```

- [ ] **Step 4: Verify + commit**

```bash
cd backend && cargo test --lib
git add backend/src/services/prompts.rs backend/src/services/llm/schema.rs
git commit -m "feat: add per-article classify/summarize prompt and schema"
```

---

### Task 3: Add `get_last_source_url` to article_history DB + simplify ScrapedContent

**Files:**
- Modify: `backend/src/db/article_history.rs`
- Modify: `backend/src/services/scraper.rs`

- [ ] **Step 1: Add `get_last_source_url`**

```rust
/// Get the source_url from the most recent 'used' entry for source rotation.
pub async fn get_last_source_url(
    pool: &PgPool,
    user_id: Uuid,
) -> Result<Option<String>, AppError> {
    let result = sqlx::query_scalar::<_, String>(
        "SELECT source_url FROM article_history WHERE user_id = $1 AND status = 'used' AND source_url IS NOT NULL ORDER BY created_at DESC LIMIT 1",
    )
    .bind(user_id)
    .fetch_optional(pool)
    .await?;
    Ok(result)
}
```

- [ ] **Step 2: Remove `head_html` from `ScrapedContent`**

In `scraper.rs`, remove `pub head_html: String` from the `ScrapedContent` struct. Remove the `head_html` extraction code in `scrape_url` (the block that finds `<head>...</head>`). Remove `head_html` from the return struct construction.

This will cause compilation errors in `source_scraper.rs` where `extract_article_links_with_llm` uses `content.head_html` — but source_scraper uses its own `extract_head_and_body` function, not `ScrapedContent.head_html`. Check and fix any references.

Also check `scrape_single_article_with_llm` in `synthesis.rs` — it references `content.head_html`. This function will be removed in Task 5, but it needs to compile now. Temporarily replace `content.head_html` with `String::new()` if needed, or remove the function now.

- [ ] **Step 3: Verify + commit**

```bash
cd backend && cargo test --lib
git add backend/src/db/article_history.rs backend/src/services/scraper.rs backend/src/services/synthesis.rs
git commit -m "feat: add get_last_source_url + remove head_html from ScrapedContent"
```

---

### Task 4: Remove old prompts, schemas, and unused code

**Files:**
- Modify: `backend/src/services/prompts.rs`
- Modify: `backend/src/services/llm/schema.rs`

- [ ] **Step 1: Remove old prompts from prompts.rs**

Remove these functions and their tests:
- `build_rewrite_prompt`
- `build_classification_prompt`
- `build_article_extraction_prompt`
- `build_link_extraction_prompt` — WAIT, this one stays (used by source_scraper LLM link extraction)

So remove: `build_rewrite_prompt`, `build_classification_prompt`, `build_article_extraction_prompt` and their tests.

Also remove the `build_search_prompt` parameter `category_gaps: Option<&[(String, i32)]>` — simplify back to always using `max_items_per_category`. Actually wait — Phase 2 still uses gap-aware search. Keep `category_gaps` parameter.

Remove `use crate::models::synthesis::ScrapedNewsItem;` if it's no longer needed (check if `build_classification_prompt` was the only user).

- [ ] **Step 2: Remove old schemas from schema.rs**

Remove: `build_classification_schema`, `build_article_extraction_schema`
Keep: `build_category_schema` (Phase 2 search), `build_link_extraction_schema` (source scraper), `build_article_classify_schema` (new)

- [ ] **Step 3: Verify + commit**

```bash
cd backend && cargo test --lib
git add backend/src/services/prompts.rs backend/src/services/llm/schema.rs
git commit -m "refactor: remove old classification, rewrite, and article extraction prompts/schemas"
```

---

### Task 5: Rewrite `synthesis.rs` — the core pipeline

**Files:**
- Modify: `backend/src/services/synthesis.rs`

This is the largest task. The entire `run_generation_inner` function is rewritten. Many helper functions are removed.

- [ ] **Step 1: Remove dead helper functions**

Delete these functions and their tests from `synthesis.rs`:
- `scrape_single_article_with_llm`
- `scrape_flat_urls`
- `scrape_articles`
- `filter_empty_scraped_articles`
- `build_rewrite_schema`
- `build_final_sections`
- `restore_scraped_urls`
- `parse_classification_response`
- `limit_articles_per_source`
- `dedup_by_url`
- `filter_homepage_urls`
- `SYNTHESIS_MIN_FILL_RATIO` constant
- All associated tests for these functions

Keep:
- `scrape_single_article` (used for Phase 1 per-article scraping)
- `emit_progress`
- `trace_article`
- `log_llm_call`
- `normalize_article_url` / `hash_article_url`
- `extract_domain`
- `resolve_provider_and_key` / `resolve_model`
- `check_rate_limit` / `get_user_rate_limiter`
- `sanitize_json_null_bytes`
- `sanitize_error_message`
- `get_iso_week_string`
- `parse_llm_output` (used in Phase 2)

- [ ] **Step 2: Add `rotate_sources` helper**

```rust
/// Rotate the sources list so that the source after the last-used source comes first.
fn rotate_sources(sources: Vec<Source>, last_source_url: Option<&str>) -> Vec<Source> {
    let Some(last_url) = last_source_url else {
        return sources;
    };

    let pos = sources.iter().position(|s| s.url == last_url);
    match pos {
        Some(idx) => {
            let next = (idx + 1) % sources.len();
            let mut rotated = sources[next..].to_vec();
            rotated.extend_from_slice(&sources[..next]);
            rotated
        }
        None => sources, // Last source not in list, don't rotate
    }
}
```

- [ ] **Step 3: Rewrite `run_generation_inner`**

Replace the entire function body with the new algorithm. The new flow:

```rust
async fn run_generation_inner(
    job_id: Uuid,
    state: &AppState,
    user_id: Uuid,
    tx: &watch::Sender<ProgressEvent>,
) -> Result<Uuid, AppError> {
    // === INITIALIZATION ===
    emit_progress(tx, "settings", "Chargement des parametres...", 5);
    let settings = db::settings::get_or_create_default(&state.pool, user_id).await?;

    // Cleanup
    if settings.article_history_days > 0 {
        db::article_history::cleanup_old(&state.pool, user_id, settings.article_history_days).await.unwrap_or(0);
        db::llm_call_log::truncate_old(&state.pool, user_id, settings.article_history_days).await.ok();
    }

    // Categories — if empty, default to just "Autre"
    let user_categories = if settings.categories.is_empty() {
        Vec::new()
    } else {
        settings.categories.clone()
    };
    let mut classification_categories = user_categories.clone();
    classification_categories.push("Autre".to_string());

    // Load sources
    emit_progress(tx, "sources", "Chargement des sources...", 10);
    let sources = db::sources::list_for_user(&state.pool, user_id).await?;

    // Resolve provider
    emit_progress(tx, "provider", "Configuration du fournisseur IA...", 12);
    let (provider_name, api_key) = resolve_provider_and_key(state, user_id, &settings).await?;
    let provider = create_provider(&provider_name, api_key)?;
    let model_research = if !settings.ai_model.is_empty() { settings.ai_model.clone() } else { resolve_model(state, &provider_name).await? };
    let model_writing = if !settings.ai_model_writing.is_empty() { settings.ai_model_writing.clone() } else { model_research.clone() };
    let user_rate_limiter = get_user_rate_limiter(state, &settings, user_id);

    // Tracking structures
    let mut article_scraped: HashMap<String, Vec<NewsItem>> = HashMap::new();
    let mut source_counts: HashMap<String, usize> = HashMap::new();
    let mut url_source: HashMap<String, String> = HashMap::new(); // url → source_url
    let mut filled_counts: HashMap<String, usize> = HashMap::new();
    let mut seen_urls: std::collections::HashSet<String> = std::collections::HashSet::new();
    let max_total = (user_categories.len() + 1) * settings.max_items_per_category as usize;
    let classify_schema = build_article_classify_schema();

    // === PHASE 1: Personalized Sources ===
    if !sources.is_empty() {
        emit_progress(tx, "sources_scrape", "Analyse des sources personnalisees...", 15);

        // 1a. Rotate sources
        let last_source = db::article_history::get_last_source_url(&state.pool, user_id).await.unwrap_or(None);
        let rotated_sources = rotate_sources(sources.clone(), last_source.as_deref());
        let max_sources = rotated_sources.len().min(10);
        let max_links = 10usize;

        let mut candidate_urls: Vec<(String, String)> = Vec::new(); // (article_url, source_url)

        for source in rotated_sources.iter().take(max_sources) {
            let links = if settings.use_llm_for_source_links {
                source_scraper::extract_article_links_with_llm(
                    &state.http_client, &source.url, max_links, &provider, &model_research,
                ).await
            } else {
                source_scraper::extract_article_links(
                    &state.http_client, &source.url, max_links,
                ).await
            };

            if let Ok(links) = links {
                for link in links {
                    if seen_urls.insert(link.to_lowercase()) {
                        candidate_urls.push((link, source.url.clone()));
                    }
                }
            }
        }

        // Filter against article history
        if settings.article_history_days > 0 && !candidate_urls.is_empty() {
            let hashes: Vec<String> = candidate_urls.iter().map(|(url, _)| hash_article_url(url)).collect();
            let existing = db::article_history::check_urls_exist(&state.pool, user_id, &hashes).await.unwrap_or_default();
            if !existing.is_empty() {
                // Trace filtered articles
                for (url, source_url) in &candidate_urls {
                    if existing.contains(&hash_article_url(url)) {
                        trace_article(&state.pool, user_id, job_id, url, "", "personalized_source", Some(source_url), None, None, "filtered_history", false).await;
                    }
                }
                candidate_urls.retain(|(url, _)| !existing.contains(&hash_article_url(url)));
            }
        }

        // Track url → source
        for (url, source_url) in &candidate_urls {
            url_source.insert(url.clone(), source_url.clone());
        }

        // 1b. Scrape, classify, summarize each article
        emit_progress(tx, "processing", "Traitement des articles...", 25);
        let total_candidates = candidate_urls.len();

        for (idx, (url, source_url)) in candidate_urls.into_iter().enumerate() {
            // Progress
            let pct = 25 + ((idx as u32 * 40) / total_candidates.max(1) as u32).min(40);
            emit_progress(tx, "processing", &format!("Article {}/{}...", idx + 1, total_candidates), pct as u8);

            // Check source limit
            let source_domain = extract_domain(&source_url).unwrap_or_default();
            let source_count = source_counts.get(&source_domain).copied().unwrap_or(0);
            if source_count >= settings.max_articles_per_source as usize {
                trace_article(&state.pool, user_id, job_id, &url, "", "personalized_source", Some(&source_url), None, None, "filtered_diversity", false).await;
                continue;
            }

            // Scrape
            let (body_text, page_title, final_url) = scrape_single_article(&state.http_client, &url, settings.max_age_days as i64).await;

            if body_text.trim().is_empty() {
                trace_article(&state.pool, user_id, job_id, &final_url, &page_title, "personalized_source", Some(&source_url), None, None, "filtered_empty", false).await;
                continue;
            }

            // LLM classify + summarize
            check_rate_limit(state, &user_rate_limiter, &provider_name)?;
            let body_snippet: String = body_text.chars().take(500).collect();
            let (class_sys, class_user) = prompts::build_article_classify_prompt(&page_title, &body_snippet, &classification_categories);

            let llm_start = std::time::Instant::now();
            let class_response = provider.call_llm(&model_research, &class_sys, &class_user, &classify_schema).await?;
            let llm_duration = llm_start.elapsed().as_millis() as u64;
            log_llm_call(&state.pool, user_id, job_id, "classify_summarize", &model_research, &class_sys, &class_user, &class_response, llm_duration).await;

            // Parse response
            let llm_title = class_response.get("title").and_then(|t| t.as_str()).unwrap_or(&page_title).to_string();
            let llm_summary = class_response.get("summary").and_then(|s| s.as_str()).unwrap_or("").to_string();
            let mut llm_category = class_response.get("category").and_then(|c| c.as_str()).unwrap_or("Autre").to_string();

            // Validate category — if not in list, use "Autre"
            if !classification_categories.iter().any(|c| c.to_lowercase() == llm_category.to_lowercase()) {
                llm_category = "Autre".to_string();
            }

            // Map category to key
            let cat_key = if llm_category == "Autre" {
                "category_autre".to_string()
            } else {
                user_categories.iter().position(|c| c.to_lowercase() == llm_category.to_lowercase())
                    .map(|i| format!("category_{}", i))
                    .unwrap_or_else(|| "category_autre".to_string())
            };

            // Check if category is full → overflow to "Autre"
            let cat_filled = filled_counts.get(&llm_category).copied().unwrap_or(0);
            let (final_cat_key, final_cat_name) = if cat_filled >= settings.max_items_per_category as usize && llm_category != "Autre" {
                let autre_filled = filled_counts.get("Autre").copied().unwrap_or(0);
                if autre_filled >= settings.max_items_per_category as usize {
                    // Both full — skip article
                    continue;
                }
                ("category_autre".to_string(), "Autre".to_string())
            } else {
                (cat_key, llm_category)
            };

            // Add article
            article_scraped.entry(final_cat_key).or_default().push(NewsItem {
                title: llm_title,
                url: final_url.clone(),
                summary: llm_summary,
            });
            *filled_counts.entry(final_cat_name).or_insert(0) += 1;
            *source_counts.entry(source_domain).or_insert(0) += 1;

            // Check if we've reached the maximum
            let total: usize = article_scraped.values().map(|v| v.len()).sum();
            if total >= max_total {
                break;
            }
        }
    }

    // === PHASE 2: Web Search Fallback ===
    let category_gaps: Vec<(String, i32)> = user_categories.iter().filter_map(|cat| {
        let filled = filled_counts.get(cat).copied().unwrap_or(0);
        let needed = (settings.max_items_per_category as usize).saturating_sub(filled);
        if needed > 0 { Some((cat.clone(), needed as i32)) } else { None }
    }).collect();

    if !category_gaps.is_empty() {
        emit_progress(tx, "search", "Recherche d'actualites complementaires...", 70);
        check_rate_limit(state, &user_rate_limiter, &provider_name)?;

        let search_schema = build_category_schema(&user_categories, settings.max_items_per_category);
        let current_date = Utc::now().format("%A %d %B %Y").to_string();
        let (sys_prompt, usr_prompt) = prompts::build_search_prompt(&settings, &sources, &current_date, &[], Some(&category_gaps));

        let llm_start = std::time::Instant::now();
        let raw_results = provider.call_llm(&model_research, &sys_prompt, &usr_prompt, &search_schema).await?;
        let llm_duration = llm_start.elapsed().as_millis() as u64;
        log_llm_call(&state.pool, user_id, job_id, "search", &model_research, &sys_prompt, &usr_prompt, &raw_results, llm_duration).await;

        // Parse and filter
        emit_progress(tx, "parsing", "Analyse des resultats...", 75);
        let parsed = parse_llm_output(&raw_results, &user_categories)?;

        // Filter: homepage, cross-phase dedup, url dedup, source limit, history
        let mut phase2_articles: Vec<(String, NewsItem)> = Vec::new(); // (cat_key, item)

        for (cat_key, items) in parsed {
            for item in items {
                let url_lower = item.url.to_lowercase();

                // Homepage filter
                if let Ok(parsed_url) = url::Url::parse(&item.url) {
                    let path = parsed_url.path();
                    if path.is_empty() || path == "/" {
                        trace_article(&state.pool, user_id, job_id, &item.url, &item.title, "web_search", None, None, None, "filtered_homepage", false).await;
                        continue;
                    }
                }

                // Cross-phase dedup
                if seen_urls.contains(&url_lower) {
                    trace_article(&state.pool, user_id, job_id, &item.url, &item.title, "web_search", None, None, None, "filtered_cross_phase_dedup", false).await;
                    continue;
                }

                // History dedup
                if settings.article_history_days > 0 {
                    let hash = hash_article_url(&item.url);
                    let exists = db::article_history::check_urls_exist(&state.pool, user_id, &[hash.clone()]).await.unwrap_or_default();
                    if exists.contains(&hash) {
                        trace_article(&state.pool, user_id, job_id, &item.url, &item.title, "web_search", None, None, None, "filtered_history", false).await;
                        continue;
                    }
                }

                // Source limit
                if let Some(domain) = extract_domain(&item.url) {
                    let count = source_counts.get(&domain).copied().unwrap_or(0);
                    if count >= settings.max_articles_per_source as usize {
                        trace_article(&state.pool, user_id, job_id, &item.url, &item.title, "web_search", None, None, None, "filtered_diversity", false).await;
                        continue;
                    }
                }

                seen_urls.insert(url_lower);
                phase2_articles.push((cat_key.clone(), item));
            }
        }

        // Scrape Phase 2 articles for validation
        emit_progress(tx, "scraping", "Verification des sources web...", 80);
        for (cat_key, item) in phase2_articles {
            let (body_text, _, final_url) = scrape_single_article(&state.http_client, &item.url, settings.max_age_days as i64).await;

            if body_text.trim().is_empty() {
                trace_article(&state.pool, user_id, job_id, &final_url, &item.title, "web_search", None, None, None, "filtered_empty", false).await;
                continue;
            }

            // Use the LLM-provided title and summary (Phase 2 summaries are final)
            article_scraped.entry(cat_key).or_default().push(NewsItem {
                title: item.title,
                url: final_url,
                summary: item.summary,
            });

            if let Some(domain) = extract_domain(&item.url) {
                *source_counts.entry(domain).or_insert(0) += 1;
            }
        }
    }

    // === SAVE ===
    if article_scraped.values().all(|items| items.is_empty()) {
        return Err(AppError::BadRequest("Aucun article valide trouve. Verifiez vos sources et categories.".into()));
    }

    emit_progress(tx, "saving", "Sauvegarde de la synthese...", 90);

    // Build final sections
    let mut final_sections: Vec<NewsSection> = Vec::new();
    for (i, cat_name) in user_categories.iter().enumerate() {
        let key = format!("category_{}", i);
        if let Some(items) = article_scraped.get(&key) {
            if !items.is_empty() {
                final_sections.push(NewsSection { title: cat_name.clone(), items: items.clone() });
            }
        }
    }
    if let Some(autre_items) = article_scraped.get("category_autre") {
        if !autre_items.is_empty() {
            final_sections.push(NewsSection { title: "Autre".to_string(), items: autre_items.clone() });
        }
    }

    let sections_json = serde_json::to_value(&final_sections).map_err(|e| AppError::Internal(anyhow::anyhow!("Failed to serialize: {}", e)))?;
    let sections_json = sanitize_json_null_bytes(sections_json);

    let synthesis = db::syntheses::create(&state.pool, user_id, &get_iso_week_string(Utc::now().date_naive()), &sections_json, job_id).await?;

    // Record used articles
    if settings.article_history_days > 0 {
        for section in &final_sections {
            for item in &section.items {
                let source_url = url_source.get(&item.url).map(|s| s.as_str());
                trace_article(&state.pool, user_id, job_id, &item.url, &item.title,
                    if source_url.is_some() { "personalized_source" } else { "web_search" },
                    source_url, Some(&section.title), Some(synthesis.id), "used", true).await;
            }
        }
    }

    Ok(synthesis.id)
}
```

- [ ] **Step 4: Add `rotate_sources` unit tests**

```rust
    #[test]
    fn rotate_sources_after_last_used() {
        // Create mock sources — need Source struct with url field
        // Test that rotation works correctly
    }
```

- [ ] **Step 5: Verify + commit**

```bash
cd backend && cargo test --lib
git add backend/src/services/synthesis.rs
git commit -m "feat: rewrite synthesis pipeline — per-article classify/summarize, no rewrite pass"
```

---

### Task 6: Frontend — remove deprecated settings

**Files:**
- Modify: `frontend/src/types.ts`
- Modify: `frontend/src/pages/Settings.tsx`
- Modify: `frontend/src/i18n/fr.ts`

- [ ] **Step 1: Remove fields from types**

Remove `source_diversity_window: number` and `use_llm_for_article_extraction: boolean` from `UserSettings` and `DEFAULT_SETTINGS`.

- [ ] **Step 2: Remove from Settings page**

Remove the diversity window number input and the LLM extraction checkbox from `Settings.tsx`.

- [ ] **Step 3: Remove i18n labels**

Remove `settings.diversityWindow` and `settings.useLlmForArticleExtraction` labels.

- [ ] **Step 4: Verify + commit**

```bash
cd frontend && npx tsc --noEmit && npx vitest run
git add frontend/src/types.ts frontend/src/pages/Settings.tsx frontend/src/i18n/fr.ts
git commit -m "feat: remove deprecated settings from frontend"
```

---

### Task 7: Update E2E test

**Files:**
- Modify: `e2e/tests/generation-live.spec.ts`

- [ ] **Step 1: Update settings payload**

Remove `source_diversity_window` and `use_llm_for_article_extraction` from the PUT settings body.

- [ ] **Step 2: Commit**

```bash
git add e2e/tests/generation-live.spec.ts
git commit -m "test: update E2E test for new pipeline (remove deprecated settings)"
```