diff --git a/solstone/apps/curation/copy.py b/solstone/apps/curation/copy.py
index d38b0569a..7bb29d08e 100644
--- a/solstone/apps/curation/copy.py
+++ b/solstone/apps/curation/copy.py
@@ -23,6 +23,15 @@ CUR_SPEAKER_BODY = (
 )
 CUR_SPEAKER_MERGE_ACTION = "review merge"
 CUR_SPEAKER_DISMISS_ACTION = "keep separate"
+CUR_SPEAKER_CANDIDATE_PAIR_BODY = (
+    "solstone found two speaker candidates that sound alike. merge them?"
+)
+CUR_SPEAKER_CANDIDATE_PAIR_MERGE_ACTION = "merge candidates"
+CUR_SPEAKER_CANDIDATE_PAIR_DISMISS_ACTION = "keep separate"
+CUR_SPEAKER_CANDIDATE_PAIR_SIMILARITY_LABEL = "cosine"
+CUR_SPEAKER_CANDIDATE_PAIR_INTERVALS_LABEL = "intervals"
+CUR_SPEAKER_CANDIDATE_PAIR_SOURCE_LABEL = "candidate A"
+CUR_SPEAKER_CANDIDATE_PAIR_TARGET_LABEL = "candidate B"
 CUR_EMPTY_STATE = (
     "nothing to review — solstone hasn't spotted new structure to suggest."
 )
diff --git a/solstone/apps/curation/routes.py b/solstone/apps/curation/routes.py
index e4926a7cb..9e41dbd16 100644
--- a/solstone/apps/curation/routes.py
+++ b/solstone/apps/curation/routes.py
@@ -17,20 +17,26 @@ from solstone.convey.reasons import (
     MISSING_REQUIRED_FIELD,
 )
 from solstone.convey.utils import error_response, respond_collection
-from solstone.think import speaker_review_candidates
+from solstone.think import (
+    speaker_candidate_pair_review_candidates,
+    speaker_review_candidates,
+)
 from solstone.think.curation import (
     KIND_ENTITY_AMBIGUITY,
     KIND_ENTITY_MERGE,
     KIND_FACET_CANDIDATE,
+    KIND_SPEAKER_CANDIDATE_PAIR,
     KIND_SPEAKER_NAME_VARIANT,
     accept_entity_candidate,
     accept_entity_candidate_batch,
     accept_facet_candidate,
     accept_speaker_candidate,
+    accept_speaker_candidate_pair,
     dismiss_entity_candidate,
     dismiss_entity_candidate_batch,
     dismiss_facet_candidate,
     dismiss_speaker_candidate,
+    dismiss_speaker_candidate_pair,
     load_open_items,
     merge_preview_fields,
 )
@@ -68,6 +74,11 @@ def api_state() -> Response | tuple[Response, int]:
                 for item in items
                 if item.kind == KIND_SPEAKER_NAME_VARIANT
             ],
+            "speaker_candidate_pair_items": [
+                item.to_dict()
+                for item in items
+                if item.kind == KIND_SPEAKER_CANDIDATE_PAIR
+            ],
             "copy": curation_copy.curation_copy_payload(),
         }
     )
@@ -114,6 +125,28 @@ def _speaker_payload(
     return key, source_id, target_id
 
 
+def _speaker_candidate_pair_payload(
+    data: dict[str, Any],
+) -> tuple[str, str, str] | tuple[Response, int]:
+    try:
+        key = str(_required(data, "key"))
+        anchor_a = str(_required(data, "anchor_a"))
+        anchor_b = str(_required(data, "anchor_b"))
+    except KeyError as exc:
+        return _missing_field(str(exc.args[0]))
+
+    expected = speaker_candidate_pair_review_candidates.candidate_key(
+        anchor_a,
+        anchor_b,
+    )
+    if key != expected:
+        return error_response(
+            INVALID_REQUEST_VALUE,
+            detail="key does not match anchor_a/anchor_b",
+        )
+    return key, anchor_a, anchor_b
+
+
 @curation_bp.route("/api/facet/candidates")
 def facet_candidates() -> Response:
     return respond_collection(load_candidates())
@@ -219,6 +252,38 @@ def dismiss_speaker() -> Response | tuple[Response, int]:
     return _result_response(result)
 
 
+@curation_bp.post("/api/speaker-candidate-pair/accept")
+def accept_speaker_candidate_pair_route() -> Response | tuple[Response, int]:
+    payload = _speaker_candidate_pair_payload(_json_body())
+    if not isinstance(payload, tuple) or len(payload) != 3:
+        return payload
+    _, anchor_a, anchor_b = payload
+
+    try:
+        result = accept_speaker_candidate_pair(anchor_a, anchor_b)
+    except LockTimeout:
+        return error_response(
+            ENTITY_BUSY, detail="speaker suggestions are busy; try again"
+        )
+    return _result_response(result)
+
+
+@curation_bp.post("/api/speaker-candidate-pair/dismiss")
+def dismiss_speaker_candidate_pair_route() -> Response | tuple[Response, int]:
+    payload = _speaker_candidate_pair_payload(_json_body())
+    if not isinstance(payload, tuple) or len(payload) != 3:
+        return payload
+    _, anchor_a, anchor_b = payload
+
+    try:
+        result = dismiss_speaker_candidate_pair(anchor_a, anchor_b)
+    except LockTimeout:
+        return error_response(
+            ENTITY_BUSY, detail="speaker suggestions are busy; try again"
+        )
+    return _result_response(result)
+
+
 @curation_bp.post("/api/entity/accept")
 def accept_entity() -> Response | tuple[Response, int]:
     data = _json_body()
diff --git a/solstone/apps/curation/tests/test_copy.py b/solstone/apps/curation/tests/test_copy.py
index 55f7224c5..c1b83741b 100644
--- a/solstone/apps/curation/tests/test_copy.py
+++ b/solstone/apps/curation/tests/test_copy.py
@@ -84,6 +84,15 @@ def test_curation_copy_literals_are_folded_byte_for_byte():
         ),
         "CUR_SPEAKER_MERGE_ACTION": "review merge",
         "CUR_SPEAKER_DISMISS_ACTION": "keep separate",
+        "CUR_SPEAKER_CANDIDATE_PAIR_BODY": (
+            "solstone found two speaker candidates that sound alike. merge them?"
+        ),
+        "CUR_SPEAKER_CANDIDATE_PAIR_MERGE_ACTION": "merge candidates",
+        "CUR_SPEAKER_CANDIDATE_PAIR_DISMISS_ACTION": "keep separate",
+        "CUR_SPEAKER_CANDIDATE_PAIR_SIMILARITY_LABEL": "cosine",
+        "CUR_SPEAKER_CANDIDATE_PAIR_INTERVALS_LABEL": "intervals",
+        "CUR_SPEAKER_CANDIDATE_PAIR_SOURCE_LABEL": "candidate A",
+        "CUR_SPEAKER_CANDIDATE_PAIR_TARGET_LABEL": "candidate B",
         "CUR_EMPTY_STATE": (
             "nothing to review — solstone hasn't spotted new structure to suggest."
         ),
diff --git a/solstone/apps/curation/tests/test_routes.py b/solstone/apps/curation/tests/test_routes.py
index 73da4cc60..2bc02ca60 100644
--- a/solstone/apps/curation/tests/test_routes.py
+++ b/solstone/apps/curation/tests/test_routes.py
@@ -26,6 +26,15 @@ from solstone.think.facet_review_candidates import (
 )
 from solstone.think.facet_review_candidates import record_facet_candidate
 from solstone.think.journal_io import LockTimeout
+from solstone.think.speaker_candidate_pair_review_candidates import (
+    candidate_key as pair_candidate_key,
+)
+from solstone.think.speaker_candidate_pair_review_candidates import (
+    load_candidates as load_pair_candidates,
+)
+from solstone.think.speaker_candidate_pair_review_candidates import (
+    record_candidate_pair,
+)
 from solstone.think.speaker_review_candidates import (
     candidate_key as speaker_candidate_key,
 )
@@ -150,6 +159,51 @@ def _speaker_payload(
     }
 
 
+def _pair_anchors() -> tuple[str, str]:
+    return (
+        '["20260101","090000_300","test","mic_audio",1]',
+        '["20260102","090000_300","test","mic_audio",2]',
+    )
+
+
+def _speaker_candidate_pair_payload(
+    anchor_a: str | None = None,
+    anchor_b: str | None = None,
+) -> dict[str, str]:
+    left, right = _pair_anchors()
+    anchor_a = anchor_a or left
+    anchor_b = anchor_b or right
+    return {
+        "key": pair_candidate_key(anchor_a, anchor_b),
+        "anchor_a": anchor_a,
+        "anchor_b": anchor_b,
+    }
+
+
+def _seed_speaker_candidate_pair() -> tuple[str, str]:
+    anchor_a, anchor_b = _pair_anchors()
+    sample = {
+        "day": "20260101",
+        "stream": "test",
+        "segment_key": "090000_300",
+        "source": "mic_audio",
+        "cluster_label": 1,
+        "audio_url": "/app/speakers/api/serve_audio/20260101/test/090000_300/mic_audio.flac",
+    }
+    record_candidate_pair(
+        source_anchor=anchor_a,
+        target_anchor=anchor_b,
+        source_anchors={anchor_a},
+        target_anchors={anchor_b},
+        similarity=0.62,
+        source_intervals=31,
+        target_intervals=35,
+        source_samples=[sample],
+        target_samples=[],
+    )
+    return anchor_a, anchor_b
+
+
 def _embedding(vector: list[float]) -> np.ndarray:
     embedding = np.array(vector + [0.0] * (256 - len(vector)), dtype=np.float32)
     return embedding / np.linalg.norm(embedding)
@@ -258,6 +312,7 @@ def test_index_renders_empty_state(curation_env):
     assert data["facet_items"] == []
     assert data["entity_items"] == []
     assert data["speaker_items"] == []
+    assert data["speaker_candidate_pair_items"] == []
     assert data["copy"]["CUR_HEADING"] == CUR_HEADING
     assert data["copy"]["CUR_EMPTY_STATE"] == CUR_EMPTY_STATE
 
@@ -295,6 +350,28 @@ def test_index_renders_speaker_candidate(curation_env):
     assert data["speaker_items"][0]["target"] == "Alice Johnson"
 
 
+def test_index_renders_speaker_candidate_pair_bucket(curation_env):
+    env = curation_env()
+    _seed_speaker_candidate_pair()
+
+    resp = env.client.get("/app/curation/api/state")
+
+    assert resp.status_code == 200
+    data = resp.get_json()
+    assert data["speaker_candidate_pair_items"][0]["kind"] == "speaker_candidate_pair"
+    assert data["speaker_candidate_pair_items"][0]["evidence"]["similarity"] == 0.62
+    assert (
+        data["speaker_candidate_pair_items"][0]["evidence"]["source_samples"][0][
+            "segment_key"
+        ]
+        == "090000_300"
+    )
+    assert (
+        "segment"
+        not in data["speaker_candidate_pair_items"][0]["evidence"]["source_samples"][0]
+    )
+
+
 def test_facet_accept_creates_facet_and_flips_status(curation_env):
     env = curation_env()
     _seed_facet_candidate()
@@ -805,6 +882,60 @@ def test_speaker_payload_key_mismatch_returns_400(curation_env):
     assert resp.get_json()["reason_code"] == "invalid_request_value"
 
 
+def test_speaker_candidate_pair_dismiss_sets_status_and_removes_open_item(curation_env):
+    env = curation_env()
+    _seed_speaker_candidate_pair()
+
+    resp = env.client.post(
+        "/app/curation/api/speaker-candidate-pair/dismiss",
+        json=_speaker_candidate_pair_payload(),
+    )
+
+    assert resp.status_code == 200
+    assert resp.get_json()["status"] == "dismissed"
+    assert load_pair_candidates()[0]["status"] == "dismissed"
+    state = env.client.get("/app/curation/api/state").get_json()
+    assert state["speaker_candidate_pair_items"] == []
+
+
+def test_speaker_candidate_pair_payload_key_mismatch_returns_400(curation_env):
+    env = curation_env()
+
+    resp = env.client.post(
+        "/app/curation/api/speaker-candidate-pair/accept",
+        json={
+            "key": "wrong",
+            "anchor_a": _pair_anchors()[0],
+            "anchor_b": _pair_anchors()[1],
+        },
+    )
+
+    assert resp.status_code == 400
+    assert resp.get_json()["reason_code"] == "invalid_request_value"
+
+
+def test_speaker_candidate_pair_accept_lock_timeout_returns_busy(
+    curation_env,
+    monkeypatch,
+):
+    env = curation_env()
+    _seed_speaker_candidate_pair()
+    from solstone.apps.curation import routes
+
+    def raise_busy(anchor_a: str, anchor_b: str) -> dict[str, Any]:
+        raise LockTimeout(path=env.journal / "speakers" / "busy.jsonl", timeout=0.0)
+
+    monkeypatch.setattr(routes, "accept_speaker_candidate_pair", raise_busy)
+
+    resp = env.client.post(
+        "/app/curation/api/speaker-candidate-pair/accept",
+        json=_speaker_candidate_pair_payload(),
+    )
+
+    assert resp.status_code == 503
+    assert resp.get_json()["reason_code"] == "entity_busy"
+
+
 def test_rendered_payload_matches_copy_source(curation_env):
     env = curation_env()
 
@@ -862,10 +993,12 @@ def test_curation_state_payload_shape_includes_nested_evidence(curation_env):
         "copy",
         "entity_items",
         "facet_items",
+        "speaker_candidate_pair_items",
         "speaker_items",
     }
     assert data["ambiguity_items"] == []
     assert data["entity_items"] == []
+    assert data["speaker_candidate_pair_items"] == []
     assert data["speaker_items"] == []
     assert data["facet_items"][0]["evidence"]["samples"] == [
         {"day": "20260602", "stream": "archon", "segment": "090000_300"}
diff --git a/solstone/apps/curation/tests/test_trust_core_surface.py b/solstone/apps/curation/tests/test_trust_core_surface.py
index 5d16ef771..ea61bcae9 100644
--- a/solstone/apps/curation/tests/test_trust_core_surface.py
+++ b/solstone/apps/curation/tests/test_trust_core_surface.py
@@ -53,6 +53,24 @@ def test_removing_final_item_does_not_reload_away_undo_outcomes() -> None:
     assert "refreshToolbar();" in html[start:end]
 
 
+def test_speaker_candidate_pair_renderer_includes_audio_and_actions() -> None:
+    html = _workspace()
+
+    assert "function speakerCandidatePairItemHtml(item)" in html
+    assert "payload.speaker_candidate_pair_items || []" in html
+    assert 'data-kind="speaker_candidate_pair"' in html
+    assert 'data-anchor-a="${escapeAttr(item.source_slug)}"' in html
+    assert 'data-action="speaker-pair-accept"' in html
+    assert 'data-action="speaker-pair-dismiss"' in html
+    assert (
+        '<audio controls preload="metadata" src="${escapeHtml(sample.audio_url)}">'
+        in html
+    )
+    assert "sample.segment_key" in html
+    assert "/app/curation/api/speaker-candidate-pair/accept" in html
+    assert "/app/curation/api/speaker-candidate-pair/dismiss" in html
+
+
 def test_repair_required_disables_replay_and_shows_remediation() -> None:
     html = _workspace()
 
diff --git a/solstone/apps/curation/workspace.html b/solstone/apps/curation/workspace.html
index fe92f1d6f..2cd76674a 100644
--- a/solstone/apps/curation/workspace.html
+++ b/solstone/apps/curation/workspace.html
@@ -207,6 +207,38 @@
   font-size: 0.9em;
 }
 
+.curation-speaker-pair-summary {
+  margin: 0 0 0.65em;
+  color: #4b5563;
+  line-height: 1.45;
+}
+
+.curation-speaker-pair-samples {
+  display: grid;
+  gap: 0.75em;
+  grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+}
+
+.curation-speaker-pair-samples h3 {
+  margin: 0 0 0.45em;
+  color: #374151;
+  font-size: 1em;
+  font-weight: 650;
+}
+
+.curation-speaker-pair-samples ul {
+  margin: 0;
+  padding-left: 1.2em;
+  color: #4b5563;
+  line-height: 1.45;
+}
+
+.curation-speaker-pair-samples audio {
+  display: block;
+  width: 100%;
+  margin-top: 0.35em;
+}
+
 @media (max-width: 640px) {
   .curation-shell {
     padding: 1em;
@@ -276,6 +308,54 @@ window.CUR_COPY = CUR_COPY;
     `).join('');
   }
 
+  function formatSimilarity(value) {
+    const number = Number(value || 0);
+    return Number.isFinite(number) ? number.toFixed(2) : '0.00';
+  }
+
+  function sampleAudioHtml(sample) {
+    if (!sample?.audio_url) return '';
+    return `<audio controls preload="metadata" src="${escapeHtml(sample.audio_url)}"></audio>`;
+  }
+
+  function speakerCandidatePairSampleHtml(sample) {
+    return `
+      <li>
+        <span>${escapeHtml(sample.day)}</span>
+        ${sample.stream ? `<span> · ${escapeHtml(sample.stream)}</span>` : ''}
+        ${sample.segment_key ? `<span> · ${escapeHtml(sample.segment_key)}</span>` : ''}
+        ${sample.source ? `<span> · ${escapeHtml(sample.source)}</span>` : ''}
+        ${sample.cluster_label !== undefined ? `<span> · ${escapeHtml(sample.cluster_label)}</span>` : ''}
+        ${sampleAudioHtml(sample)}
+      </li>
+    `;
+  }
+
+  function speakerCandidatePairEvidenceHtml(item) {
+    const evidence = item.evidence || {};
+    const sourceSamples = evidence.source_samples || [];
+    const targetSamples = evidence.target_samples || [];
+    return `
+      <div class="curation-evidence">
+        <p class="curation-speaker-pair-summary">
+          ${escapeHtml(CUR_COPY.CUR_SPEAKER_CANDIDATE_PAIR_SIMILARITY_LABEL)}: ${escapeHtml(formatSimilarity(evidence.similarity))}
+          · ${escapeHtml(CUR_COPY.CUR_SPEAKER_CANDIDATE_PAIR_SOURCE_LABEL)} ${escapeHtml(CUR_COPY.CUR_SPEAKER_CANDIDATE_PAIR_INTERVALS_LABEL)}: ${escapeHtml(evidence.source_intervals || 0)}
+          · ${escapeHtml(CUR_COPY.CUR_SPEAKER_CANDIDATE_PAIR_TARGET_LABEL)} ${escapeHtml(CUR_COPY.CUR_SPEAKER_CANDIDATE_PAIR_INTERVALS_LABEL)}: ${escapeHtml(evidence.target_intervals || 0)}
+        </p>
+        <div class="curation-speaker-pair-samples">
+          <section>
+            <h3>${escapeHtml(CUR_COPY.CUR_SPEAKER_CANDIDATE_PAIR_SOURCE_LABEL)}</h3>
+            <ul>${sourceSamples.map(speakerCandidatePairSampleHtml).join('')}</ul>
+          </section>
+          <section>
+            <h3>${escapeHtml(CUR_COPY.CUR_SPEAKER_CANDIDATE_PAIR_TARGET_LABEL)}</h3>
+            <ul>${targetSamples.map(speakerCandidatePairSampleHtml).join('')}</ul>
+          </section>
+        </div>
+      </div>
+    `;
+  }
+
   function facetItemHtml(item) {
     return `
       <article class="curation-item" data-curation-item data-kind="facet_candidate" data-name-key="${escapeHtml(item.key)}">
@@ -361,6 +441,20 @@ window.CUR_COPY = CUR_COPY;
     `;
   }
 
+  function speakerCandidatePairItemHtml(item) {
+    return `
+      <article class="curation-item" data-curation-item data-kind="speaker_candidate_pair" data-key="${escapeAttr(item.key)}" data-anchor-a="${escapeAttr(item.source_slug)}" data-anchor-b="${escapeAttr(item.target_slug)}">
+        <p class="curation-body">${escapeHtml(CUR_COPY.CUR_SPEAKER_CANDIDATE_PAIR_BODY)}</p>
+        ${speakerCandidatePairEvidenceHtml(item)}
+        <div class="curation-actions">
+          <button class="curation-button curation-button-primary" type="button" data-action="speaker-pair-accept">${escapeHtml(CUR_COPY.CUR_SPEAKER_CANDIDATE_PAIR_MERGE_ACTION)}</button>
+          <button class="curation-button" type="button" data-action="speaker-pair-dismiss">${escapeHtml(CUR_COPY.CUR_SPEAKER_CANDIDATE_PAIR_DISMISS_ACTION)}</button>
+        </div>
+        <p class="curation-item-error" hidden></p>
+      </article>
+    `;
+  }
+
   function renderState(payload, preserveOutcomes = false) {
     const savedOutcomes = preserveOutcomes
       ? Array.from(root.querySelector('[data-curation-outcomes]')?.children || [])
@@ -371,7 +465,8 @@ window.CUR_COPY = CUR_COPY;
     const entityItems = payload.entity_items || [];
     const ambiguityItems = payload.ambiguity_items || [];
     const speakerItems = payload.speaker_items || [];
-    const empty = !facetItems.length && !entityItems.length && !ambiguityItems.length && !speakerItems.length;
+    const speakerCandidatePairItems = payload.speaker_candidate_pair_items || [];
+    const empty = !facetItems.length && !entityItems.length && !ambiguityItems.length && !speakerItems.length && !speakerCandidatePairItems.length;
     root.innerHTML = `
       <h1 class="curation-header">${escapeHtml(CUR_COPY.CUR_HEADING)}</h1>
       ${empty ? `<p class="curation-empty">${escapeHtml(CUR_COPY.CUR_EMPTY_STATE)}</p>` : ''}
@@ -382,6 +477,7 @@ window.CUR_COPY = CUR_COPY;
         ${entityItems.map(entityItemHtml).join('')}
         ${ambiguityItems.map(ambiguityItemHtml).join('')}
         ${speakerItems.map(speakerItemHtml).join('')}
+        ${speakerCandidatePairItems.map(speakerCandidatePairItemHtml).join('')}
       </div>
     `;
     const outcomes = root.querySelector('[data-curation-outcomes]');
@@ -457,6 +553,10 @@ window.CUR_COPY = CUR_COPY;
     return holder.innerHTML;
   }
 
+  function escapeAttr(value) {
+    return escapeHtml(value).replace(/"/g, '&quot;');
+  }
+
   function removeItem(item) {
     if (!item) return;
     item.dataset.removing = 'true';
@@ -588,6 +688,16 @@ window.CUR_COPY = CUR_COPY;
     };
   }
 
+  function speakerCandidatePairPayload(button) {
+    const item = itemFor(button);
+    const ds = item?.dataset || {};
+    return {
+      key: ds.key,
+      anchor_a: ds.anchorA,
+      anchor_b: ds.anchorB
+    };
+  }
+
   function payloadAttrs(payload) {
     if (payload.facet !== undefined) {
       return `data-facet="${escapeHtml(payload.facet)}" data-source-slug="${escapeHtml(payload.source_slug)}" data-target-slug="${escapeHtml(payload.target_slug)}"`;
@@ -762,6 +872,28 @@ window.CUR_COPY = CUR_COPY;
       return;
     }
 
+    if (action === 'speaker-pair-accept' || action === 'speaker-pair-dismiss') {
+      const payload = speakerCandidatePairPayload(button);
+      const path = action === 'speaker-pair-accept'
+        ? '/app/curation/api/speaker-candidate-pair/accept'
+        : '/app/curation/api/speaker-candidate-pair/dismiss';
+      setBusy(button, true);
+      postJson(path, payload)
+        .then((data) => {
+          if (action === 'speaker-pair-accept') appendUndoOutcome(data.undo, data.key);
+          removeItem(item);
+        })
+        .catch((err) => {
+          if (action === 'speaker-pair-accept') {
+            showMutationError(item, button, err, CUR_COPY.CUR_UNDO_FAILED);
+          } else {
+            setBusy(button, false);
+            showError(item, err.serverMessage || err.message);
+          }
+        });
+      return;
+    }
+
     if (action === 'entity-select' || action === 'entity-select-all') {
       if (action === 'entity-select-all') {
         entityCheckboxes().forEach((checkbox) => {
diff --git a/solstone/apps/speakers/maintenance.py b/solstone/apps/speakers/maintenance.py
index 273afa893..806ada2f9 100644
--- a/solstone/apps/speakers/maintenance.py
+++ b/solstone/apps/speakers/maintenance.py
@@ -135,18 +135,16 @@ def run_candidate_pair_suggestions(args: list[str]) -> int:
                 continue
             found += 1
             try:
-                row, was_created, was_suppressed = (
-                    pair_store.record_candidate_pair_candidate(
-                        source_anchor=canonical_candidate_anchor(left),
-                        target_anchor=canonical_candidate_anchor(right),
-                        source_anchors=candidate_source_anchors(left),
-                        target_anchors=candidate_source_anchors(right),
-                        similarity=score,
-                        source_intervals=left.n_intervals,
-                        target_intervals=right.n_intervals,
-                        source_samples=_candidate_samples(left),
-                        target_samples=_candidate_samples(right),
-                    )
+                row, was_created, was_suppressed = pair_store.record_candidate_pair(
+                    source_anchor=canonical_candidate_anchor(left),
+                    target_anchor=canonical_candidate_anchor(right),
+                    source_anchors=candidate_source_anchors(left),
+                    target_anchors=candidate_source_anchors(right),
+                    similarity=score,
+                    source_intervals=left.n_intervals,
+                    target_intervals=right.n_intervals,
+                    source_samples=_candidate_samples(left),
+                    target_samples=_candidate_samples(right),
                 )
             except LockTimeout as exc:
                 logger.warning("speaker candidate-pair suggestions skipped: %s", exc)
diff --git a/solstone/apps/speakers/suggest.py b/solstone/apps/speakers/suggest.py
index 5c03b1da4..f304c60c5 100644
--- a/solstone/apps/speakers/suggest.py
+++ b/solstone/apps/speakers/suggest.py
@@ -324,12 +324,40 @@ def _low_confidence_review() -> list[dict[str, Any]]:
     return results
 
 
+def _candidate_pair_review() -> list[dict[str, Any]]:
+    from solstone.think import speaker_candidate_pair_review_candidates as pair_store
+
+    results: list[dict[str, Any]] = []
+    for row in pair_store.load_candidates():
+        if row.get("status") != "open":
+            continue
+        evidence = row.get("evidence", {})
+        if not isinstance(evidence, dict):
+            evidence = {}
+        similarity = float(row.get("similarity") or evidence.get("similarity") or 0.0)
+        results.append(
+            {
+                "type": "speaker_candidate_pair",
+                "key": row.get("key"),
+                "anchor_a": row.get("anchor_a"),
+                "anchor_b": row.get("anchor_b"),
+                "similarity": similarity,
+                "source_intervals": evidence.get("source_intervals", 0),
+                "target_intervals": evidence.get("target_intervals", 0),
+            }
+        )
+
+    results.sort(key=lambda item: (-float(item["similarity"]), str(item["key"] or "")))
+    return results
+
+
 def suggest_opportunities(limit: int = 5) -> list[dict[str, Any]]:
     suggestions: list[dict[str, Any]] = []
     for generator in [
         _unknown_recurring,
         _import_linkable,
         _name_variant,
+        _candidate_pair_review,
         _low_confidence_review,
     ]:
         if len(suggestions) >= limit:
@@ -376,6 +404,13 @@ def format_suggestions(suggestions: list[dict[str, Any]]) -> str:
                 f'\u2194 "{suggestion["target"]["name"]}" '
                 f"(similarity: {suggestion['similarity']:.2f})"
             )
+        elif suggestion_type == "speaker_candidate_pair":
+            lines.append(
+                "Speaker candidate pair: "
+                f"similarity {suggestion['similarity']:.2f} "
+                f"({suggestion['source_intervals']} vs "
+                f"{suggestion['target_intervals']} intervals)"
+            )
         elif suggestion_type == "low_confidence_review":
             seg_info = suggestion.get("segment_key", "")
             lines.append(
diff --git a/solstone/apps/speakers/tests/test_suggest.py b/solstone/apps/speakers/tests/test_suggest.py
index 7981caff1..7bceb7949 100644
--- a/solstone/apps/speakers/tests/test_suggest.py
+++ b/solstone/apps/speakers/tests/test_suggest.py
@@ -13,6 +13,9 @@ from solstone.apps.speakers.suggest import (
     format_suggestions,
     suggest_opportunities,
 )
+from solstone.think.speaker_candidate_pair_review_candidates import (
+    record_candidate_pair,
+)
 
 
 def create_meetings_md(env, day: str, content: str) -> Path:
@@ -133,6 +136,35 @@ def test_suggest_name_variant(speakers_env):
     assert suggestion["readiness"] == "ready"
 
 
+def test_suggest_speaker_candidate_pair_and_formats_it(speakers_env):
+    speakers_env()
+    anchor_a = '["20260101","090000_300","test","mic_audio",1]'
+    anchor_b = '["20260102","090000_300","test","mic_audio",2]'
+    record_candidate_pair(
+        source_anchor=anchor_a,
+        target_anchor=anchor_b,
+        source_anchors={anchor_a},
+        target_anchors={anchor_b},
+        similarity=0.62,
+        source_intervals=31,
+        target_intervals=35,
+        source_samples=[],
+        target_samples=[],
+    )
+
+    results = suggest_opportunities()
+    suggestion = next(
+        item for item in results if item["type"] == "speaker_candidate_pair"
+    )
+    rendered = format_suggestions([suggestion])
+
+    assert suggestion["similarity"] == 0.62
+    assert suggestion["source_intervals"] == 31
+    assert suggestion["target_intervals"] == 35
+    assert rendered
+    assert "Speaker candidate pair: similarity 0.62 (31 vs 35 intervals)" in rendered
+
+
 def test_suggest_import_linkable(speakers_env):
     env = speakers_env()
     env.create_entity("Romeo Montague")
diff --git a/solstone/think/curation.py b/solstone/think/curation.py
index 13b7307fb..5065d146b 100644
--- a/solstone/think/curation.py
+++ b/solstone/think/curation.py
@@ -10,6 +10,9 @@ from dataclasses import dataclass
 from typing import Any, Callable
 
 import solstone.think.facet_review_candidates as facet_store
+from solstone.think import (
+    speaker_candidate_pair_review_candidates as speaker_pair_store,
+)
 from solstone.think import speaker_review_candidates as speaker_store
 from solstone.think.entities import review_candidates as entity_store
 from solstone.think.entities.ambiguities import load_ambiguities
@@ -22,6 +25,7 @@ KIND_FACET_CANDIDATE = "facet_candidate"
 KIND_ENTITY_MERGE = "entity_merge"
 KIND_ENTITY_AMBIGUITY = "entity_ambiguity"
 KIND_SPEAKER_NAME_VARIANT = "speaker_name_variant"
+KIND_SPEAKER_CANDIDATE_PAIR = "speaker_candidate_pair"
 NEIGHBORHOOD_WEIGHT = 0.25
 # Entity detection strength is an integer; a sub-1.0 neighborhood contribution
 # can break ties but cannot outrank a genuinely stronger detection count.
@@ -87,6 +91,10 @@ def _speaker_key(source_id: str, target_id: str) -> str:
     return speaker_store.candidate_key(source_id, target_id)
 
 
+def _speaker_candidate_pair_key(anchor_a: str, anchor_b: str) -> str:
+    return speaker_pair_store.candidate_key(anchor_a, anchor_b)
+
+
 def _find_facet_candidate(name_key: str) -> dict[str, Any] | None:
     return facet_store.find_candidate(facet_store.load_candidates(), name_key)
 
@@ -115,6 +123,17 @@ def _find_speaker_candidate(
     )
 
 
+def _find_speaker_candidate_pair(
+    anchor_a: str,
+    anchor_b: str,
+) -> dict[str, Any] | None:
+    return speaker_pair_store.find_candidate(
+        speaker_pair_store.load_candidates(),
+        anchor_a,
+        anchor_b,
+    )
+
+
 def _speaker_direction_matches(
     row: dict[str, Any],
     source_id: str,
@@ -174,6 +193,19 @@ def _speaker_error(
     }
 
 
+def _speaker_candidate_pair_error(
+    anchor_a: str,
+    anchor_b: str,
+    message: str,
+) -> dict[str, Any]:
+    return {
+        "status": "error",
+        "kind": KIND_SPEAKER_CANDIDATE_PAIR,
+        "key": _speaker_candidate_pair_key(anchor_a, anchor_b),
+        "error": message,
+    }
+
+
 def _merge_error_context(result: dict[str, Any]) -> dict[str, Any]:
     error = result.get("error")
     nested_repair = isinstance(error, dict) and error.get("code") == "repair_required"
@@ -199,7 +231,17 @@ def _merge_error_message(result: dict[str, Any]) -> str:
     return str(error)
 
 
-def _undo_descriptor(merge_id: Any) -> dict[str, Any]:
+def _undo_descriptor(
+    merge_id: Any,
+    *,
+    kind: str | None = None,
+) -> dict[str, Any]:
+    if kind == KIND_SPEAKER_CANDIDATE_PAIR:
+        return {
+            "available": False,
+            "merge_id": None,
+            "reason": "Speaker candidate-pair merges cannot be undone.",
+        }
     value = str(merge_id or "")
     return {
         "available": bool(value),
@@ -341,6 +383,33 @@ def load_open_items() -> list[CurationItem]:
             )
         )
 
+    for row in speaker_pair_store.load_candidates():
+        if row.get("status") != "open":
+            continue
+        evidence = row.get("evidence", {})
+        if not isinstance(evidence, dict):
+            evidence = {}
+        anchor_a = str(row.get("anchor_a") or "")
+        anchor_b = str(row.get("anchor_b") or "")
+        similarity = float(row.get("similarity") or evidence.get("similarity") or 0.0)
+        pair_evidence = dict(evidence)
+        pair_evidence["similarity"] = similarity
+        items.append(
+            CurationItem(
+                kind=KIND_SPEAKER_CANDIDATE_PAIR,
+                key=_speaker_candidate_pair_key(anchor_a, anchor_b),
+                name=None,
+                facet=None,
+                source="candidate A",
+                source_slug=anchor_a,
+                target="candidate B",
+                target_slug=anchor_b,
+                evidence=pair_evidence,
+                strength=int(round(similarity * 100)),
+                composite=float(int(round(similarity * 100))),
+            )
+        )
+
     return sorted(items, key=lambda item: (-item.composite, item.key))
 
 
@@ -740,6 +809,81 @@ def dismiss_speaker_candidate(
     }
 
 
+def accept_speaker_candidate_pair(anchor_a: str, anchor_b: str) -> dict[str, Any]:
+    """Accept one open speaker candidate-pair merge candidate."""
+    key = _speaker_candidate_pair_key(anchor_a, anchor_b)
+    row = _find_speaker_candidate_pair(anchor_a, anchor_b)
+    if row is None:
+        return _speaker_candidate_pair_error(anchor_a, anchor_b, "candidate not found")
+
+    status = _status(row)
+    if status == "accepted":
+        return {
+            "status": "already_accepted",
+            "kind": KIND_SPEAKER_CANDIDATE_PAIR,
+            "key": key,
+            "candidate": row,
+            "undo": _undo_descriptor(None, kind=KIND_SPEAKER_CANDIDATE_PAIR),
+        }
+    if status != "open":
+        return _speaker_candidate_pair_error(
+            anchor_a,
+            anchor_b,
+            f"cannot accept candidate with status {status}",
+        )
+
+    from solstone.apps.speakers.candidate_tracker import CandidateTracker
+
+    merge = CandidateTracker().merge_candidate_pair(anchor_a, anchor_b)
+    if merge.get("status") != "merged":
+        return _speaker_candidate_pair_error(
+            anchor_a,
+            anchor_b,
+            str(merge.get("error") or "candidate pair is already merged"),
+        )
+
+    accepted = speaker_pair_store.accept_candidate(anchor_a, anchor_b)
+    return {
+        "status": "accepted",
+        "kind": KIND_SPEAKER_CANDIDATE_PAIR,
+        "key": key,
+        "merge": merge,
+        "candidate": accepted,
+        "undo": _undo_descriptor(None, kind=KIND_SPEAKER_CANDIDATE_PAIR),
+    }
+
+
+def dismiss_speaker_candidate_pair(anchor_a: str, anchor_b: str) -> dict[str, Any]:
+    """Dismiss one open speaker candidate-pair merge candidate."""
+    key = _speaker_candidate_pair_key(anchor_a, anchor_b)
+    row = _find_speaker_candidate_pair(anchor_a, anchor_b)
+    if row is None:
+        return _speaker_candidate_pair_error(anchor_a, anchor_b, "candidate not found")
+
+    status = _status(row)
+    if status == "dismissed":
+        return {
+            "status": "already_dismissed",
+            "kind": KIND_SPEAKER_CANDIDATE_PAIR,
+            "key": key,
+            "candidate": row,
+        }
+    if status != "open":
+        return _speaker_candidate_pair_error(
+            anchor_a,
+            anchor_b,
+            f"cannot dismiss candidate with status {status}",
+        )
+
+    dismissed = speaker_pair_store.dismiss_candidate(anchor_a, anchor_b)
+    return {
+        "status": "dismissed",
+        "kind": KIND_SPEAKER_CANDIDATE_PAIR,
+        "key": key,
+        "candidate": dismissed,
+    }
+
+
 def merge_preview_fields(merge_result: dict[str, Any]) -> dict[str, Any]:
     """Return compact preview fields used by curation renderers."""
     identity = merge_result.get("would_identity") or {}
diff --git a/solstone/think/speaker_candidate_pair_review_candidates.py b/solstone/think/speaker_candidate_pair_review_candidates.py
index 0ff2f6c81..4e493f8e8 100644
--- a/solstone/think/speaker_candidate_pair_review_candidates.py
+++ b/solstone/think/speaker_candidate_pair_review_candidates.py
@@ -169,7 +169,7 @@ def is_dismissed_pair_suppressed(
     return False
 
 
-def record_candidate_pair_candidate(
+def record_candidate_pair(
     *,
     source_anchor: str,
     target_anchor: str,
diff --git a/tests/test_curation.py b/tests/test_curation.py
index 07a3d4ae9..2af5a216c 100644
--- a/tests/test_curation.py
+++ b/tests/test_curation.py
@@ -6,18 +6,27 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Any
 
+import numpy as np
 import pytest
 
 import solstone.think.curation as curation
+from solstone.apps.speakers.candidate_tracker import (
+    CandidateProfile,
+    CandidateTracker,
+    canonical_candidate_anchor,
+)
 from solstone.think.curation import (
     KIND_ENTITY_AMBIGUITY,
+    KIND_SPEAKER_CANDIDATE_PAIR,
     KIND_SPEAKER_NAME_VARIANT,
     accept_entity_candidate,
     accept_entity_candidate_batch,
     accept_facet_candidate,
+    accept_speaker_candidate_pair,
     dismiss_entity_candidate,
     dismiss_entity_candidate_batch,
     dismiss_facet_candidate,
+    dismiss_speaker_candidate_pair,
     load_open_items,
     merge_preview_fields,
 )
@@ -44,6 +53,12 @@ from solstone.think.facet_review_candidates import (
 from solstone.think.indexer.edges import insert_edges
 from solstone.think.indexer.journal import get_journal_index
 from solstone.think.journal_io import LockTimeout
+from solstone.think.speaker_candidate_pair_review_candidates import (
+    load_candidates as load_pair_candidates,
+)
+from solstone.think.speaker_candidate_pair_review_candidates import (
+    record_candidate_pair,
+)
 from solstone.think.speaker_review_candidates import record_name_variant_candidate
 
 
@@ -202,6 +217,76 @@ def _assert_folded(source_slug: str, target_slug: str, source_name: str) -> None
     assert source_name in target["aka"]
 
 
+def _unit(vector: list[float]) -> np.ndarray:
+    embedding = np.array(vector + [0.0] * (256 - len(vector)), dtype=np.float32)
+    return embedding / np.linalg.norm(embedding)
+
+
+def _source_segment(day: str, cluster_label: int = 1) -> dict[str, object]:
+    return {
+        "day": day,
+        "segment_key": "090000_300",
+        "stream": "test",
+        "source": "mic_audio",
+        "cluster_label": cluster_label,
+    }
+
+
+def _candidate_profile(
+    cand_id: int,
+    centroid: np.ndarray,
+    *,
+    status: str = "pending",
+    confirmed_entity: str | None = None,
+) -> CandidateProfile:
+    source_segment = _source_segment(f"2026010{cand_id}", cand_id)
+    return CandidateProfile(
+        cand_id=cand_id,
+        centroid=centroid,
+        n_segments=1,
+        n_intervals=30,
+        total_duration_s=30.0,
+        source_segments=[source_segment],
+        status=status,
+        confirmed_entity=confirmed_entity,
+    )
+
+
+def _seed_candidate_tracker(
+    journal: Path,
+    candidates: list[CandidateProfile],
+) -> CandidateTracker:
+    tracker = CandidateTracker(journal / "awareness" / "speaker_candidates.json")
+    tracker._candidates = {candidate.cand_id: candidate for candidate in candidates}
+    tracker._next_id = (
+        max((candidate.cand_id for candidate in candidates), default=0) + 1
+    )
+    tracker.save()
+    return CandidateTracker(journal / "awareness" / "speaker_candidates.json")
+
+
+def _record_pair_for_candidates(
+    left: CandidateProfile,
+    right: CandidateProfile,
+    *,
+    similarity: float = 0.70,
+) -> tuple[str, str]:
+    anchor_a = canonical_candidate_anchor(left)
+    anchor_b = canonical_candidate_anchor(right)
+    record_candidate_pair(
+        source_anchor=anchor_a,
+        target_anchor=anchor_b,
+        source_anchors={anchor_a},
+        target_anchors={anchor_b},
+        similarity=similarity,
+        source_intervals=left.n_intervals,
+        target_intervals=right.n_intervals,
+        source_samples=[],
+        target_samples=[],
+    )
+    return anchor_a, anchor_b
+
+
 def test_load_open_items_normalizes_and_orders(curation_journal):
     save_facet_candidates(
         [
@@ -258,6 +343,27 @@ def test_load_open_items_includes_speaker_name_variant(curation_journal):
     assert item.strength == 93
 
 
+def test_load_open_items_includes_speaker_candidate_pair(curation_journal):
+    left = _candidate_profile(1, _unit([1.0, 0.0]))
+    right = _candidate_profile(2, _unit([0.62, np.sqrt(1.0 - 0.62**2)]))
+    anchor_a, anchor_b = _record_pair_for_candidates(left, right, similarity=0.62)
+
+    items = load_open_items()
+
+    assert len(items) == 1
+    item = items[0]
+    assert item.kind == KIND_SPEAKER_CANDIDATE_PAIR
+    assert item.key == curation._speaker_candidate_pair_key(anchor_a, anchor_b)
+    assert item.source_slug == anchor_a
+    assert item.target_slug == anchor_b
+    assert item.source == "candidate A"
+    assert item.target == "candidate B"
+    assert item.evidence["similarity"] == 0.62
+    assert item.evidence["source_intervals"] == 30
+    assert item.evidence["target_intervals"] == 30
+    assert item.strength == 62
+
+
 def test_entity_merge_equal_strength_uses_shared_neighborhood(curation_journal):
     _seed_entity_candidates(
         [
@@ -882,6 +988,100 @@ def test_dismiss_entity_candidate_batch_counts_already_dismissed(curation_journa
     ]
 
 
+def test_accept_speaker_candidate_pair_merges_tracker_without_entity_merge(
+    curation_journal,
+    monkeypatch,
+):
+    calls: list[tuple[tuple[Any, ...], dict[str, Any]]] = []
+
+    def merge_entity_spy(*args: Any, **kwargs: Any) -> dict[str, Any]:
+        calls.append((args, kwargs))
+        raise AssertionError("speaker candidate-pair accept must not merge entities")
+
+    monkeypatch.setattr(curation, "merge_entity", merge_entity_spy)
+    left = _candidate_profile(1, _unit([1.0, 0.0]))
+    right = _candidate_profile(
+        2,
+        _unit([0.70, np.sqrt(1.0 - 0.70**2)]),
+        status="confirmed",
+        confirmed_entity="alice_test",
+    )
+    tracker = _seed_candidate_tracker(curation_journal, [left, right])
+    anchor_a, anchor_b = _record_pair_for_candidates(
+        tracker.load_all_candidates()[0],
+        tracker.load_all_candidates()[1],
+    )
+
+    result = accept_speaker_candidate_pair(anchor_b, anchor_a)
+
+    assert calls == []
+    assert result["status"] == "accepted"
+    assert result["kind"] == KIND_SPEAKER_CANDIDATE_PAIR
+    assert result["merge"]["status"] == "merged"
+    assert result["undo"] == {
+        "available": False,
+        "merge_id": None,
+        "reason": "Speaker candidate-pair merges cannot be undone.",
+    }
+    survivor = CandidateTracker(
+        curation_journal / "awareness" / "speaker_candidates.json"
+    ).load_all_candidates()
+    assert len(survivor) == 1
+    assert survivor[0].cand_id == 1
+    assert survivor[0].status == "confirmed"
+    assert survivor[0].confirmed_entity == "alice_test"
+    assert load_pair_candidates()[0]["status"] == "accepted"
+
+
+def test_accept_speaker_candidate_pair_stale_tracker_error_keeps_row_open(
+    curation_journal,
+    monkeypatch,
+):
+    calls: list[tuple[tuple[Any, ...], dict[str, Any]]] = []
+    monkeypatch.setattr(
+        curation,
+        "merge_entity",
+        lambda *args, **kwargs: calls.append((args, kwargs)),
+    )
+    left = _candidate_profile(1, _unit([1.0, 0.0]))
+    right = _candidate_profile(2, _unit([0.70, np.sqrt(1.0 - 0.70**2)]))
+    anchor_a, anchor_b = _record_pair_for_candidates(left, right)
+
+    result = accept_speaker_candidate_pair(anchor_a, anchor_b)
+
+    assert calls == []
+    assert result == {
+        "status": "error",
+        "kind": KIND_SPEAKER_CANDIDATE_PAIR,
+        "key": curation._speaker_candidate_pair_key(anchor_a, anchor_b),
+        "error": "candidate anchor not found",
+    }
+    assert load_pair_candidates()[0]["status"] == "open"
+    assert (
+        CandidateTracker(
+            curation_journal / "awareness" / "speaker_candidates.json"
+        ).load_all_candidates()
+        == []
+    )
+
+
+def test_dismiss_speaker_candidate_pair_sets_status_and_removes_open_item(
+    curation_journal,
+):
+    left = _candidate_profile(1, _unit([1.0, 0.0]))
+    right = _candidate_profile(2, _unit([0.62, np.sqrt(1.0 - 0.62**2)]))
+    anchor_a, anchor_b = _record_pair_for_candidates(left, right, similarity=0.62)
+
+    result = dismiss_speaker_candidate_pair(anchor_b, anchor_a)
+
+    assert result["status"] == "dismissed"
+    assert result["kind"] == KIND_SPEAKER_CANDIDATE_PAIR
+    assert load_pair_candidates()[0]["status"] == "dismissed"
+    assert [
+        item for item in load_open_items() if item.kind == KIND_SPEAKER_CANDIDATE_PAIR
+    ] == []
+
+
 def test_merge_preview_fields_returns_compact_summary():
     fields = merge_preview_fields(
         {
diff --git a/tests/test_speaker_candidate_pair_review_candidates.py b/tests/test_speaker_candidate_pair_review_candidates.py
index f3b474276..d5faffe50 100644
--- a/tests/test_speaker_candidate_pair_review_candidates.py
+++ b/tests/test_speaker_candidate_pair_review_candidates.py
@@ -14,7 +14,7 @@ from solstone.think.speaker_candidate_pair_review_candidates import (
     find_candidate,
     is_dismissed_pair_suppressed,
     load_candidates,
-    record_candidate_pair_candidate,
+    record_candidate_pair,
     review_candidates_path,
 )
 
@@ -39,9 +39,7 @@ def test_candidate_pair_path_and_key_are_order_independent(candidate_journal):
     assert candidate_key(anchor_a, anchor_b) == candidate_key(anchor_b, anchor_a)
 
 
-def test_record_candidate_pair_candidate_creates_evidence_row(
-    candidate_journal, monkeypatch
-):
+def test_record_candidate_pair_creates_evidence_row(candidate_journal, monkeypatch):
     monkeypatch.setattr(mod, "utc_now_iso", lambda: "2026-06-03T17:30:00Z")
     anchor_a = '["20260101","090000_300","test","mic_audio",1]'
     anchor_b = '["20260102","090000_300","test","mic_audio",2]'
@@ -54,7 +52,7 @@ def test_record_candidate_pair_candidate_creates_evidence_row(
         "audio_url": "/app/speakers/api/serve_audio/20260101/test/090000_300/mic_audio.flac",
     }
 
-    row, created, suppressed = record_candidate_pair_candidate(
+    row, created, suppressed = record_candidate_pair(
         source_anchor=anchor_b,
         target_anchor=anchor_a,
         source_anchors={anchor_b},
@@ -100,7 +98,7 @@ def test_dismissal_suppression_survives_id_churn_membership(
     anchor_b = '["20260102","090000_300","test","mic_audio",1]'
     anchor_c = '["20260103","090000_300","test","mic_audio",1]'
 
-    record_candidate_pair_candidate(
+    record_candidate_pair(
         source_anchor=anchor_a,
         target_anchor=anchor_b,
         source_anchors={anchor_a},
@@ -117,7 +115,7 @@ def test_dismissal_suppression_survives_id_churn_membership(
     rows = load_candidates()
     assert is_dismissed_pair_suppressed(rows, {anchor_a, anchor_c}, {anchor_b})
     assert is_dismissed_pair_suppressed(rows, {anchor_b}, {anchor_a, anchor_c})
-    row, created, suppressed = record_candidate_pair_candidate(
+    row, created, suppressed = record_candidate_pair(
         source_anchor=anchor_c,
         target_anchor=anchor_b,
         source_anchors={anchor_a, anchor_c},
@@ -139,7 +137,7 @@ def test_dismissal_suppression_survives_id_churn_membership(
 def test_dismissed_rows_do_not_reopen(candidate_journal):
     anchor_a = '["20260101","090000_300","test","mic_audio",1]'
     anchor_b = '["20260102","090000_300","test","mic_audio",1]'
-    record_candidate_pair_candidate(
+    record_candidate_pair(
         source_anchor=anchor_a,
         target_anchor=anchor_b,
         source_anchors={anchor_a},
@@ -152,7 +150,7 @@ def test_dismissed_rows_do_not_reopen(candidate_journal):
     )
     dismiss_candidate(anchor_a, anchor_b)
 
-    row, created, suppressed = record_candidate_pair_candidate(
+    row, created, suppressed = record_candidate_pair(
         source_anchor=anchor_a,
         target_anchor=anchor_b,
         source_anchors={anchor_a},