speakers: identify and merge-names CLI commands

Thin CLI wrappers around discovery.identify_cluster and bootstrap.merge_names
for agent consumption via sol call speakers. Both output JSON by default (no
--json flag) with errors to stderr and exit code 1.

apps/speakers/call.py

···
     sol call speakers attribute-segment <day> <stream> <segment> [--json]
     sol call speakers backfill [--dry-run] [--json]
     sol call speakers discover [--json]
+    sol call speakers identify <cluster-id> <name> [--entity-id ID]
+    sol call speakers merge-names <alias> <canonical>
 """
 
 from __future__ import annotations
···
                 f"sid={sample['sentence_id']}: {text_preview}"
             )
         typer.echo()
+
+
[e-mail]()
+def identify(
+    cluster_id: int = typer.Argument(..., help="Cluster ID from discovery output."),
+    name: str = typer.Argument(..., help="Speaker name to assign."),
+    entity_id: str | None = typer.Option(
+        None, "--entity-id", help="Link to existing entity ID instead of name matching."
+    ),
+) -> None:
+    """Identify a discovered unknown speaker cluster."""
+    import json
+
+    from apps.speakers.discovery import identify_cluster
+
+    result = identify_cluster(cluster_id, name, entity_id=entity_id)
+    output = json.dumps(result, indent=2, default=str)
+    if "error" in result:
+        typer.echo(output, err=True)
+        raise typer.Exit(1)
+    typer.echo(output)
+
+
[e-mail]("merge-names")
+def merge_names_cmd(
+    alias: str = typer.Argument(..., help="Alias/variant speaker name to merge from."),
+    canonical: str = typer.Argument(..., help="Canonical speaker name to merge into."),
+) -> None:
+    """Merge a speaker name variant into a canonical entity."""
+    import json
+
+    from apps.speakers.bootstrap import merge_names
+
+    result = merge_names(alias, canonical)
+    output = json.dumps(result, indent=2, default=str)
+    if "error" in result:
+        typer.echo(output, err=True)
+        raise typer.Exit(1)
+    typer.echo(output)

apps/speakers/tests/test_discovery.py

···
 from pathlib import Path
 
 import numpy as np
+from typer.testing import CliRunner
 
+from apps.speakers.call import app as speakers_app
 from apps.speakers.discovery import (
     _discovery_cache_path,
     discover_unknown_speakers,
     identify_cluster,
 )
+
+_runner = CliRunner()
 
 
 def _make_speaker_embeddings(
···
 
     assert result["voiceprints_saved"] == 0
     assert not (env.journal / "entities" / "bob_smith" / "voiceprints.npz").exists()
+
+
+def test_identify_cli_success(speakers_env):
+    """CLI identify outputs JSON to stdout on success."""
+    env = speakers_env()
+    _setup_owner_centroid(env.journal, [0.0, 1.0])
+    embeddings = _make_speaker_embeddings([1.0, 0.0], 5)
+    _create_cluster_segments(env, embeddings)
+
+    scan_result = discover_unknown_speakers()
+    cluster_id = scan_result["clusters"][0]["cluster_id"]
+
+    result = _runner.invoke(speakers_app, ["identify", str(cluster_id), "Bob Smith"])
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert data["status"] == "identified"
+    assert data["entity_id"] == "bob_smith"
+
+
+def test_identify_cli_error_no_cache(speakers_env):
+    """CLI identify outputs error JSON to stderr and exits 1 when no cache."""
+    speakers_env()
+    result = _runner.invoke(speakers_app, ["identify", "0", "Nobody"])
+    assert result.exit_code == 1

apps/speakers/tests/test_merge_names.py

···
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (c) 2026 sol pbc
+
+"""Tests for merge-names CLI command."""
+
+from __future__ import annotations
+
+import json
+
+import numpy as np
+from typer.testing import CliRunner
+
+from apps.speakers.call import app as speakers_app
+
+_runner = CliRunner()
+
+
+def test_merge_names_cli_error_missing_entity(speakers_env):
+    """CLI merge-names outputs error JSON and exits 1 for unknown entity."""
+    speakers_env()
+    result = _runner.invoke(speakers_app, ["merge-names", "Nobody", "Also Nobody"])
+    assert result.exit_code == 1
+
+
+def test_merge_names_cli_success(speakers_env):
+    """CLI merge-names outputs JSON with merged=True on success."""
+    env = speakers_env()
+    entity_a = env.create_entity("Alice Alias")
+    entity_b = env.create_entity("Alice Canonical")
+
+    emb_a = np.random.default_rng(42).standard_normal((3, 256)).astype(np.float32)
+    emb_b = np.random.default_rng(99).standard_normal((3, 256)).astype(np.float32)
+    meta_a = np.array([json.dumps({"key": f"a_{i}"}) for i in range(3)], dtype=str)
+    meta_b = np.array([json.dumps({"key": f"b_{i}"}) for i in range(3)], dtype=str)
+    np.savez_compressed(entity_a / "voiceprints.npz", embeddings=emb_a, metadata=meta_a)
+    np.savez_compressed(entity_b / "voiceprints.npz", embeddings=emb_b, metadata=meta_b)
+
+    result = _runner.invoke(
+        speakers_app, ["merge-names", "Alice Alias", "Alice Canonical"]
+    )
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert data["merged"] is True
+    assert data["canonical_name"] == "Alice Canonical"