Superseded by #708: Learn dictionary corrections from target-app edits

[SeoFood]

Context

TypeWhisper already has two useful pieces for this:

• Dictionary corrections can replace recurring transcription mistakes after transcription.
• The History editor can infer correction pairs when a user edits a saved transcription.

The missing workflow is the one users are most likely to use: dictate into the target app, notice one wrong word, fix it in place, and expect TypeWhisper to remember that correction next time.

Proposal

Add an opt-in feature that learns conservative dictionary corrections from edits the user makes directly in the target app shortly after TypeWhisper inserts dictated text.

This should not be a general keylogger or long-running text monitor. It should be a short, bounded follow-up to a TypeWhisper insertion event.

Proposed v1 behavior

• Default off.
• Only runs after direct dictation insertion into a target app.
• Watches only the same focused Accessibility text element that received the insertion.
• Uses a short 10-second observation window after insertion.
• Learns only high-confidence single-token replacements inside the inserted text.
• Stores learned pairs as normal global Dictionary Corrections.
• Shows short indicator feedback when a correction is learned.
• Provides an Undo action for the just-learned correction(s).

Example:

Inserted: Please ask Sarah about teh launch checklist.
User edits in target app: Please ask Sarah about the launch checklist.
Learned correction: teh -> the

Out of scope for v1

• App-specific dictionary corrections.
• Long-running monitoring after the 10-second window.
• Learning from arbitrary text edits that are not anchored to a TypeWhisper insertion.
• Learning from API/CLI, file transcription, action plugins, or recent-transcription reinsert flows.
• Learning multi-sentence rewrites, formatting changes, punctuation-only changes, or case-only edits.

Safety rules

The learner should skip instead of guessing when confidence is low:

• Focus moved to a different AX element.
• The target app no longer exposes readable text state.
• The edit is a large rewrite rather than a localized correction.
• Multiple unrelated changes happened.
• A correction for the same original text already exists.
• The inserted output was rich text or otherwise cannot be reliably mapped back to the plain inserted text.

Implementation sketch

• Extend the insertion path to capture a focused text observation before/after insertion.
• Add a small target-app correction learning service that receives:
  • inserted text,
  • target app metadata,
  • initial/final AX text state,
  • dictionary service,
  • diff service.
• Reuse the existing dictionary correction model rather than creating a new correction store.
• Add batch learning to DictionaryService so the caller knows exactly which new entries were created.
• Keep Undo scoped to the entries created by the most recent learning event.
• Keep the existing History-based correction learning, but route it through the same conservative learn API where practical.

Open questions

• Should the 10-second window be configurable, or fixed for v1?
• Should automatically learned corrections be visually marked in Dictionary settings later?
• Should app-specific corrections be a separate follow-up feature once global learning proves useful?
• Which apps should be part of the first manual smoke test set: Notes, Slack, browsers, Obsidian, or others?

Acceptance criteria

• Users can enable or disable target-app correction learning in settings.
• A supported text field can produce a learned dictionary correction after a local single-word user edit.
• Duplicate corrections are skipped and existing corrections are not overwritten.
• Undo removes only the correction entries created by that learning event.
• Existing History-based correction learning still works.
• Tests cover successful learning, skip cases, duplicate handling, and undo.

[SeoFood]

Superseded by issue #708, which is the intended tracking item. Keeping this discussion only as an accidental duplicate pointer.