Improve auto-send reliability with AX-based paste detection

[gulliversgames]

Summary

• Dismiss recorder before pasting so macOS refocuses the target window first — previously paste keystrokes could miss the target window because the recorder panel was still visible
• Capture auto-send key before dismiss — dismissMiniRecorder clears the Power Mode config, so the auto-send key was always nil by the time it was read
• Replace fixed delay with AX-based detection — polls the focused text field's AXValue every 50ms (up to 3s) to confirm the paste has landed before sending the auto-send keystroke. Works for any text length. Falls back to a timeout for apps where AXValue isn't readable (e.g. some web apps)

Problem

The auto-send feature (sending Enter/Shift+Enter/Cmd+Enter after paste) was unreliable:

1. The recorder panel was still visible when paste fired, so keystrokes sometimes went to the wrong window
2. The Power Mode config was cleared during dismiss before the auto-send key could be read
3. The fixed 100ms delay between paste and auto-send was too short for long texts — the target app hadn't finished processing the paste

Test plan

• Record with a Power Mode that has auto-send enabled (e.g. Return key)
• Verify paste lands in the correct window
• Verify Enter fires after the text appears (not before)
• Test with short text ("yes") — Enter should fire almost immediately
• Test with long text (30+ seconds of dictation) — Enter should wait for the full text to appear
• Test with apps where AXValue may not be readable (e.g. browser text fields) — should fall back to 3s timeout

🤖 Generated with Claude Code

---

Summary by cubic

Improves auto-send reliability by dismissing the recorder before paste, capturing the auto-send key earlier, and using AX-based detection to wait for the paste to land. Prevents misdirected keystrokes and sends Enter only after text appears.

• Bug Fixes
  • Dismiss mini recorder before paste so macOS refocuses the target window; wait ~150ms before pasting to let focus settle.
  • Capture the auto-send key before dismiss clears the Power Mode config.
  • Replace fixed delay with AX polling of the focused field’s value (snapshot pre-paste, poll every 50ms up to 3s); fall back to a short 300ms delay when AX isn’t readable.

^{Written for commit 6dc3f12. Summary will update on new commits.}

[cubic-dev-ai]

2 issues found across 2 files

Prompt for AI agents (unresolved issues)

Check if these issues are valid — if so, understand the root cause of each and fix them. If appropriate, use sub-agents to investigate and fix each issue separately.


<file name="VoiceInk/CursorPaster.swift">

<violation number="1" location="VoiceInk/CursorPaster.swift:116">
P1: Auto-send polling runs in an uncancelled detached task and can fire Enter into a different app/field after focus changes.</violation>

<violation number="2" location="VoiceInk/CursorPaster.swift:126">
P2: Paste completion detection is too weak (`contains(prefix)`), allowing false positives (including empty-text immediate match) and premature auto-send before paste is actually applied.</violation>
</file>

_{Reply with feedback, questions, or to request a fix. Tag @cubic-dev-ai to re-run a review.}

[cubic-dev-ai]

P1: Auto-send polling runs in an uncancelled detached task and can fire Enter into a different app/field after focus changes.

Prompt for AI agents

Check if this issue is valid — if so, understand the root cause and fix it. At VoiceInk/CursorPaster.swift, line 116:

<comment>Auto-send polling runs in an uncancelled detached task and can fire Enter into a different app/field after focus changes.</comment>

<file context>
@@ -100,6 +100,66 @@ class CursorPaster {
+        guard autoSendKey.isEnabled else { return }
+
+        // Poll the focused element's AXValue to detect when paste has landed.
+        Task.detached {
+            let maxWait: TimeInterval = 3.0
+            let pollInterval: UInt64 = 50_000_000 // 50ms
</file context>

[brutes1]

Code review

Found 3 issues:

1. AutoLearnVocabularyService calls are dropped on merge. This PR branched before commit ca705f9 added AutoLearnVocabularyService.shared.prepareMonitoring() and AutoLearnVocabularyService.shared.beginMonitoring() into the same paste dispatch block this PR rewrites. The new DispatchQueue.main.asyncAfter block only calls pasteAndAutoSend or pasteAtCursor — neither service call is present. Merging as-is will silently stop the auto-learn vocabulary feature from firing on every transcription.

VoiceInk/VoiceInk/Whisper/TranscriptionPipeline.swift

Lines 184 to 193 in 6dc3f12

	\n\(textToPaste)
	"""
	}
	DispatchQueue.main.asyncAfter(deadline: .now() + 0.15) {
	if let autoSendKey, autoSendKey.isEnabled {
	CursorPaster.pasteAndAutoSend(textToPaste, autoSendKey: autoSendKey)
	} else {
	let appendSpace = UserDefaults.standard.bool(forKey: "AppendTrailingSpace")
	CursorPaster.pasteAtCursor(textToPaste + (appendSpace ? " " : ""))

2. Strategy A fires auto-send into the wrong window when focus changes during polling. baselineValue is non-nil (guaranteed by canReadField). If the user switches apps during the 3-second window, getFocusedElementValue() returns nil for the new element. In Swift, nil != "previous text" evaluates to true, so the poll immediately concludes "paste landed" and fires performAutoSend into whichever window is now focused. The fix is to skip the comparison when currentValue is nil rather than treating it as a changed value.

VoiceInk/VoiceInk/CursorPaster.swift

Lines 134 to 142 in 6dc3f12

	while Date().timeIntervalSince(startTime) < maxWait {
	let currentValue = await Self.getFocusedElementValue()
	if currentValue != baselineValue {
	// Field changed — paste landed
	await MainActor.run { performAutoSend(autoSendKey) }
	return
	}
	try? await Task.sleep(nanoseconds: pollInterval)

3. Strategy B's 300ms delay regresses the terminal fix from commit a75ef6f. That commit raised the auto-send delay from 0.1s to 0.5s specifically because terminal emulators (Terminal.app, iTerm2, Warp, Ghostty) need 200–350ms for PTY/readline to process longer dictations. Strategy B fires performAutoSend 300ms after pasteAndAutoSend is called — but pasteAtCursor's internal 50ms delay means Cmd+V doesn't fire until 50ms later, leaving only 250ms between the paste keystroke and the auto-send. That's inside the 200–350ms danger zone for longer dictations in terminals. Strategy B's sleep should be at least 500_000_000 ns (500ms) to restore the prior guarantee.

VoiceInk/VoiceInk/CursorPaster.swift

Lines 148 to 153 in 6dc3f12

	} else {
	// Strategy B: fixed delay for apps where AXValue isn't readable
	// 300ms after paste keystroke (50ms internal + 250ms buffer)
	try? await Task.sleep(nanoseconds: 300_000_000)
	await MainActor.run { performAutoSend(autoSendKey) }
	}

🤖 Generated with Claude Code

_{- If this code review was useful, please react with 👍. Otherwise, react with 👎.}