Merge branch 'deedra' into testing

Wine editor insertion events previously reached speech and Braille without
checking the user's typing echo preferences. Turning off key echo or an
individual character category therefore left Wine typing feedback enabled.

Read the live settings for each insertion and reuse the native text
presentation policy for alphabetic, numeric, punctuation, symbol, space and
diacritical input. Honor character echo and the master key echo switch;
apply the action-key setting to the helper's tab and new-line labels.
Reject unexpected multi-character insertion labels rather than treating
these ordered character events as paste notifications.

Preserve navigation, selection and deletion feedback when typing echo is
disabled. Retain repeated characters, case, uppercase/custom voice routing,
focus ordering and the existing stale-source/password protections.

Add regression coverage for live disable/re-enable, independent categories,
Unicode, character-echo overrides, and unaffected editor actions. Extend
the private D-Bus test to exercise settings changes through the real Wine
service signature. Document behavior, current word/sentence echo limits,
and live Notepad acceptance checks in the README.

Validation:
- Reproduced disabled typing reaching output with the new test before fixing.
- Full go test -race ./... -count=1 passed outside the socket-restricted sandbox.
- Private-session TestNativeSessionBusWineEvents passed with -race.
- Focused typing/editor regressions passed, including a fresh pre-commit run.
- go vet passed for internal/app, presentation, remote and wine.
- Reader and BrlAPI helper builds passed; reader --version succeeded.
- gofmt and git diff --check passed; independent review found no blockers.

Live audible speech, physical keyboard and physical Braille acceptance
remain pending. No running reader was replaced. Changes target deedra.

README.md

@@ -22,3 +22,19 @@ location follows the new user location, the old `/usr` location follows the new
 system locations, and the old name on `PATH` follows the new name.
 Restart Cthulhu after changing the selected helper. Keep the launcher, its
 `.exe.so` sidecar, and the native hooks together in the installed directory.
+
+Wine typing feedback in standard Edit controls follows the current key echo
+settings, including the master switch, character echo, and alphabetic, numeric,
+punctuation, space and diacritical categories. Tabs and line breaks follow
+key echo's action-key setting. Applying preferences takes effect without
+restarting the helper. Navigation, selection and deletion feedback remain
+available when typing echo is disabled. Word and sentence typing echo are not
+currently supplied by the Wine helper.
+
+For a live check, type repeated letters, numbers, punctuation and spaces in
+Wine Notepad, change the corresponding echo settings and apply them, then
+continue typing. Disable key echo and verify that typing stays quiet while
+arrows, selection and Backspace still report editing feedback. Re-enable it
+and check capital/lowercase voices and password exclusion. Automated tests
+cover queued speech and Braille; audible speech and a physical Braille display
+still require live verification.

internal/app/remote.go

@@ -22,6 +22,7 @@ import (
 	"strings"
 	"unicode/utf8"
 
+	"git.stormux.org/storm/cthulhu/internal/config"
 	"git.stormux.org/storm/cthulhu/internal/remote"
 	"git.stormux.org/storm/cthulhu/internal/wine"
 	"github.com/godbus/dbus/v5"
@@ -95,10 +96,17 @@ func (presenter remoteSpeech) presentWineEditor(event remote.AccessibleEvent) bo
 	// character identity for navigation and Backspace as well as typing.
 	kinds := strings.Fields(event.States)
 	inserted := slices.Contains(kinds, "kind=8")
+	settings := config.DefaultSettings()
+	if presenter.live != nil {
+		settings = presenter.live.Load()
+	}
+	if inserted && !wineTypingEchoEnabled(event.Name, settings) {
+		return false
+	}
 	character := inserted || utf8.RuneCountInString(event.Name) == 1
 	custom := false
 	if character && presenter.live != nil && (inserted || slices.Contains(kinds, "kind=7")) {
-		custom = customEcho(presenter.live.Load(), "character")
+		custom = customEcho(settings, "character")
 	}
 	return presenter.presentRequest(speechRequest{
 		Text: event.Name, Role: "system", Cause: "wine-accessible-event", Append: true,

internal/app/wine_events.go

@@ -7,7 +7,11 @@ import (
 	"strings"
 	"sync"
 	"time"
+	"unicode/utf8"
 
+	"git.stormux.org/storm/cthulhu/internal/atspi"
+	"git.stormux.org/storm/cthulhu/internal/config"
+	"git.stormux.org/storm/cthulhu/internal/presentation"
 	"git.stormux.org/storm/cthulhu/internal/remote"
 )
 
@@ -40,6 +44,24 @@ func newWineEventPresenter(present func(string) bool) *wineEventPresenter {
 	return &wineEventPresenter{present: present}
 }
 
+// wineTypingEchoEnabled applies the native insertion policy to the helper's
+// character labels. Navigation and deletion do not pass through this filter.
+func wineTypingEchoEnabled(text string, settings config.Settings) bool {
+	switch text {
+	case "tab", "new line":
+		return settings.EnableKeyEcho && settings.EnableActionKeys
+	case "space":
+		text = " "
+	}
+	// The helper sends one accepted character per insertion. Do not treat an
+	// unexpected label as a multi-character paste, which has a different policy.
+	if utf8.RuneCountInString(text) != 1 {
+		return false
+	}
+	event := atspi.Event{Type: atspi.TextInsertedEvent, Payload: text}
+	return presentation.EventTextWithOptions(event, presentationSettingsFromConfig(settings, false)) != ""
+}
+
 func (owner *wineEventPresenter) Present(event remote.AccessibleEvent) bool {
 	return owner.present_event(event, nil)
 }

internal/app/wine_events_native_test.go

@@ -11,6 +11,7 @@ import (
 	"testing"
 	"time"
 
+	"git.stormux.org/storm/cthulhu/internal/config"
 	"git.stormux.org/storm/cthulhu/internal/remote"
 	"github.com/godbus/dbus/v5"
 )
@@ -32,7 +33,10 @@ func TestNativeSessionBusWineEvents(t *testing.T) {
 		t.Skip("set CTHULHU_NATIVE_DBUS_TEST=1 inside a private session bus")
 	}
 	output := &wineTestOutput{speech: make(chan speechRequest, 32), braille: make(chan string, 32)}
-	handler := remoteSpeech{speech: output, braille: output}
+	settings := config.DefaultSettings()
+	live := &liveSettings{}
+	live.Store(settings)
+	handler := remoteSpeech{speech: output, braille: output, live: live}
 	owner := newWineEventPresenter(func(message string) bool {
 		return handler.presentMessage(message, "wine-accessible-event")
 	})
@@ -71,6 +75,19 @@ func TestNativeSessionBusWineEvents(t *testing.T) {
 	for _, text := range []string{"A", "a", "É", "é"} {
 		send(remote.AccessibleEvent{SourceID: "42:text", EventType: "text", Name: text, States: "start=1 end=1 kind=8"}, true)
 	}
+	settings.EnableKeyEcho = false
+	live.Store(settings)
+	for _, text := range []string{"A", "space", "tab", "new line"} {
+		send(remote.AccessibleEvent{SourceID: "42:text", EventType: "text", Name: text, States: "kind=8"}, false)
+	}
+	send(remote.AccessibleEvent{SourceID: "42:text", EventType: "text", Name: "e", States: "kind=7"}, true)
+	settings.EnableKeyEcho = true
+	settings.EnableAlphabeticKeys = false
+	live.Store(settings)
+	send(remote.AccessibleEvent{SourceID: "42:text", EventType: "text", Name: "A", States: "kind=8"}, false)
+	settings.EnableAlphabeticKeys = true
+	live.Store(settings)
+	send(remote.AccessibleEvent{SourceID: "42:text", EventType: "text", Name: "A", States: "kind=8"}, true)
 	send(remote.AccessibleEvent{SourceID: "check", EventType: "focus", Name: "Option", Role: "check box", States: "not checked"}, true)
 	owner.flush()
 	send(remote.AccessibleEvent{SourceID: "check", EventType: "name", Name: "Renamed", Role: "check box", States: "not checked"}, true)
@@ -87,7 +104,7 @@ func TestNativeSessionBusWineEvents(t *testing.T) {
 	send(remote.AccessibleEvent{SourceID: "no", EventType: "focus", Name: "No", Role: "client"}, true)
 	owner.flush()
 	owner.Close()
-	for _, want := range []string{"edit, hello", "l", "l", "e selected", "e deleted", "A", "a", "É", "é", "Option, check box, not checked", "Renamed, check box, not checked", "Renamed, check box, checked, unavailable", "Yes", "No"} {
+	for _, want := range []string{"edit, hello", "l", "l", "e selected", "e deleted", "A", "a", "É", "é", "e", "A", "Option, check box, not checked", "Renamed, check box, not checked", "Renamed, check box, checked, unavailable", "Yes", "No"} {
 		select {
 		case request := <-output.speech:
 			if request.Text != want || !request.Append {

internal/app/wine_typing_echo_settings_test.go

@@ -0,0 +1,117 @@
+// Copyright (c) 2026 Storm Dragon
+// Authors: Storm Dragon, Angus Kola
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+package app
+
+import (
+	"testing"
+
+	"git.stormux.org/storm/cthulhu/internal/config"
+	"git.stormux.org/storm/cthulhu/internal/remote"
+)
+
+func TestWineTypingEchoUsesLiveSettings(t *testing.T) {
+	settings := config.DefaultSettings()
+	live := &liveSettings{}
+	live.Store(settings)
+	speech := &remoteSpeechQueue{}
+	braille := &remoteBrailleQueue{running: true}
+	presenter := remoteSpeech{speech: speech, braille: braille, live: live}
+	owner := newWineEventPresenter(func(message string) bool {
+		return presenter.presentMessage(message, "wine-accessible-event")
+	})
+	defer owner.Close()
+	presenter.wine = owner
+	presenter.PresentAccessibleEvent(remote.AccessibleEvent{SourceID: "edit", EventType: "focus", Role: "edit"})
+	owner.flush()
+	check := func(text, kind string, want bool) {
+		t.Helper()
+		beforeSpeech, beforeBraille := len(speech.requests), len(braille.text)
+		accepted := presenter.PresentAccessibleEvent(remote.AccessibleEvent{
+			SourceID: "edit", EventType: "text", Name: text, States: "start=1 end=1 kind=" + kind,
+		})
+		if accepted != want {
+			t.Errorf("%q kind=%s accepted=%v, want %v", text, kind, accepted, want)
+		}
+		if !want {
+			if len(speech.requests) != beforeSpeech || len(braille.text) != beforeBraille {
+				t.Errorf("disabled typing %q reached output", text)
+			}
+			return
+		}
+		if len(speech.requests) != beforeSpeech+1 || speech.requests[beforeSpeech].Text != text ||
+			len(braille.text) != beforeBraille+1 || braille.text[beforeBraille] != text {
+			t.Errorf("enabled action %q missing from speech or braille", text)
+		}
+	}
+	for _, text := range []string{"A", "a", "a", "É", "𐐀", "7", "!", "😀", "space", "tab", "new line"} {
+		check(text, "8", true)
+	}
+	settings.EnableKeyEcho = false
+	settings.EnableEchoByCharacter = true
+	live.Store(settings)
+	for _, text := range []string{"a", "7", "!", "space", "tab", "new line"} {
+		check(text, "8", false)
+	}
+	// Reading, deletion and selection remain available with key echo disabled.
+	for _, action := range []struct{ text, kind string }{
+		{"a", "5"}, {"a", "7"}, {"line of text", "1"}, {"a selected", "2"}, {"a deleted", "4"},
+	} {
+		check(action.text, action.kind, true)
+	}
+	settings.EnableKeyEcho = true
+	settings.EnableEchoByCharacter = false
+	settings.EnableAlphabeticKeys = false
+	settings.EnableNumericKeys = false
+	settings.EnablePunctuationKeys = false
+	settings.EnableSpace = false
+	settings.EnableActionKeys = false
+	live.Store(settings)
+	for _, text := range []string{"A", "é", "𐐀", "7", "!", "😀", "space", "tab", "new line", "́"} {
+		check(text, "8", false)
+	}
+	settings.EnableEchoByCharacter = true
+	live.Store(settings)
+	for _, text := range []string{"A", "é", "7", "!", "😀", "space", "́"} {
+		check(text, "8", true)
+	}
+	for _, text := range []string{"tab", "new line"} {
+		check(text, "8", false)
+	}
+	settings.EnableEchoByCharacter = false
+	settings.EnableDiacriticalKeys = true
+	settings.EnableActionKeys = true
+	live.Store(settings)
+	for _, text := range []string{"́", "tab", "new line"} {
+		check(text, "8", true)
+	}
+	settings = config.DefaultSettings()
+	live.Store(settings)
+	check("a", "8", true)
+}
+
+func TestWineTypingEchoFiltersCategoriesIndependently(t *testing.T) {
+	for _, tc := range []struct {
+		name, blocked, allowed string
+		disable                func(*config.Settings)
+	}{
+		{"alphabetic", "É", "7", func(s *config.Settings) { s.EnableAlphabeticKeys = false }},
+		{"numeric", "7", "a", func(s *config.Settings) { s.EnableNumericKeys = false }},
+		{"punctuation", "!", "a", func(s *config.Settings) { s.EnablePunctuationKeys = false }},
+		{"symbol", "😀", "a", func(s *config.Settings) { s.EnablePunctuationKeys = false }},
+		{"space", "space", "a", func(s *config.Settings) { s.EnableSpace = false }},
+		{"action", "tab", "space", func(s *config.Settings) { s.EnableActionKeys = false }},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			settings := config.DefaultSettings()
+			tc.disable(&settings)
+			if wineTypingEchoEnabled(tc.blocked, settings) {
+				t.Errorf("disabled category echoed %q", tc.blocked)
+			}
+			if !wineTypingEchoEnabled(tc.allowed, settings) {
+				t.Errorf("unrelated category suppressed %q", tc.allowed)
+			}
+		})
+	}
+}