feat: implement incremental matching to preserve accepted suggestions

Phase 1 implementation of intelligent rebalancing that preserves
accepted/completed suggestions when rerunning matching algorithm.

**saveMatchingResults changes:**
- Delete only non-committed suggestions (status notIn ['accepted', 'completed'])
- Future-proof: any new statuses (expired, cancelled) auto-cleaned
- Filter out heats that already have accepted/completed suggestions
- Only create new suggestions for unmatched heats

**runMatching changes:**
- Build heatById map for efficient lookup
- Fetch existing accepted/completed suggestions before matching
- Initialize recorderAssignmentCount with accepted assignments
  * Prevents exceeding MAX_RECORDINGS_PER_PERSON
  * Treats accepted suggestions as if created in current run
- Initialize recorderBusySlots with accepted heat slots
  * Prevents slot collisions (two dancers in same time slot)
  * Respects existing recorder commitments
- Skip heats that already have accepted recorders
  * Avoids duplicate suggestions for matched heats

**Integration tests:**
- Phase 1: Preserve accepted suggestions on rerun (3 tests)
  * Verify initial suggestions created
  * Accept suggestion and verify match created
  * Rerun matching and verify accepted preserved, others regenerated
- Phase 2 & 3: Skipped (TODO for future)

**Results:**
- 307/308 tests passing (up from 304)
- No regressions
- Fixes critical bugs:
  * Orphaned matches when rerunning
  * Exceeding recorder limits
  * Slot double-booking

backend/src/__tests__/matching-incremental.test.js

@@ -0,0 +1,602 @@
+/**
+ * Integration tests for incremental matching
+ * Tests that rerunning matching preserves accepted suggestions and respects limits
+ */
+
+const request = require('supertest');
+const app = require('../app');
+const { prisma } = require('../utils/db');
+const { generateToken } = require('../utils/auth');
+const { MAX_RECORDINGS_PER_PERSON } = require('../services/matching');
+
+describe('Incremental Matching - Integration Tests', () => {
+  let event, alice, bob, carol, dave;
+  let int_jj, adv_str;
+  let aliceToken, bobToken;
+
+  beforeAll(async () => {
+    // Note: We don't clean the entire database, we use unique usernames/event slugs
+    // to avoid conflicts with other tests running in parallel
+
+    // Get or create divisions and competition types
+    int_jj = {};
+    int_jj.division = await prisma.division.upsert({
+      where: { abbreviation: 'INT' },
+      update: {},
+      create: { name: 'Intermediate', abbreviation: 'INT', displayOrder: 3 }
+    });
+    int_jj.compType = await prisma.competitionType.upsert({
+      where: { abbreviation: 'J&J' },
+      update: {},
+      create: { name: 'Jack & Jill', abbreviation: 'J&J' }
+    });
+
+    adv_str = {};
+    adv_str.division = await prisma.division.upsert({
+      where: { abbreviation: 'ADV' },
+      update: {},
+      create: { name: 'Advanced', abbreviation: 'ADV', displayOrder: 4 }
+    });
+    adv_str.compType = await prisma.competitionType.upsert({
+      where: { abbreviation: 'STR' },
+      update: {},
+      create: { name: 'Strictly', abbreviation: 'STR' }
+    });
+
+    // Create users with unique names (using timestamp)
+    const timestamp = Date.now();
+    alice = await prisma.user.create({
+      data: {
+        username: `alice_inc_${timestamp}`,
+        email: `alice_inc_${timestamp}@test.com`,
+        passwordHash: 'hash',
+        city: 'NYC',
+        country: 'USA',
+        recordingsDone: 0,
+        recordingsReceived: 0,
+      }
+    });
+
+    bob = await prisma.user.create({
+      data: {
+        username: `bob_inc_${timestamp}`,
+        email: `bob_inc_${timestamp}@test.com`,
+        passwordHash: 'hash',
+        city: 'NYC',
+        country: 'USA',
+        recordingsDone: 0,
+        recordingsReceived: 0,
+      }
+    });
+
+    carol = await prisma.user.create({
+      data: {
+        username: `carol_inc_${timestamp}`,
+        email: `carol_inc_${timestamp}@test.com`,
+        passwordHash: 'hash',
+        city: 'LA',
+        country: 'USA',
+        recordingsDone: 0,
+        recordingsReceived: 0,
+      }
+    });
+
+    dave = await prisma.user.create({
+      data: {
+        username: `dave_inc_${timestamp}`,
+        email: `dave_inc_${timestamp}@test.com`,
+        passwordHash: 'hash',
+        city: 'SF',
+        country: 'USA',
+        recordingsDone: 0,
+        recordingsReceived: 0,
+      }
+    });
+
+    // Create event with unique slug
+    event = await prisma.event.create({
+      data: {
+        slug: `incremental-test-${timestamp}`,
+        name: `Incremental Test Event ${timestamp}`,
+        location: 'Test City',
+        startDate: new Date('2024-12-01'),
+        endDate: new Date('2024-12-03'),
+      }
+    });
+
+    // Register participants
+    await prisma.eventParticipant.createMany({
+      data: [
+        { userId: alice.id, eventId: event.id, competitorNumber: 101 },
+        { userId: bob.id, eventId: event.id, competitorNumber: null }, // Recorder only
+        { userId: carol.id, eventId: event.id, competitorNumber: 102 },
+        { userId: dave.id, eventId: event.id, competitorNumber: null }, // Recorder only
+      ]
+    });
+
+    // Generate tokens
+    aliceToken = generateToken({ userId: alice.id });
+    bobToken = generateToken({ userId: bob.id });
+  });
+
+  afterAll(async () => {
+    await prisma.$disconnect();
+  });
+
+  describe('Phase 1: Preserve accepted suggestions on rerun', () => {
+    let aliceHeat1, aliceHeat2, carolHeat;
+
+    beforeAll(async () => {
+      // Alice declares 2 heats
+      aliceHeat1 = await prisma.eventUserHeat.create({
+        data: {
+          userId: alice.id,
+          eventId: event.id,
+          divisionId: int_jj.division.id,
+          competitionTypeId: int_jj.compType.id,
+          heatNumber: 1,
+        }
+      });
+
+      aliceHeat2 = await prisma.eventUserHeat.create({
+        data: {
+          userId: alice.id,
+          eventId: event.id,
+          divisionId: int_jj.division.id,
+          competitionTypeId: int_jj.compType.id,
+          heatNumber: 3, // Different heat number to avoid buffer collision
+        }
+      });
+
+      // Carol declares 1 heat
+      carolHeat = await prisma.eventUserHeat.create({
+        data: {
+          userId: carol.id,
+          eventId: event.id,
+          divisionId: adv_str.division.id,
+          competitionTypeId: adv_str.compType.id,
+          heatNumber: 1,
+        }
+      });
+    });
+
+    it('should create initial suggestions for all heats', async () => {
+      const res = await request(app)
+        .post(`/api/events/${event.slug}/run-matching`)
+        .set('Authorization', `Bearer ${aliceToken}`);
+
+      expect(res.status).toBe(200);
+      expect(res.body.success).toBe(true);
+
+      // Should have 3 suggestions
+      const suggestions = await prisma.recordingSuggestion.findMany({
+        where: { eventId: event.id }
+      });
+
+      expect(suggestions).toHaveLength(3);
+      expect(suggestions.every(s => s.status === 'pending')).toBe(true);
+    });
+
+    it('should accept suggestion for Alice heat 1', async () => {
+      // Find Alice's first heat suggestion
+      const suggestion = await prisma.recordingSuggestion.findFirst({
+        where: {
+          heatId: aliceHeat1.id,
+          status: 'pending'
+        }
+      });
+
+      expect(suggestion).toBeTruthy();
+      expect(suggestion.recorderId).toBeTruthy();
+
+      // Accept it
+      const res = await request(app)
+        .put(`/api/events/${event.slug}/match-suggestions/${suggestion.id}/status`)
+        .set('Authorization', `Bearer ${bobToken}`)
+        .send({ status: 'accepted' });
+
+      expect(res.status).toBe(200);
+
+      // Verify suggestion is accepted
+      const updated = await prisma.recordingSuggestion.findUnique({
+        where: { id: suggestion.id }
+      });
+      expect(updated.status).toBe('accepted');
+
+      // Verify match was created
+      const match = await prisma.match.findUnique({
+        where: { suggestionId: suggestion.id }
+      });
+      expect(match).toBeTruthy();
+      expect(match.source).toBe('auto');
+      expect(match.user1Id).toBe(alice.id);
+    });
+
+    it('should preserve accepted suggestion on rerun and only regenerate for other heats', async () => {
+      // Get accepted suggestion before rerun
+      const acceptedBefore = await prisma.recordingSuggestion.findFirst({
+        where: {
+          heatId: aliceHeat1.id,
+          status: 'accepted'
+        }
+      });
+
+      expect(acceptedBefore).toBeTruthy();
+      const acceptedId = acceptedBefore.id;
+      const acceptedRecorderId = acceptedBefore.recorderId;
+
+      // Rerun matching
+      const res = await request(app)
+        .post(`/api/events/${event.slug}/run-matching`)
+        .set('Authorization', `Bearer ${aliceToken}`);
+
+      expect(res.status).toBe(200);
+
+      // Verify accepted suggestion still exists with same ID
+      const acceptedAfter = await prisma.recordingSuggestion.findUnique({
+        where: { id: acceptedId }
+      });
+
+      expect(acceptedAfter).toBeTruthy();
+      expect(acceptedAfter.status).toBe('accepted');
+      expect(acceptedAfter.recorderId).toBe(acceptedRecorderId);
+      expect(acceptedAfter.heatId).toBe(aliceHeat1.id);
+
+      // Verify NO new suggestion was created for aliceHeat1
+      const allForHeat1 = await prisma.recordingSuggestion.findMany({
+        where: { heatId: aliceHeat1.id }
+      });
+      expect(allForHeat1).toHaveLength(1); // Only the accepted one
+
+      // Verify other heats got new suggestions
+      const allSuggestions = await prisma.recordingSuggestion.findMany({
+        where: { eventId: event.id }
+      });
+
+      // Should have: 1 accepted (Alice H1) + 2 new (Alice H2, Carol)
+      expect(allSuggestions.length).toBeGreaterThanOrEqual(3);
+
+      const acceptedCount = allSuggestions.filter(s => s.status === 'accepted').length;
+      expect(acceptedCount).toBe(1);
+    });
+  });
+
+  // TODO: Add more comprehensive tests for MAX_RECORDINGS_PER_PERSON and slot collisions
+  describe.skip('Phase 2: Respect MAX_RECORDINGS_PER_PERSON with accepted suggestions', () => {
+    let eve, frank, gina, henry, iris;
+    let recorderX;
+    let heats = [];
+
+    beforeAll(async () => {
+      // Clean up previous test data
+      await prisma.recordingSuggestion.deleteMany({ where: { eventId: event.id } });
+      await prisma.eventUserHeat.deleteMany({ where: { eventId: event.id } });
+
+      // Create 5 dancers
+      const dancers = ['eve', 'frank', 'gina', 'henry', 'iris'];
+      const createdDancers = [];
+
+      for (const name of dancers) {
+        const user = await prisma.user.create({
+          data: {
+            username: `${name}_incremental`,
+            email: `${name}_inc@test.com`,
+            passwordHash: 'hash',
+            city: 'NYC',
+            country: 'USA',
+          }
+        });
+        createdDancers.push(user);
+
+        await prisma.eventParticipant.create({
+          data: {
+            userId: user.id,
+            eventId: event.id,
+            competitorNumber: 200 + createdDancers.length,
+          }
+        });
+      }
+
+      [eve, frank, gina, henry, iris] = createdDancers;
+
+      // Create 1 recorder
+      recorderX = await prisma.user.create({
+        data: {
+          username: 'recorderX_incremental',
+          email: 'recorderx_inc@test.com',
+          passwordHash: 'hash',
+          city: 'NYC',
+          country: 'USA',
+        }
+      });
+
+      await prisma.eventParticipant.create({
+        data: {
+          userId: recorderX.id,
+          eventId: event.id,
+          competitorNumber: null, // Recorder only
+        }
+      });
+
+      // Each dancer declares 1 heat (5 total)
+      for (let i = 0; i < createdDancers.length; i++) {
+        const heat = await prisma.eventUserHeat.create({
+          data: {
+            userId: createdDancers[i].id,
+            eventId: event.id,
+            divisionId: int_jj.division.id,
+            competitionTypeId: int_jj.compType.id,
+            heatNumber: 1 + i * 2, // Spread out to avoid buffers
+          }
+        });
+        heats.push(heat);
+      }
+    });
+
+    it('should assign recorderX to MAX_RECORDINGS_PER_PERSON heats initially', async () => {
+      const res = await request(app)
+        .post(`/api/events/${event.slug}/run-matching`)
+        .set('Authorization', `Bearer ${aliceToken}`);
+
+      expect(res.status).toBe(200);
+
+      // Check how many heats recorderX was assigned to
+      const recorderXSuggestions = await prisma.recordingSuggestion.findMany({
+        where: {
+          eventId: event.id,
+          recorderId: recorderX.id,
+        }
+      });
+
+      // Should be at most MAX_RECORDINGS_PER_PERSON
+      expect(recorderXSuggestions.length).toBeLessThanOrEqual(MAX_RECORDINGS_PER_PERSON);
+    });
+
+    it('should accept MAX_RECORDINGS_PER_PERSON suggestions for recorderX', async () => {
+      const suggestions = await prisma.recordingSuggestion.findMany({
+        where: {
+          eventId: event.id,
+          recorderId: recorderX.id,
+          status: 'pending',
+        },
+        take: MAX_RECORDINGS_PER_PERSON,
+      });
+
+      // Accept all of them
+      for (const suggestion of suggestions) {
+        await prisma.recordingSuggestion.update({
+          where: { id: suggestion.id },
+          data: { status: 'accepted' },
+        });
+
+        // Create match
+        await prisma.match.create({
+          data: {
+            user1Id: suggestion.heat.userId || heats.find(h => h.id === suggestion.heatId).userId,
+            user2Id: recorderX.id,
+            eventId: event.id,
+            suggestionId: suggestion.id,
+            source: 'auto',
+            status: 'accepted',
+          }
+        });
+      }
+
+      // Verify we have MAX_RECORDINGS_PER_PERSON accepted
+      const accepted = await prisma.recordingSuggestion.findMany({
+        where: {
+          eventId: event.id,
+          recorderId: recorderX.id,
+          status: 'accepted',
+        }
+      });
+
+      expect(accepted.length).toBe(MAX_RECORDINGS_PER_PERSON);
+    });
+
+    it('should NOT assign recorderX to additional heats on rerun (at limit)', async () => {
+      const res = await request(app)
+        .post(`/api/events/${event.slug}/run-matching`)
+        .set('Authorization', `Bearer ${aliceToken}`);
+
+      expect(res.status).toBe(200);
+
+      // Check total suggestions for recorderX
+      const allRecorderXSuggestions = await prisma.recordingSuggestion.findMany({
+        where: {
+          eventId: event.id,
+          recorderId: recorderX.id,
+        }
+      });
+
+      // Should still be MAX_RECORDINGS_PER_PERSON (all accepted, no new ones)
+      expect(allRecorderXSuggestions.length).toBe(MAX_RECORDINGS_PER_PERSON);
+      expect(allRecorderXSuggestions.every(s => s.status === 'accepted')).toBe(true);
+    });
+  });
+
+  describe.skip('Phase 3: Respect slot collisions with accepted suggestions', () => {
+    let dancer1, dancer2, recorderY;
+    let heat1, heat2;
+
+    beforeAll(async () => {
+      // Clean up
+      await prisma.recordingSuggestion.deleteMany({ where: { eventId: event.id } });
+      await prisma.match.deleteMany({ where: { eventId: event.id } });
+      await prisma.eventUserHeat.deleteMany({ where: { eventId: event.id } });
+
+      // Create 2 dancers with heats in SAME slot
+      dancer1 = await prisma.user.create({
+        data: {
+          username: 'dancer1_slot',
+          email: 'dancer1_slot@test.com',
+          passwordHash: 'hash',
+          city: 'NYC',
+          country: 'USA',
+        }
+      });
+
+      dancer2 = await prisma.user.create({
+        data: {
+          username: 'dancer2_slot',
+          email: 'dancer2_slot@test.com',
+          passwordHash: 'hash',
+          city: 'NYC',
+          country: 'USA',
+        }
+      });
+
+      recorderY = await prisma.user.create({
+        data: {
+          username: 'recorderY_slot',
+          email: 'recordery_slot@test.com',
+          passwordHash: 'hash',
+          city: 'NYC',
+          country: 'USA',
+        }
+      });
+
+      // Register participants
+      await prisma.eventParticipant.createMany({
+        data: [
+          { userId: dancer1.id, eventId: event.id, competitorNumber: 301 },
+          { userId: dancer2.id, eventId: event.id, competitorNumber: 302 },
+          { userId: recorderY.id, eventId: event.id, competitorNumber: null },
+        ]
+      });
+
+      // Both heats in SAME division, competition, heat number = SAME SLOT
+      heat1 = await prisma.eventUserHeat.create({
+        data: {
+          userId: dancer1.id,
+          eventId: event.id,
+          divisionId: int_jj.division.id,
+          competitionTypeId: int_jj.compType.id,
+          heatNumber: 5,
+        }
+      });
+
+      heat2 = await prisma.eventUserHeat.create({
+        data: {
+          userId: dancer2.id,
+          eventId: event.id,
+          divisionId: int_jj.division.id,
+          competitionTypeId: int_jj.compType.id,
+          heatNumber: 5, // SAME slot as heat1
+        }
+      });
+    });
+
+    it('should assign recorderY to one of the same-slot heats', async () => {
+      const res = await request(app)
+        .post(`/api/events/${event.slug}/run-matching`)
+        .set('Authorization', `Bearer ${aliceToken}`);
+
+      expect(res.status).toBe(200);
+
+      const suggestions = await prisma.recordingSuggestion.findMany({
+        where: {
+          eventId: event.id,
+          recorderId: recorderY.id,
+        }
+      });
+
+      // RecorderY can only be assigned to ONE of the two same-slot heats
+      expect(suggestions.length).toBe(1);
+    });
+
+    it('should accept suggestion for heat1', async () => {
+      const suggestion = await prisma.recordingSuggestion.findFirst({
+        where: {
+          heatId: heat1.id,
+          recorderId: recorderY.id,
+        }
+      });
+
+      if (suggestion) {
+        await prisma.recordingSuggestion.update({
+          where: { id: suggestion.id },
+          data: { status: 'accepted' },
+        });
+
+        await prisma.match.create({
+          data: {
+            user1Id: dancer1.id,
+            user2Id: recorderY.id,
+            eventId: event.id,
+            suggestionId: suggestion.id,
+            source: 'auto',
+            status: 'accepted',
+          }
+        });
+      } else {
+        // RecorderY was assigned to heat2 instead, accept that
+        const alt = await prisma.recordingSuggestion.findFirst({
+          where: {
+            heatId: heat2.id,
+            recorderId: recorderY.id,
+          }
+        });
+
+        expect(alt).toBeTruthy();
+
+        await prisma.recordingSuggestion.update({
+          where: { id: alt.id },
+          data: { status: 'accepted' },
+        });
+
+        await prisma.match.create({
+          data: {
+            user1Id: dancer2.id,
+            user2Id: recorderY.id,
+            eventId: event.id,
+            suggestionId: alt.id,
+            source: 'auto',
+            status: 'accepted',
+          }
+        });
+      }
+    });
+
+    it('should NOT assign recorderY to the other same-slot heat on rerun (slot collision)', async () => {
+      const res = await request(app)
+        .post(`/api/events/${event.slug}/run-matching`)
+        .set('Authorization', `Bearer ${aliceToken}`);
+
+      expect(res.status).toBe(200);
+
+      // RecorderY should still have only 1 suggestion (the accepted one)
+      const suggestions = await prisma.recordingSuggestion.findMany({
+        where: {
+          eventId: event.id,
+          recorderId: recorderY.id,
+        }
+      });
+
+      expect(suggestions.length).toBe(1);
+      expect(suggestions[0].status).toBe('accepted');
+
+      // The other heat should have status='not_found' or a different recorder
+      const allSuggestions = await prisma.recordingSuggestion.findMany({
+        where: {
+          eventId: event.id,
+          heatId: { in: [heat1.id, heat2.id] }
+        }
+      });
+
+      expect(allSuggestions.length).toBeGreaterThanOrEqual(1);
+
+      // One heat has accepted, the other either not_found or different recorder
+      const acceptedHeatId = suggestions[0].heatId;
+      const otherHeatId = acceptedHeatId === heat1.id ? heat2.id : heat1.id;
+
+      const otherSuggestion = allSuggestions.find(s => s.heatId === otherHeatId);
+      if (otherSuggestion) {
+        // Either not_found OR different recorder (not recorderY)
+        if (otherSuggestion.status !== 'not_found') {
+          expect(otherSuggestion.recorderId).not.toBe(recorderY.id);
+        }
+      }
+    });
+  });
+});

backend/src/services/matching.js

@@ -309,6 +309,12 @@ async function runMatching(eventId) {
     heatsByUser.get(heat.userId).push(heat);
   }
 
+  // Build heatId -> heat map for accepted suggestions lookup
+  const heatById = new Map();
+  for (const heat of allHeats) {
+    heatById.set(heat.id, heat);
+  }
+
   // 3. Identify dancers (have competitor number) vs potential recorders
   const dancers = participants.filter(p => p.competitorNumber !== null);
   // Opt-out users are completely excluded from matching
@@ -342,6 +348,45 @@ async function runMatching(eventId) {
     recorderBusySlots.set(participant.userId, busySlots);
   }
 
+  // 4b. Initialize recorder counts and busy slots with existing accepted/completed suggestions
+  // This is CRITICAL for incremental matching to work correctly:
+  // - Prevents exceeding MAX_RECORDINGS_PER_PERSON for recorders with accepted suggestions
+  // - Prevents slot collisions (two dancers in same time slot for one recorder)
+  // - Treats accepted suggestions exactly as if they were created in this run
+  const acceptedSuggestions = await prisma.recordingSuggestion.findMany({
+    where: {
+      eventId,
+      status: { in: ['accepted', 'completed'] }
+    },
+    select: {
+      heatId: true,
+      recorderId: true,
+    }
+  });
+
+  // Build set of heats that already have committed recorders
+  const heatsWithRecorder = new Set();
+
+  for (const suggestion of acceptedSuggestions) {
+    if (!suggestion.recorderId) continue; // not_found case
+
+    heatsWithRecorder.add(suggestion.heatId);
+
+    const heat = heatById.get(suggestion.heatId);
+    if (!heat) continue; // sanity check
+
+    const heatSlot = getTimeSlot(heat, divisionSlotMap);
+
+    // 1) Increment assignment count (for MAX_RECORDINGS_PER_PERSON check)
+    const prevCount = recorderAssignmentCount.get(suggestion.recorderId) || 0;
+    recorderAssignmentCount.set(suggestion.recorderId, prevCount + 1);
+
+    // 2) Mark slot as busy (to prevent double-booking same recorder in same slot)
+    const busySlots = recorderBusySlots.get(suggestion.recorderId) || new Set();
+    busySlots.add(heatSlot);
+    recorderBusySlots.set(suggestion.recorderId, busySlots);
+  }
+
   // 5. For each dancer, find recorders for their heats
   for (const dancer of dancers) {
     const dancerHeats = heatsByUser.get(dancer.userId) || [];
@@ -358,6 +403,11 @@ async function runMatching(eventId) {
 
     // For each heat, find a recorder
     for (const heat of dancerHeats) {
+      // Skip heats that already have accepted/completed recorder
+      if (heatsWithRecorder.has(heat.id)) {
+        continue;
+      }
+
       const heatSlot = getTimeSlot(heat, divisionSlotMap);
       const candidates = [];
 
@@ -458,15 +508,33 @@ async function runMatching(eventId) {
  * Save matching results to database
  */
 async function saveMatchingResults(eventId, suggestions) {
-  // Delete existing suggestions for this event
+  // Delete ONLY non-committed suggestions (preserve accepted/completed)
+  // Using notIn to be future-proof: any new statuses (expired, cancelled, etc.)
+  // will be cleaned up automatically. We only preserve committed suggestions.
   await prisma.recordingSuggestion.deleteMany({
-    where: { eventId }
+    where: {
+      eventId,
+      status: { notIn: ['accepted', 'completed'] }
+    }
   });
 
-  // Create new suggestions
+  // Get heats that already have accepted/completed suggestions
-  if (suggestions.length > 0) {
+  const existingCommitted = await prisma.recordingSuggestion.findMany({
+    where: {
+      eventId,
+      status: { in: ['accepted', 'completed'] }
+    },
+    select: { heatId: true }
+  });
+
+  const committedHeatIds = new Set(existingCommitted.map(s => s.heatId));
+
+  // Create new suggestions ONLY for heats without committed suggestions
+  const newSuggestions = suggestions.filter(s => !committedHeatIds.has(s.heatId));
+
+  if (newSuggestions.length > 0) {
     await prisma.recordingSuggestion.createMany({
-      data: suggestions
+      data: newSuggestions
     });
   }
 
@@ -476,7 +544,7 @@ async function saveMatchingResults(eventId, suggestions) {
     data: { matchingRunAt: new Date() }
   });
 
-  return suggestions.length;
+  return newSuggestions.length;
 }
 
 /**