refactor: switch the whole project to English

talk is going to be published. Code comments, CLI output, error messages,
daemon log lines, MCP descriptions and results, test names and assertions,
README, spec, skill, build scripts and flake are now English. Only the
spoken announcement texts stay bilingual: the wrap result and the test
sentence are German or English depending on the detected language.

Language fallback is now configurable: `lang = "en" | "de"` (env
TALK_LANG, default en) is used when detection cannot tell (numbers, single
words, ties) and for talk's own announcements. langdetect.Detect takes the
fallback as an argument instead of hard-coding German. `talk setup` asks for
it; `talk doctor` and `talk status` show it.

Vocabulary pinned across packages so the process-boundary tests observe
stable strings: chain log lines ("chain: tier X skipped (not available)",
"falling back to the next tier", "spoken via X"), queue lines ("discarded:
quiet hours ... active", "replaced by toast", "max_age"), CLI notes
("speaking directly", "daemon started at", "no daemon", "nothing to cancel"),
status block with aligned English labels, MCP messages, origin guard 403.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

internal/provider/edge_test.go

@@ -14,72 +14,72 @@ import (
 	"github.com/gorilla/websocket"
 )
 
-// TestEdgeAvailable: Edge braucht nur einen Endpunkt, keinen Key — der
-// Konstruktor bäkt den Default-Endpunkt ein, daher ist ein über NewEdge
-// gebauter Edge immer verfügbar; nur der Nullwert (direkt gebaut, ohne
-// Endpunkt) ist es nicht.
+// TestEdgeAvailable: Edge needs only an endpoint, no key. The constructor
+// bakes in the default endpoint, so an Edge built via NewEdge is always
+// available; only the zero value (built directly, without an endpoint) is
+// not.
 func TestEdgeAvailable(t *testing.T) {
 	if (&Edge{}).Available(context.Background()) {
-		t.Error("Available ohne Endpunkt (Nullwert) = true, want false")
+		t.Error("Available without endpoint (zero value) = true, want false")
 	}
 	p := NewEdge(ChainConfig{Getenv: envMap(map[string]string{
 		EnvEdgeEndpoint: "wss://edge.example.com",
 	})})
 	if !p.Available(context.Background()) {
-		t.Error("Available mit Endpunkt = false, want true")
+		t.Error("Available with endpoint = false, want true")
 	}
 	if !NewEdge(ChainConfig{Getenv: envMap(nil)}).Available(context.Background()) {
-		t.Error("Available mit Default-Endpunkt = false, want true (edge ist der Key-freie Fallback)")
+		t.Error("Available with default endpoint = false, want true (edge is the key-free fallback)")
 	}
 }
 
-// TestEdgeVerbindungFehlschlaegt (Fehlerpfad-Mock): ein garantiert toter
-// Loopback-Port liefert einen klaren Fehler — sofort, ohne Netz.
-func TestEdgeVerbindungFehlschlaegt(t *testing.T) {
+// TestEdgeConnectionFails (error-path mock): a guaranteed dead loopback
+// port yields a clear error, immediately and without network.
+func TestEdgeConnectionFails(t *testing.T) {
 	p := NewEdge(ChainConfig{Getenv: envMap(map[string]string{
 		EnvEdgeEndpoint: "ws://127.0.0.1:1/",
 	})})
-	_, err := p.Synthesize(context.Background(), "Hallo", "de")
+	_, err := p.Synthesize(context.Background(), "Hello", "de")
 	if err == nil {
-		t.Fatal("Synthesize gegen toten Port: kein Fehler")
+		t.Fatal("Synthesize against dead port: no error")
 	}
 	if !strings.Contains(err.Error(), "edge") || !strings.Contains(err.Error(), "WebSocket") {
-		t.Errorf("Fehler = %v, will klaren edge/WebSocket-Fehler", err)
+		t.Errorf("error = %v, want a clear edge/WebSocket error", err)
 	}
 }
 
-// TestEdgeUngueltigesSchema: ein Nicht-w(s)-Endpunkt ist ein klarer Fehler.
-func TestEdgeUngueltigesSchema(t *testing.T) {
+// TestEdgeInvalidScheme: a non-ws(s) endpoint is a clear error.
+func TestEdgeInvalidScheme(t *testing.T) {
 	p := NewEdge(ChainConfig{Getenv: envMap(map[string]string{
 		EnvEdgeEndpoint: "http://127.0.0.1:1234/",
 	})})
-	_, err := p.Synthesize(context.Background(), "Hallo", "de")
+	_, err := p.Synthesize(context.Background(), "Hello", "de")
 	if err == nil || !strings.Contains(err.Error(), "ws://") {
-		t.Errorf("Fehler = %v, will Schema-Hinweis ws://", err)
+		t.Errorf("error = %v, want scheme hint ws://", err)
 	}
 }
 
-// TestEdgeSSML: die SSML-Anfrage enthält Stimme und den von Steuerzeichen
-// befreiten, XML-escapten Text; xml:lang ist wie in der Referenz fest
-// „en-US".
+// TestEdgeSSML: the SSML request contains the voice and the text stripped
+// of control characters and XML-escaped; xml:lang is fixed to "en-US" as in
+// the reference.
 func TestEdgeSSML(t *testing.T) {
-	got := edgeSSML("de-DE-KatjaNeural", "AT&T <Kunde> „fertig“")
+	got := edgeSSML("de-DE-KatjaNeural", "AT&T <customer> „done“")
 	for _, want := range []string{
 		"voice name='de-DE-KatjaNeural'",
 		"xml:lang='en-US'",
-		"AT&amp;T &lt;Kunde&gt;",
+		"AT&amp;T &lt;customer&gt;",
 	} {
 		if !strings.Contains(got, want) {
-			t.Errorf("SSML = %q, will %q", got, want)
+			t.Errorf("SSML = %q, want %q", got, want)
 		}
 	}
 	if strings.Contains(got, "AT&T") {
-		t.Errorf("SSML enthält unescaptes &: %q", got)
+		t.Errorf("SSML contains unescaped &: %q", got)
 	}
 }
 
-// TestEdgeEscape: Steuerzeichen (u. a. Vertical Tab aus OCR-Texten) werden
-// durch Leerzeichen ersetzt, & < > escapt.
+// TestEdgeEscape: control characters (e.g. vertical tab from OCR texts) are
+// replaced by spaces, & < > are escaped.
 func TestEdgeEscape(t *testing.T) {
 	in := "a\x0bb&c<d>\x08e"
 	if want := "a b&amp;c&lt;d&gt; e"; edgeEscape(in) != want {
@@ -87,19 +87,19 @@ func TestEdgeEscape(t *testing.T) {
 	}
 }
 
-// TestEdgeSpeechConfigMsg: Output-Format (mono-mp3) und Pfad stimmen.
+// TestEdgeSpeechConfigMsg: output format (mono mp3) and path are correct.
 func TestEdgeSpeechConfigMsg(t *testing.T) {
 	msg := edgeSpeechConfigMsg(time.Unix(0, 0).UTC())
 	if !strings.Contains(msg, "Path:speech.config") {
-		t.Errorf("speech.config-Nachricht ohne Path: %q", msg)
+		t.Errorf("speech.config message without Path: %q", msg)
 	}
 	if !strings.Contains(msg, edgeOutputFormat) {
-		t.Errorf("speech.config-Nachricht ohne Ausgabeformat %q: %q", edgeOutputFormat, msg)
+		t.Errorf("speech.config message without output format %q: %q", edgeOutputFormat, msg)
 	}
 }
 
-// TestEdgeRequestURL: Query-Parameter (Token, Sec-MS-GEC, Version) werden
-// ergänzt; der Token landet nicht in der URL-Debug-Ausgabe.
+// TestEdgeRequestURL: query parameters (token, Sec-MS-GEC, version) are
+// added; the token does not end up in the redacted URL output.
 func TestEdgeRequestURL(t *testing.T) {
 	p := &Edge{Endpoint: "wss://edge.example.com/path"}
 	raw, err := p.requestURL(time.Unix(1700000000, 0).UTC())
@@ -112,20 +112,20 @@ func TestEdgeRequestURL(t *testing.T) {
 		"Sec-MS-GEC-Version=" + edgeSecMSGECVersion,
 	} {
 		if !strings.Contains(raw, want) {
-			t.Errorf("requestURL = %q, will %q", raw, want)
+			t.Errorf("requestURL = %q, want %q", raw, want)
 		}
 	}
 	if got := redactURL(raw); strings.Contains(got, edgeTrustedClientToken) {
-		t.Errorf("redactURL leakt den Token: %q", got)
+		t.Errorf("redactURL leaks the token: %q", got)
 	}
 }
 
-// TestEdgeSecMSGEC: Format „<16 Hex>-<64 Hex>" (groß), 5-Minuten-Raster
-// (innerhalb des Fensters stabil, über die Grenze anders) und exakte
-// Referenzvektoren der edge-tts-DRM-Implementierung (v2).
+// TestEdgeSecMSGEC: format "<16 hex>-<64 hex>" (upper case), 5-minute grid
+// (stable within the window, different across the boundary) and exact
+// reference vectors of the edge-tts DRM implementation (v2).
 func TestEdgeSecMSGEC(t *testing.T) {
-	// Referenzvektoren: (Unix-Sekunden, erwarteter Token) — erzeugt mit der
-	// Python-Referenz (edge-tts src/edge_tts/drm.py, Stand 2026-10).
+	// Reference vectors: (unix seconds, expected token), generated with the
+	// Python reference (edge-tts src/edge_tts/drm.py, as of 2026-10).
 	vectors := []struct {
 		ts   int64
 		want string
@@ -141,36 +141,36 @@ func TestEdgeSecMSGEC(t *testing.T) {
 		}
 	}
 
-	// Fenster-Stabilität (Basis am Fensterbeginn, mod 300 == 0).
+	// Window stability (base at window start, mod 300 == 0).
 	base := time.Unix(1700000400, 0).UTC()
 	token := edgeSecMSGEC(base)
 	if edgeSecMSGEC(base.Add(4*time.Minute)) != token {
-		t.Error("Sec-MS-GEC weicht innerhalb des 5-Minuten-Fensters ab")
+		t.Error("Sec-MS-GEC differs within the 5-minute window")
 	}
 	if edgeSecMSGEC(base.Add(6*time.Minute)) == token {
-		t.Error("Sec-MS-GEC ändert sich über die Fenster-Grenze nicht")
+		t.Error("Sec-MS-GEC does not change across the window boundary")
 	}
 	if len(token) != 16+1+64 || !strings.Contains(token, "-") {
-		t.Errorf("Token-Format = %q, want <16 Hex>-<64 Hex>", token)
+		t.Errorf("token format = %q, want <16 hex>-<64 hex>", token)
 	}
 }
 
-// TestEdgeRequestID: 32 Hex-Zeichen, eindeutig.
+// TestEdgeRequestID: 32 hex characters, unique.
 func TestEdgeRequestID(t *testing.T) {
 	a, b := edgeRequestID(), edgeRequestID()
 	if len(a) != 32 {
-		t.Errorf("RequestID-Länge = %d, want 32", len(a))
+		t.Errorf("request ID length = %d, want 32", len(a))
 	}
 	if _, err := hex.DecodeString(a); err != nil {
-		t.Errorf("RequestID ist kein Hex: %v", err)
+		t.Errorf("request ID is not hex: %v", err)
 	}
 	if a == b {
-		t.Error("RequestID nicht eindeutig")
+		t.Error("request ID not unique")
 	}
 }
 
-// TestEdgeSplitBinary: Binär-Rahmen: 2 Bytes big-endian Header-Länge, dann
-// Header (Path:audio), dann Payload.
+// TestEdgeSplitBinary: binary frame: 2 bytes big-endian header length, then
+// header (Path:audio), then payload.
 func TestEdgeSplitBinary(t *testing.T) {
 	msg := []byte{0, 12, 'P', 'a', 't', 'h', ':', 'a', 'u', 'd', 'i', 'o', '\r', '\n', 1, 2, 3}
 	header, payload, ok := splitEdgeBinary(msg)
@@ -178,15 +178,15 @@ func TestEdgeSplitBinary(t *testing.T) {
 		t.Errorf("splitEdgeBinary = %q, %x, %v", header, payload, ok)
 	}
 	if _, _, ok := splitEdgeBinary([]byte{0, 99, 'x'}); ok {
-		t.Error("übergroßer Header-Längenangabe soll abgelehnt werden")
+		t.Error("oversized header length should be rejected")
 	}
 }
 
-// fakeEdgeServer ist ein Loopback-Fake des Edge-WSS-Protokolls (kein
-// echter Netz-Call — alles bleibt auf 127.0.0.1). Er prüft die beiden
-// Client-Nachrichten und antwortet nach Protokoll: Audio-Binär-Rahmen mit
-// Path:audio, danach turn.end. audio ist die zu liefernde Payload;
-// closing schließt die Verbindung vor turn.end (Fehlerpfad).
+// fakeEdgeServer is a loopback fake of the Edge WSS protocol (no real
+// network call; everything stays on 127.0.0.1). It checks the two client
+// messages and answers per protocol: a binary audio frame with Path:audio,
+// then turn.end. audio is the payload to deliver; closing closes the
+// connection before turn.end (error path).
 func fakeEdgeServer(t *testing.T, audio []byte, closing bool) (*httptest.Server, *fakeEdgeSeen) {
 	t.Helper()
 	seen := &fakeEdgeSeen{}
@@ -208,21 +208,21 @@ func fakeEdgeServer(t *testing.T, audio []byte, closing bool) (*httptest.Server,
 			return
 		}
 		if _, cfg, err := conn.ReadMessage(); err != nil {
-			t.Errorf("speech.config lesen: %v", err)
+			t.Errorf("reading speech.config: %v", err)
 		} else {
 			seen.mu.Lock()
 			seen.config = string(cfg)
 			seen.mu.Unlock()
 		}
 		if _, req, err := conn.ReadMessage(); err != nil {
-			t.Errorf("ssml lesen: %v", err)
+			t.Errorf("reading ssml: %v", err)
 		} else {
 			seen.mu.Lock()
 			seen.ssml = string(req)
 			seen.mu.Unlock()
 		}
 		if closing {
-			return // Verbindung dichtmachen, ohne zu antworten
+			return // close the connection without answering
 		}
 		header := "X-RequestId:dummy\r\nPath:audio\r\n"
 		frame := make([]byte, 0, 2+len(header)+len(audio))
@@ -252,10 +252,9 @@ func (s *fakeEdgeSeen) snapshot() (configMsg, ssml string) {
 	return s.config, s.ssml
 }
 
-// TestEdgeLoopbackFakeServer: kompletter Protokoll-Durchlauf gegen den
-// Loopback-Fake (fake-bar getestet: Handshake-Parameter, beide
-// Client-Nachrichten, Binär-Rahmen-Parsing, turn.end-Ende) — siehe
-// Task-03-Report für die Abgrenzung zum echten Endpoint.
+// TestEdgeLoopbackFakeServer: complete protocol run against the loopback
+// fake (tested fakeably: handshake parameters, both client messages,
+// binary frame parsing, turn.end termination).
 func TestEdgeLoopbackFakeServer(t *testing.T) {
 	wantAudio := []byte("\xff\xfb\x90\x00" + "edge-audio")
 	ts, seen := fakeEdgeServer(t, wantAudio, false)
@@ -263,9 +262,9 @@ func TestEdgeLoopbackFakeServer(t *testing.T) {
 	p := NewEdge(ChainConfig{Getenv: envMap(map[string]string{
 		EnvEdgeEndpoint: "ws://" + ts.Listener.Addr().String(),
 	})})
-	data, err := p.Synthesize(context.Background(), "Hallo & fertig", "de")
+	data, err := p.Synthesize(context.Background(), "Hello & done", "de")
 	if err != nil {
-		t.Fatalf("Synthesize gegen Loopback-Fake: %v", err)
+		t.Fatalf("Synthesize against loopback fake: %v", err)
 	}
 	if string(data) != string(wantAudio) {
 		t.Errorf("Synthesize = %x, want %x", data, wantAudio)
@@ -275,47 +274,47 @@ func TestEdgeLoopbackFakeServer(t *testing.T) {
 		t.Errorf("speech.config = %q", configMsg)
 	}
 	if !strings.Contains(ssml, "Path:ssml") {
-		t.Errorf("ssml-Anfrage ohne Path:ssml: %q", ssml)
+		t.Errorf("ssml request without Path:ssml: %q", ssml)
 	}
 	if !strings.Contains(ssml, "voice name='de-DE-KatjaNeural'") {
-		t.Errorf("ssml ohne Default-Stimme de: %q", ssml)
+		t.Errorf("ssml without default voice de: %q", ssml)
 	}
-	if !strings.Contains(ssml, "Hallo &amp; fertig") {
-		t.Errorf("ssml ohne escapten Text: %q", ssml)
+	if !strings.Contains(ssml, "Hello &amp; done") {
+		t.Errorf("ssml without escaped text: %q", ssml)
 	}
 }
 
-// TestEdgeLoopbackVerbindungsAbbruch: Server schließt nach den Anfragen
-// ohne Audio → klarer „Protokoll geändert?"-Fehler.
-func TestEdgeLoopbackVerbindungsAbbruch(t *testing.T) {
+// TestEdgeLoopbackConnectionAbort: the server closes after the requests
+// without audio → clear "protocol changed?" error.
+func TestEdgeLoopbackConnectionAbort(t *testing.T) {
 	ts, _ := fakeEdgeServer(t, nil, true)
 	p := NewEdge(ChainConfig{Getenv: envMap(map[string]string{
 		EnvEdgeEndpoint: "ws://" + ts.Listener.Addr().String(),
 	})})
-	_, err := p.Synthesize(context.Background(), "Hallo", "de")
-	if err == nil || !strings.Contains(err.Error(), "Protokoll") {
-		t.Errorf("Fehler = %v, will Protokoll-Änderungs-Hinweis", err)
+	_, err := p.Synthesize(context.Background(), "Hello", "de")
+	if err == nil || !strings.Contains(err.Error(), "protocol") {
+		t.Errorf("error = %v, want protocol-change hint", err)
 	}
 }
 
-// TestEdgeIntegrationEcht ist die als testing.Short überspringbare
-// Integrations-Markierung gegen den ECHTEN Microsoft-Endpunkt (kostenlos,
-// aber echtes Netz — Standard-Testläufe und -short überspringen; einmalige
-// manuelle Abnahme mit TALK_TEST_REAL_EDGE=1).
-func TestEdgeIntegrationEcht(t *testing.T) {
+// TestEdgeIntegrationReal is the integration marker against the REAL
+// Microsoft endpoint, skippable via testing.Short (free, but real network;
+// standard test runs and -short skip it; one-off manual acceptance with
+// TALK_TEST_REAL_EDGE=1).
+func TestEdgeIntegrationReal(t *testing.T) {
 	if testing.Short() {
-		t.Skip("Übersprungen (-short)")
+		t.Skip("skipped (-short)")
 	}
 	if os.Getenv("TALK_TEST_REAL_EDGE") != "1" {
-		t.Skip("Übersprungen (echtes Netz) — mit TALK_TEST_REAL_EDGE=1 ausführen")
+		t.Skip("skipped (real network); run with TALK_TEST_REAL_EDGE=1")
 	}
 	p := NewEdge(ChainConfig{})
-	data, err := p.Synthesize(context.Background(), "Kurzer Sprachtest über Edge.", "de")
+	data, err := p.Synthesize(context.Background(), "Short speech test via Edge.", "de")
 	if err != nil {
-		t.Fatalf("Synthesize gegen echten Endpunkt: %v", err)
+		t.Fatalf("Synthesize against real endpoint: %v", err)
 	}
 	if len(data) == 0 {
-		t.Fatal("Synthesize gegen echten Endpunkt: 0 Bytes")
+		t.Fatal("Synthesize against real endpoint: 0 bytes")
 	}
-	t.Logf("Edge-Integration: %d Bytes Audio", len(data))
+	t.Logf("Edge integration: %d bytes of audio", len(data))
 }