From 7f096319c09a71e31a8037fbea9ff84bce7e40fe Mon Sep 17 00:00:00 2001
From: Jer Miller <jeremie.miller@gmail.com>
Date: Sat, 18 Jul 2026 10:59:54 -0600
Subject: [PATCH] Let owners review dense speaker candidate pairs

Owners can now review acoustically similar dense speaker candidates from Suggestions with per-side audio evidence and stable anchor-based dismissal that survives candidate id churn.

Accepting one of these suggestions performs a speaker candidate-pool merge, not an entity merge, and the curation response reports that the merge has no undo. Also wire the speakers suggestion generator and formatter for the new kind and rename the new store writer to record_candidate_pair.
---
 solstone/apps/curation/copy.py                |   9 +
 solstone/apps/curation/routes.py              |  67 +++++-
 solstone/apps/curation/tests/test_copy.py     |   9 +
 solstone/apps/curation/tests/test_routes.py   | 133 ++++++++++++
 .../curation/tests/test_trust_core_surface.py |  18 ++
 solstone/apps/curation/workspace.html         | 134 +++++++++++-
 solstone/apps/speakers/maintenance.py         |  22 +-
 solstone/apps/speakers/suggest.py             |  35 +++
 solstone/apps/speakers/tests/test_suggest.py  |  32 +++
 solstone/think/curation.py                    | 146 ++++++++++++-
 ...peaker_candidate_pair_review_candidates.py |   2 +-
 tests/test_curation.py                        | 200 ++++++++++++++++++
 ...peaker_candidate_pair_review_candidates.py |  16 +-
 13 files changed, 798 insertions(+), 25 deletions(-)

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},
-- 
2.51.2