zerg-ztc 0.1.10 → 0.1.12

package/dist/components/InputArea.js

@@ -8,7 +8,35 @@ import chalk from 'chalk';
 import { saveClipboardImage } from '../utils/clipboard_image.js';
 import { renderImagePreview } from '../utils/image_preview.js';
 import { completePath } from '../utils/path_complete.js';
+import { isRecording as isLegacyRecording, startRecording as startLegacyRecording, stopRecordingAndTranscribe as stopLegacyRecording, isDictationAvailable as isLegacyDictationAvailable } from '../utils/dictation.js';
+import { isNativeDictationAvailable, isNativeRecording, startNativeRecording, stopNativeRecording } from '../utils/dictation_native.js';
+// Use native dictation if available, otherwise fall back to legacy
+const useNative = isNativeDictationAvailable();
+const isRecording = () => useNative ? isNativeRecording() : isLegacyRecording();
+const isDictationAvailable = () => useNative ? true : isLegacyDictationAvailable();
 import { createEmptyState, insertText, insertBadge, backspace, deleteForward, moveLeft, moveRight, moveWordLeft, moveWordRight, getPlainText, serializeSegments, PASTE_BADGE_THRESHOLD } from '../ui/core/input_segments.js';
+// Helper to check for Ctrl key combinations
+// Handles multiple formats:
+// 1. Ink's key.ctrl + letter
+// 2. Traditional control characters (\x01 for Ctrl+A, etc.)
+// 3. Kitty keyboard protocol: [<keycode>;5u where keycode is ASCII, 5 = Ctrl
+function isCtrl(input, key, letter) {
+    const lowerLetter = letter.toLowerCase();
+    // Method 1: Ink's key.ctrl flag
+    if (key.ctrl && input === lowerLetter)
+        return true;
+    // Method 2: Traditional control character (Ctrl+A = \x01, etc.)
+    const ctrlCode = lowerLetter.charCodeAt(0) - 96; // 'a' -> 1, 'b' -> 2, etc.
+    if (input === String.fromCharCode(ctrlCode))
+        return true;
+    // Method 3: Kitty keyboard protocol [<keycode>;5u (fallback, main handling is in handleKittyInput)
+    // keycode is ASCII code of the letter, 5 = Ctrl modifier
+    const asciiCode = lowerLetter.charCodeAt(0); // 'a' -> 97, 'r' -> 114, etc.
+    const kittyPattern = `[${asciiCode};5u`;
+    if (input === kittyPattern || input === `\x1b${kittyPattern}`)
+        return true;
+    return false;
+}
 const initialState = createEmptyState();
 function reducer(state, action) {
     switch (action.type) {
@@ -58,12 +86,13 @@ function reducer(state, action) {
             return state;
     }
 }
-export const InputArea = ({ onSubmit, onCommand, commands = [], onStateChange, onToast, cols = process.stdout.columns || 80, inputBus, disabled = false, placeholder = 'Type a message...', historyEnabled = true, debug = false, cwd = process.cwd() }) => {
+export const InputArea = ({ onSubmit, onCommand, commands = [], onStateChange, onToast, onDictationStateChange, cols = process.stdout.columns || 80, inputBus, disabled = false, placeholder = 'Type a message...', historyEnabled = true, debug = false, cwd = process.cwd() }) => {
     const [state, dispatch] = useReducer(reducer, initialState);
     const stateRef = React.useRef(state);
     const [badgePreview, setBadgePreview] = React.useState(null);
     const killRingRef = React.useRef([]);
     const killIndexRef = React.useRef(-1);
+    const dictationBusyRef = React.useRef(false);
     // Bracketed paste mode support - buffer paste content between \x1b[200~ and \x1b[201~
     const pasteBufferRef = React.useRef('');
     const isPastingRef = React.useRef(false);
@@ -424,6 +453,165 @@ export const InputArea = ({ onSubmit, onCommand, commands = [], onStateChange, o
     }, [insertTextIntoOverlay, insertTextIntoState, onToast, renderOverlay]);
     // Update ref so handleSubmit can access it
     handleClipboardImagePasteRef.current = handleClipboardImagePaste;
+    // Handle Kitty keyboard protocol sequences directly
+    // This is called when we detect a Kitty sequence in handleInput
+    const handleKittyInput = useCallback((char, key, keycode, modifier) => {
+        if (disabled)
+            return;
+        const isKittyCtrl = modifier === 5;
+        const isKittyMeta = modifier === 9;
+        const lowerChar = char.toLowerCase();
+        // Navigation
+        if (isKittyCtrl && lowerChar === 'a') {
+            dispatch({ type: 'apply', state: { cursor: { index: 0, offset: 0 } } });
+            return;
+        }
+        if (isKittyCtrl && lowerChar === 'e') {
+            dispatch({ type: 'apply', state: { cursor: { index: state.segments.length, offset: 0 } } });
+            return;
+        }
+        if (isKittyCtrl && lowerChar === 'b') {
+            dispatch({ type: 'apply', state: moveLeft(state) });
+            return;
+        }
+        if (isKittyCtrl && lowerChar === 'f') {
+            dispatch({ type: 'apply', state: moveRight(state) });
+            return;
+        }
+        if (isKittyCtrl && lowerChar === 'p') {
+            navigateHistory('up');
+            return;
+        }
+        if (isKittyCtrl && lowerChar === 'n') {
+            navigateHistory('down');
+            return;
+        }
+        // Kill/yank
+        if (isKittyCtrl && lowerChar === 'u') {
+            const { next, killed } = killToStart(state);
+            pushKill(killed);
+            dispatch({ type: 'apply', state: next });
+            return;
+        }
+        if (isKittyCtrl && lowerChar === 'k') {
+            const { next, killed } = killToEnd(state);
+            pushKill(killed);
+            dispatch({ type: 'apply', state: next });
+            return;
+        }
+        if (isKittyCtrl && lowerChar === 'y') {
+            dispatch({ type: 'apply', state: yank(state) });
+            return;
+        }
+        if (isKittyCtrl && lowerChar === 'w') {
+            const { next, killed } = killWordBackward(state);
+            pushKill(killed);
+            dispatch({ type: 'apply', state: next });
+            return;
+        }
+        // Transpose
+        if (isKittyCtrl && lowerChar === 't') {
+            dispatch({ type: 'apply', state: transposeChars(state) });
+            return;
+        }
+        // Delete forward
+        if (isKittyCtrl && lowerChar === 'd') {
+            dispatch({ type: 'apply', state: deleteForward(state) });
+            return;
+        }
+        // Push-to-talk: Ctrl+R to toggle recording
+        if (isKittyCtrl && lowerChar === 'r') {
+            if (dictationBusyRef.current)
+                return;
+            if (isRecording()) {
+                // Stop recording and transcribe
+                dictationBusyRef.current = true;
+                onDictationStateChange?.('transcribing');
+                if (useNative) {
+                    stopNativeRecording()
+                        .then((text) => {
+                        if (text && text.trim()) {
+                            // Submit the transcribed text directly
+                            onSubmit(text.trim());
+                        }
+                        else {
+                            onToast?.('No speech detected');
+                        }
+                    })
+                        .catch((err) => {
+                        onToast?.(`Dictation error: ${err.message}`);
+                    })
+                        .finally(() => {
+                        dictationBusyRef.current = false;
+                        onDictationStateChange?.('idle');
+                    });
+                }
+                else {
+                    stopLegacyRecording()
+                        .then((result) => {
+                        if (result.text && result.text.trim()) {
+                            // Submit the transcribed text directly
+                            onSubmit(result.text.trim());
+                        }
+                        else {
+                            onToast?.('No speech detected');
+                        }
+                    })
+                        .catch((err) => {
+                        onToast?.(`Dictation error: ${err.message}`);
+                    })
+                        .finally(() => {
+                        dictationBusyRef.current = false;
+                        onDictationStateChange?.('idle');
+                    });
+                }
+            }
+            else {
+                // Start recording
+                if (!isDictationAvailable()) {
+                    onToast?.('Dictation not available. Build native/ztc-audio or install sox');
+                    return;
+                }
+                try {
+                    if (useNative) {
+                        startNativeRecording({ model: 'tiny' });
+                    }
+                    else {
+                        startLegacyRecording();
+                    }
+                    onDictationStateChange?.('recording');
+                }
+                catch (err) {
+                    onToast?.(`Recording error: ${err instanceof Error ? err.message : 'Unknown'}`);
+                }
+            }
+            return;
+        }
+        // Meta key combinations
+        if (isKittyMeta && lowerChar === 'y') {
+            dispatch({ type: 'apply', state: yankPop(state) });
+            return;
+        }
+        if (isKittyMeta && lowerChar === 't') {
+            dispatch({ type: 'apply', state: transposeWords(state) });
+            return;
+        }
+        if (isKittyMeta && lowerChar === 'd') {
+            const { next, killed } = killWordForward(state);
+            pushKill(killed);
+            dispatch({ type: 'apply', state: next });
+            return;
+        }
+        if (isKittyMeta && lowerChar === 'b') {
+            dispatch({ type: 'apply', state: moveWordLeft(state) });
+            return;
+        }
+        if (isKittyMeta && lowerChar === 'f') {
+            dispatch({ type: 'apply', state: moveWordRight(state) });
+            return;
+        }
+        // Unknown Kitty sequence - don't insert as text
+    }, [disabled, killToEnd, killToStart, killWordBackward, killWordForward, navigateHistory, onDictationStateChange, onToast, pushKill, state, transposeChars, transposeWords, yank, yankPop]);
     const handleInput = useCallback((input, key) => {
         // Detect Kitty keyboard protocol CSI u sequences
         // Format: ESC [ <keycode> ; <modifiers> u
@@ -435,23 +623,33 @@ export const InputArea = ({ onSubmit, onCommand, commands = [], onStateChange, o
             void handleClipboardImagePaste('state');
             return;
         }
-        // Consume any other Kitty sequences to prevent them from being displayed
-        // Match pattern: ESC? [ number ; number u
-        if (/\x1b?\[\d+;\d+u/.test(input)) {
-            // This is a Kitty keyboard sequence - don't display it as text
-            // Extract what key it is and handle accordingly
-            const match = input.match(/\x1b?\[(\d+);(\d+)u/);
-            if (match) {
-                const keycode = parseInt(match[1], 10);
-                const modifier = parseInt(match[2], 10);
-                // Ctrl+C (99;5) or Cmd+C (99;9) - exit the app
-                if (keycode === 99 && (modifier === 5 || modifier === 9)) {
-                    exit();
-                    return;
-                }
-                // Ctrl+L (108;5) - could add clear screen here if needed
+        // Handle Kitty keyboard protocol sequences
+        // Format: ESC? [ keycode ; modifier u
+        // Modifier 5 = Ctrl, modifier 9 = Cmd/Super
+        const kittyMatch = input.match(/\x1b?\[(\d+);(\d+)u/);
+        if (kittyMatch) {
+            const keycode = parseInt(kittyMatch[1], 10);
+            const modifier = parseInt(kittyMatch[2], 10);
+            const isKittyCtrl = modifier === 5;
+            const isKittyMeta = modifier === 9;
+            // Ctrl+C (99;5) or Cmd+C (99;9) - exit the app
+            if (keycode === 99 && (isKittyCtrl || isKittyMeta)) {
+                exit();
+                return;
             }
-            return; // Consume other Kitty sequences
+            // Synthesize key flags for Kitty sequences so downstream handlers work
+            const kittyKey = {
+                ...key,
+                ctrl: isKittyCtrl || key.ctrl,
+                meta: isKittyMeta || key.meta,
+            };
+            // Convert keycode to character for isCtrl checks
+            const kittyChar = String.fromCharCode(keycode);
+            // Route to handlers based on keycode
+            // Let the normal handler flow process this with synthesized key flags
+            // by falling through with modified key/input
+            handleKittyInput(kittyChar, kittyKey, keycode, modifier);
+            return;
         }
         if (disabled)
             return;
@@ -601,27 +799,27 @@ export const InputArea = ({ onSubmit, onCommand, commands = [], onStateChange, o
             }
             return;
         }
-        if (key.ctrl && input === 'a') {
+        if (isCtrl(input, key, 'a')) {
             dispatch({ type: 'apply', state: { cursor: { index: 0, offset: 0 } } });
             return;
         }
-        if (key.ctrl && input === 'e') {
+        if (isCtrl(input, key, 'e')) {
             dispatch({ type: 'apply', state: { cursor: { index: state.segments.length, offset: 0 } } });
             return;
         }
-        if (key.ctrl && input === 'b') {
+        if (isCtrl(input, key, 'b')) {
             dispatch({ type: 'apply', state: moveLeft(state) });
             return;
         }
-        if (key.ctrl && input === 'f') {
+        if (isCtrl(input, key, 'f')) {
             dispatch({ type: 'apply', state: moveRight(state) });
             return;
         }
-        if (key.ctrl && input === 'p') {
+        if (isCtrl(input, key, 'p')) {
             navigateHistory('up');
             return;
         }
-        if (key.ctrl && input === 'n') {
+        if (isCtrl(input, key, 'n')) {
             navigateHistory('down');
             return;
         }
@@ -631,19 +829,19 @@ export const InputArea = ({ onSubmit, onCommand, commands = [], onStateChange, o
             dispatch({ type: 'apply', state: next });
             return;
         }
-        if (key.ctrl && input === 'u') {
+        if (isCtrl(input, key, 'u')) {
             const { next, killed } = killToStart(state);
             pushKill(killed);
             dispatch({ type: 'apply', state: next });
             return;
         }
-        if (key.ctrl && input === 'k') {
+        if (isCtrl(input, key, 'k')) {
             const { next, killed } = killToEnd(state);
             pushKill(killed);
             dispatch({ type: 'apply', state: next });
             return;
         }
-        if (key.ctrl && input === 'y') {
+        if (isCtrl(input, key, 'y')) {
             dispatch({ type: 'apply', state: yank(state) });
             return;
         }
@@ -651,7 +849,75 @@ export const InputArea = ({ onSubmit, onCommand, commands = [], onStateChange, o
             dispatch({ type: 'apply', state: yankPop(state) });
             return;
         }
-        if (key.ctrl && input === 't') {
+        // Push-to-talk: Ctrl+R to toggle recording
+        if (isCtrl(input, key, 'r')) {
+            if (dictationBusyRef.current)
+                return;
+            if (isRecording()) {
+                // Stop recording and transcribe
+                dictationBusyRef.current = true;
+                onDictationStateChange?.('transcribing');
+                if (useNative) {
+                    stopNativeRecording()
+                        .then((text) => {
+                        if (text && text.trim()) {
+                            // Submit the transcribed text directly
+                            onSubmit(text.trim());
+                        }
+                        else {
+                            onToast?.('No speech detected');
+                        }
+                    })
+                        .catch((err) => {
+                        onToast?.(`Dictation error: ${err.message}`);
+                    })
+                        .finally(() => {
+                        dictationBusyRef.current = false;
+                        onDictationStateChange?.('idle');
+                    });
+                }
+                else {
+                    stopLegacyRecording()
+                        .then((result) => {
+                        if (result.text && result.text.trim()) {
+                            // Submit the transcribed text directly
+                            onSubmit(result.text.trim());
+                        }
+                        else {
+                            onToast?.('No speech detected');
+                        }
+                    })
+                        .catch((err) => {
+                        onToast?.(`Dictation error: ${err.message}`);
+                    })
+                        .finally(() => {
+                        dictationBusyRef.current = false;
+                        onDictationStateChange?.('idle');
+                    });
+                }
+            }
+            else {
+                // Start recording
+                if (!isDictationAvailable()) {
+                    onToast?.('Dictation not available. Build native/ztc-audio or install sox');
+                    return;
+                }
+                try {
+                    if (useNative) {
+                        startNativeRecording({ model: 'tiny' });
+                    }
+                    else {
+                        startLegacyRecording();
+                    }
+                    onDictationStateChange?.('recording');
+                }
+                catch (err) {
+                    onToast?.(`Recording error: ${err instanceof Error ? err.message : 'Unknown'}`);
+                }
+            }
+            return;
+        }
+        if (isCtrl(input, key, 't')) {
             dispatch({ type: 'apply', state: transposeChars(state) });
             return;
         }
@@ -659,11 +925,11 @@ export const InputArea = ({ onSubmit, onCommand, commands = [], onStateChange, o
             dispatch({ type: 'apply', state: transposeWords(state) });
             return;
         }
-        if (key.ctrl && input === 'd') {
+        if (isCtrl(input, key, 'd')) {
             dispatch({ type: 'apply', state: deleteForward(state) });
             return;
         }
-        if (key.ctrl && input === 'w') {
+        if (isCtrl(input, key, 'w')) {
             const { next, killed } = killWordBackward(state);
             pushKill(killed);
             dispatch({ type: 'apply', state: next });
@@ -701,10 +967,222 @@ export const InputArea = ({ onSubmit, onCommand, commands = [], onStateChange, o
             const next = insertText(state, input);
             dispatch({ type: 'apply', state: { ...next, historyIdx: -1 } });
         }
-    }, [disabled, exit, handleClipboardImagePaste, handleSubmit, navigateHistory, state]);
+    }, [disabled, exit, handleClipboardImagePaste, handleKittyInput, handleSubmit, navigateHistory, state]);
+    // Handle Kitty keyboard protocol sequences for overlay mode
+    const handleKittyOverlayInput = useCallback((char, key, keycode, modifier) => {
+        if (disabled)
+            return;
+        const current = overlayStateRef.current;
+        const isKittyCtrl = modifier === 5;
+        const isKittyMeta = modifier === 9;
+        const lowerChar = char.toLowerCase();
+        // Navigation
+        if (isKittyCtrl && lowerChar === 'a') {
+            overlayStateRef.current = { ...current, cursor: { index: 0, offset: 0 } };
+            renderOverlay(overlayStateRef.current);
+            return;
+        }
+        if (isKittyCtrl && lowerChar === 'e') {
+            overlayStateRef.current = { ...current, cursor: { index: current.segments.length, offset: 0 } };
+            renderOverlay(overlayStateRef.current);
+            return;
+        }
+        if (isKittyCtrl && lowerChar === 'b') {
+            overlayStateRef.current = moveLeft(current);
+            renderOverlay(overlayStateRef.current);
+            return;
+        }
+        if (isKittyCtrl && lowerChar === 'f') {
+            overlayStateRef.current = moveRight(current);
+            renderOverlay(overlayStateRef.current);
+            return;
+        }
+        if (isKittyCtrl && lowerChar === 'p') {
+            if (historyEnabled && current.history.length > 0) {
+                const newIdx = current.historyIdx === -1 ? current.history.length - 1 : Math.max(0, current.historyIdx - 1);
+                const historyValue = current.history[newIdx] || '';
+                overlayStateRef.current = {
+                    ...current,
+                    historyIdx: newIdx,
+                    segments: historyValue.length > 0 ? [{ type: 'text', text: historyValue }] : [],
+                    cursor: { index: historyValue.length > 0 ? 0 : 0, offset: historyValue.length }
+                };
+                renderOverlay(overlayStateRef.current);
+            }
+            return;
+        }
+        if (isKittyCtrl && lowerChar === 'n') {
+            if (historyEnabled && current.history.length > 0) {
+                let newIdx = current.historyIdx === -1 ? -1 : current.historyIdx + 1;
+                if (newIdx >= current.history.length)
+                    newIdx = -1;
+                if (newIdx === -1) {
+                    overlayStateRef.current = { ...createEmptyState(), history: current.history, historyIdx: -1 };
+                }
+                else {
+                    const historyValue = current.history[newIdx];
+                    overlayStateRef.current = {
+                        ...current,
+                        historyIdx: newIdx,
+                        segments: historyValue.length > 0 ? [{ type: 'text', text: historyValue }] : [],
+                        cursor: { index: historyValue.length > 0 ? 0 : 0, offset: historyValue.length }
+                    };
+                }
+                renderOverlay(overlayStateRef.current);
+            }
+            return;
+        }
+        // Kill/yank
+        if (isKittyCtrl && lowerChar === 'u') {
+            const { next, killed } = killToStart(current);
+            pushKill(killed);
+            overlayStateRef.current = { ...next, history: current.history, historyIdx: -1 };
+            renderOverlay(overlayStateRef.current);
+            return;
+        }
+        if (isKittyCtrl && lowerChar === 'k') {
+            const { next, killed } = killToEnd(current);
+            pushKill(killed);
+            overlayStateRef.current = next;
+            renderOverlay(overlayStateRef.current);
+            return;
+        }
+        if (isKittyCtrl && lowerChar === 'y') {
+            overlayStateRef.current = yank(current);
+            renderOverlay(overlayStateRef.current);
+            return;
+        }
+        if (isKittyCtrl && lowerChar === 'w') {
+            const { next, killed } = killWordBackward(current);
+            pushKill(killed);
+            overlayStateRef.current = next;
+            renderOverlay(overlayStateRef.current);
+            return;
+        }
+        // Transpose
+        if (isKittyCtrl && lowerChar === 't') {
+            overlayStateRef.current = transposeChars(current);
+            renderOverlay(overlayStateRef.current);
+            return;
+        }
+        // Delete forward
+        if (isKittyCtrl && lowerChar === 'd') {
+            overlayStateRef.current = deleteForward(current);
+            renderOverlay(overlayStateRef.current);
+            return;
+        }
+        // Push-to-talk: Ctrl+R to toggle recording
+        if (isKittyCtrl && lowerChar === 'r') {
+            if (dictationBusyRef.current)
+                return;
+            if (isRecording()) {
+                dictationBusyRef.current = true;
+                onDictationStateChange?.('transcribing');
+                if (useNative) {
+                    stopNativeRecording()
+                        .then((text) => {
+                        if (text && text.trim()) {
+                            // Submit the transcribed text directly
+                            onSubmit(text.trim());
+                            overlayStateRef.current = { ...overlayStateRef.current, segments: [], cursor: { index: 0, offset: 0 }, historyIdx: -1 };
+                            renderOverlay(overlayStateRef.current);
+                        }
+                        else {
+                            onToast?.('No speech detected');
+                        }
+                    })
+                        .catch((err) => {
+                        onToast?.(`Dictation error: ${err.message}`);
+                    })
+                        .finally(() => {
+                        dictationBusyRef.current = false;
+                        onDictationStateChange?.('idle');
+                    });
+                }
+                else {
+                    stopLegacyRecording()
+                        .then((result) => {
+                        if (result.text && result.text.trim()) {
+                            // Submit the transcribed text directly
+                            onSubmit(result.text.trim());
+                            overlayStateRef.current = { ...overlayStateRef.current, segments: [], cursor: { index: 0, offset: 0 }, historyIdx: -1 };
+                            renderOverlay(overlayStateRef.current);
+                        }
+                        else {
+                            onToast?.('No speech detected');
+                        }
+                    })
+                        .catch((err) => {
+                        onToast?.(`Dictation error: ${err.message}`);
+                    })
+                        .finally(() => {
+                        dictationBusyRef.current = false;
+                        onDictationStateChange?.('idle');
+                    });
+                }
+            }
+            else {
+                if (!isDictationAvailable()) {
+                    onToast?.('Dictation not available. Build native/ztc-audio or install sox');
+                    return;
+                }
+                try {
+                    if (useNative) {
+                        startNativeRecording({ model: 'tiny' });
+                    }
+                    else {
+                        startLegacyRecording();
+                    }
+                    onDictationStateChange?.('recording');
+                }
+                catch (err) {
+                    onToast?.(`Recording error: ${err instanceof Error ? err.message : 'Unknown'}`);
+                }
+            }
+            return;
+        }
+        // Meta key combinations
+        if (isKittyMeta && lowerChar === 'y') {
+            overlayStateRef.current = yankPop(current);
+            renderOverlay(overlayStateRef.current);
+            return;
+        }
+        if (isKittyMeta && lowerChar === 't') {
+            overlayStateRef.current = transposeWords(current);
+            renderOverlay(overlayStateRef.current);
+            return;
+        }
+        if (isKittyMeta && lowerChar === 'd') {
+            const { next, killed } = killWordForward(current);
+            pushKill(killed);
+            overlayStateRef.current = next;
+            renderOverlay(overlayStateRef.current);
+            return;
+        }
+        if (isKittyMeta && lowerChar === 'b') {
+            overlayStateRef.current = moveWordLeft(current);
+            renderOverlay(overlayStateRef.current);
+            return;
+        }
+        if (isKittyMeta && lowerChar === 'f') {
+            overlayStateRef.current = moveWordRight(current);
+            renderOverlay(overlayStateRef.current);
+            return;
+        }
+        // Unknown Kitty sequence - don't insert as text
+    }, [disabled, historyEnabled, killToEnd, killToStart, killWordBackward, killWordForward, onDictationStateChange, onToast, pushKill, renderOverlay, transposeChars, transposeWords, yank, yankPop]);
     const handleOverlayInput = useCallback((input, key) => {
         if (disabled)
             return;
+        // Handle Kitty keyboard protocol sequences for overlay mode
+        const kittyMatch = input.match(/\x1b?\[(\d+);(\d+)u/);
+        if (kittyMatch) {
+            const keycode = parseInt(kittyMatch[1], 10);
+            const modifier = parseInt(kittyMatch[2], 10);
+            const kittyChar = String.fromCharCode(keycode);
+            handleKittyOverlayInput(kittyChar, key, keycode, modifier);
+            return;
+        }
         // Detect backspace via explicit key flag or known control codes
         const backspaceFallback = input === '\b' || input === '\x7f' || input === '\x08';
         const isBackspace = key.backspace || key.delete || backspaceFallback;
@@ -810,27 +1288,27 @@ export const InputArea = ({ onSubmit, onCommand, commands = [], onStateChange, o
             renderOverlay(overlayStateRef.current);
             return;
         }
-        if (key.ctrl && input === 'a') {
+        if (isCtrl(input, key, 'a')) {
             overlayStateRef.current = { ...current, cursor: { index: 0, offset: 0 } };
             renderOverlay(overlayStateRef.current);
             return;
         }
-        if (key.ctrl && input === 'e') {
+        if (isCtrl(input, key, 'e')) {
             overlayStateRef.current = { ...current, cursor: { index: current.segments.length, offset: 0 } };
             renderOverlay(overlayStateRef.current);
             return;
         }
-        if (key.ctrl && input === 'b') {
+        if (isCtrl(input, key, 'b')) {
             overlayStateRef.current = moveLeft(current);
             renderOverlay(overlayStateRef.current);
             return;
         }
-        if (key.ctrl && input === 'f') {
+        if (isCtrl(input, key, 'f')) {
             overlayStateRef.current = moveRight(current);
             renderOverlay(overlayStateRef.current);
             return;
         }
-        if (key.ctrl && input === 'p') {
+        if (isCtrl(input, key, 'p')) {
             const direction = 'up';
             if (historyEnabled && current.history.length > 0) {
                 let newIdx = current.historyIdx === -1 ? current.history.length - 1 : Math.max(0, current.historyIdx - 1);
@@ -845,7 +1323,7 @@ export const InputArea = ({ onSubmit, onCommand, commands = [], onStateChange, o
             }
             return;
         }
-        if (key.ctrl && input === 'n') {
+        if (isCtrl(input, key, 'n')) {
             if (historyEnabled && current.history.length > 0) {
                 let newIdx = current.historyIdx === -1 ? -1 : current.historyIdx + 1;
                 if (newIdx >= current.history.length)
@@ -872,31 +1350,101 @@ export const InputArea = ({ onSubmit, onCommand, commands = [], onStateChange, o
             renderOverlay(overlayStateRef.current);
             return;
         }
-        if (key.ctrl && input === 'u') {
+        if (isCtrl(input, key, 'u')) {
             const { next, killed } = killToStart(current);
             pushKill(killed);
             overlayStateRef.current = { ...next, history: current.history, historyIdx: -1 };
             renderOverlay(overlayStateRef.current);
             return;
         }
-        if (key.ctrl && input === 'k') {
+        if (isCtrl(input, key, 'k')) {
             const { next, killed } = killToEnd(current);
             pushKill(killed);
             overlayStateRef.current = next;
             renderOverlay(overlayStateRef.current);
             return;
         }
-        if (key.ctrl && input === 'y') {
+        if (isCtrl(input, key, 'y')) {
             overlayStateRef.current = yank(current);
             renderOverlay(overlayStateRef.current);
             return;
         }
+        // Push-to-talk: Ctrl+R to toggle recording (overlay mode)
+        if (isCtrl(input, key, 'r')) {
+            if (dictationBusyRef.current)
+                return;
+            if (isRecording()) {
+                dictationBusyRef.current = true;
+                onDictationStateChange?.('transcribing');
+                if (useNative) {
+                    stopNativeRecording()
+                        .then((text) => {
+                        if (text && text.trim()) {
+                            // Submit the transcribed text directly
+                            onSubmit(text.trim());
+                            overlayStateRef.current = { ...overlayStateRef.current, segments: [], cursor: { index: 0, offset: 0 }, historyIdx: -1 };
+                            renderOverlay(overlayStateRef.current);
+                        }
+                        else {
+                            onToast?.('No speech detected');
+                        }
+                    })
+                        .catch((err) => {
+                        onToast?.(`Dictation error: ${err.message}`);
+                    })
+                        .finally(() => {
+                        dictationBusyRef.current = false;
+                        onDictationStateChange?.('idle');
+                    });
+                }
+                else {
+                    stopLegacyRecording()
+                        .then((result) => {
+                        if (result.text && result.text.trim()) {
+                            // Submit the transcribed text directly
+                            onSubmit(result.text.trim());
+                            overlayStateRef.current = { ...overlayStateRef.current, segments: [], cursor: { index: 0, offset: 0 }, historyIdx: -1 };
+                            renderOverlay(overlayStateRef.current);
+                        }
+                        else {
+                            onToast?.('No speech detected');
+                        }
+                    })
+                        .catch((err) => {
+                        onToast?.(`Dictation error: ${err.message}`);
+                    })
+                        .finally(() => {
+                        dictationBusyRef.current = false;
+                        onDictationStateChange?.('idle');
+                    });
+                }
+            }
+            else {
+                if (!isDictationAvailable()) {
+                    onToast?.('Dictation not available. Build native/ztc-audio or install sox');
+                    return;
+                }
+                try {
+                    if (useNative) {
+                        startNativeRecording({ model: 'tiny' });
+                    }
+                    else {
+                        startLegacyRecording();
+                    }
+                    onDictationStateChange?.('recording');
+                }
+                catch (err) {
+                    onToast?.(`Recording error: ${err instanceof Error ? err.message : 'Unknown'}`);
+                }
+            }
+            return;
+        }
         if (key.meta && input === 'y') {
             overlayStateRef.current = yankPop(current);
             renderOverlay(overlayStateRef.current);
             return;
         }
-        if (key.ctrl && input === 't') {
+        if (isCtrl(input, key, 't')) {
             overlayStateRef.current = transposeChars(current);
             renderOverlay(overlayStateRef.current);
             return;
@@ -906,12 +1454,12 @@ export const InputArea = ({ onSubmit, onCommand, commands = [], onStateChange, o
             renderOverlay(overlayStateRef.current);
             return;
         }
-        if (key.ctrl && input === 'd') {
+        if (isCtrl(input, key, 'd')) {
             overlayStateRef.current = deleteForward(current);
             renderOverlay(overlayStateRef.current);
             return;
         }
-        if (key.ctrl && input === 'w') {
+        if (isCtrl(input, key, 'w')) {
             const { next, killed } = killWordBackward(current);
             pushKill(killed);
             overlayStateRef.current = next;
@@ -958,7 +1506,7 @@ export const InputArea = ({ onSubmit, onCommand, commands = [], onStateChange, o
             overlayStateRef.current = { ...overlayStateRef.current, historyIdx: -1 };
             renderOverlay(overlayStateRef.current);
         }
-    }, [disabled, historyEnabled, onCommand, onSubmit, renderOverlay]);
+    }, [disabled, handleKittyOverlayInput, historyEnabled, onCommand, onSubmit, renderOverlay]);
     useInput((input, key) => {
         if (overlayEnabled) {
             handleOverlayInput(input, key);