regression-suite-curator

def signal_history(test_id, window_months=12):
    """Returns the list of (sha, date, status) for this test across all runs."""
    return [
        {'sha': r['sha'], 'date': r['date'], 'status': r['tests'][test_id]}
        for r in load_ci_history(window_months)
        if test_id in r['tests']
    ]

def has_caught_regression(history):
    """A regression-catch is a transition from PASS → FAIL on a non-flake basis."""
    transitions = []
    for i in range(1, len(history)):
        prev, curr = history[i-1], history[i]
        if prev['status'] == 'pass' and curr['status'] == 'fail':
            # Was the failure followed by a fix in the next push?
            if i + 1 < len(history) and history[i+1]['status'] == 'pass':
                transitions.append((curr['sha'], curr['date']))
    return transitions

def keep_candidates(tests, history_index):
    keeps = []
    for t in tests:
        regressions_caught = has_caught_regression(history_index[t.id])
        unique_coverage = is_only_test_covering_paths(t)
        critical = t.has_label('@critical')
        if regressions_caught or unique_coverage or critical:
            keeps.append({
                'test': t.id,
                'reason': summarize(regressions_caught, unique_coverage, critical),
            })
    return keeps

def fold_candidates(tests):
    by_describe = defaultdict(list)
    for t in tests:
        by_describe[t.describe_path].append(t)
    folds = []
    for describe, peers in by_describe.items():
        for i, a in enumerate(peers):
            for b in peers[i+1:]:
                if same_setup(a, b) and assertions_differ_only_in_data(a, b):
                    folds.append({'into_one': [a.id, b.id], 'data_axis': diff_axis(a, b)})
    return folds

**Fold candidate:** `cart.spec.ts > addItem` — 4 tests can become 1
parameterized test:

```typescript
// Before (4 tests):
test('addItem accepts 1', () => { /* ... */ });
test('addItem accepts 5', () => { /* ... */ });
test('addItem accepts 100', () => { /* ... */ });
test('addItem rejects 0',  () => { /* ... */ });

// After (1 test):
test.each([
  { qty: 1,   expected: 'accepted' },
  { qty: 5,   expected: 'accepted' },
  { qty: 100, expected: 'accepted' },
  { qty: 0,   expected: 'rejected' },
])('addItem qty=$qty → $expected', ({ qty, expected }) => { /* ... */ });

Folding doesn't reduce coverage; it reduces test-code maintenance
surface.

## Mode 4 - Identify delete candidates

The hardest decision. The agent's rule: **all four conditions
must hold**:

1. Test has never caught a regression in the window (Mode 1).
2. Every source-path the test covers is also covered by ≥1 other
   test (the per-test coverage map confirms - see
   [`regression-suite-selector`](../skills/regression-suite-selector/SKILL.md)).
3. Not labeled `@critical` / `@regression-guard` / similar.
4. Not a test the test-code-critic / assertion-quality-reviewer
   has flagged for rewrite (those should be fixed, not deleted).

If any condition fails, the test is `keep` by default.

```python
def delete_candidates(tests, signal_history, coverage_map):
    deletes = []
    for t in tests:
        if has_caught_regression(signal_history[t.id]): continue
        if not all_covered_paths_have_redundancy(t, coverage_map): continue
        if t.has_critical_label(): continue
        if t.has_quality_flag(): continue
        deletes.append({
            'test': t.id,
            'reasoning': render_reasoning(t, signal_history, coverage_map),
        })
    return deletes

## Regression suite curation — Q2 2026 review

**Suite size before:** 4,127 tests
**Suite size after recommended changes:** 3,840 tests (-287)
**Coverage delta:** 0.0pp (verified — no source path loses coverage)
**Estimated CI time saved per run:** ~4.5 min (12% of current 38 min)

| Decision       | Count | LOC delta |
|----------------|------:|----------:|
| Keep (no change) | 3,762 |        0 |
| Fold (parameterize multiple → one) | 78 fold-groups |  -800 |
| Delete         |   209 |    -1,400 |

### Fold-groups (top 5 by impact)

| Fold-group                                | Tests folded | Net LOC saved |
|-------------------------------------------|-------------:|--------------:|
| `cart.spec.ts > addItem` (qty variants)   |      4       |        -45    |
| `parseDate.spec.ts > ISO 8601`            |      3       |        -38    |
| ...                                       |              |               |

### Deletes (high-confidence, all 4 conditions met)

(table with test ID + 4-condition checklist + redundancy evidence)

### Keep — for context

| Test                                         | Reason                                          |
|----------------------------------------------|-------------------------------------------------|
| `payment.spec.ts > stripe_3ds_failure`        | Caught regression `2026-02-12` (incident: #1234). |
| `auth.spec.ts > session_token_rotation`        | `@critical:auth-flow` label.                     |
| `parseDate.spec.ts > millennium_bug_edge`     | Only test covering pre-1970 date branch.         |

### Process

This is a recommendation, not an action. The next step is:

1. Reviewer skims the Delete and Fold tables (the Keep table is for
   audit transparency).
2. Reviewer rejects any rows with surprising recommendations.
3. The agent emits a PR with the accepted changes, one commit per
   fold-group, one squashed commit for deletes.
4. Run the full suite + a chaos test (per `qa-chaos`)
   against the post-curation suite; verify no new regressions.