@codexstar/pi-listen 1.0.15 → 1.0.17

package/extensions/voice.ts

@@ -567,6 +567,7 @@ export default function (pi: ExtensionAPI) {
 	function voiceCleanup() {
 		if (statusTimer) { clearInterval(statusTimer); statusTimer = null; }
 		clearHoldTimer();
+		clearReleaseTimer();
 		stopRecordingWidgetAnimation();
 		if (activeSession) {
 			finalizeSession(activeSession);
@@ -699,7 +700,7 @@ export default function (pi: ExtensionAPI) {
 						? theme.fg("dim", "  Press Ctrl+Shift+B to stop")
 						: kittyReleaseDetected
 							? theme.fg("dim", "  Release SPACE to finalize")
-							: theme.fg("dim", "  Press Ctrl+Shift+V to stop");
+							: theme.fg("dim", "  Release SPACE to stop");
 
 					const lines = [
 						topBorder,
@@ -755,10 +756,7 @@ export default function (pi: ExtensionAPI) {
 					const label = theme.bold(theme.fg("accent", " VOICE "));
 					const timeStyled = theme.fg("muted", timeStr);
 					const titleLine = `  ${dot} ${label}  ${timeStyled}`;
-					const hint = kittyReleaseDetected
-						? theme.fg("dim", "  Release SPACE to finalize")
-						: theme.fg("dim", "  Press Ctrl+Shift+V to stop");
-
+					const hint = theme.fg("dim", "  Release SPACE to stop");
 					const lines = [topBorder, side(titleLine)];
 
 					if (!displayText.trim()) {
@@ -1011,25 +1009,27 @@ export default function (pi: ExtensionAPI) {
 	// If SPACE is released before the threshold, a regular space character
 	// is typed into the editor (normal typing behavior).
 	//
-	// This prevents accidental voice activation when typing and matches
-	// Claude Code's hold-to-talk UX pattern.
+	// KEY DESIGN for non-Kitty terminals (no key-release events):
+	//   Holding a key generates rapid press events (~30ms apart). We detect
+	//   "release" by watching for the stream of space presses to STOP.
+	//   Once the gap exceeds RELEASE_DETECT_MS (200ms), we know the user
+	//   lifted their finger and we stop recording.
 	//
-	// For Kitty protocol terminals: hold → wait threshold → activate →
-	//   release → stop recording. True hold-to-talk.
-	// For non-Kitty terminals: hold → wait threshold → activate →
-	//   Ctrl+Shift+V or /voice stop to end recording.
+	// Flow:
+	//   Hold SPACE → rapid presses arrive → first press starts 500ms timer →
+	//   timer fires → recording starts → presses keep coming (consumed) →
+	//   user releases → presses stop → 200ms silence → auto-stop recording
 	//
-	// KEY INSIGHT: In non-Kitty terminals, holding a key generates
-	// rapid press events (key-repeat). We CANNOT use "second space press
-	// = stop" because repeats arrive while holding. Instead, non-Kitty
-	// users must use Ctrl+Shift+V to stop.
+	// Kitty protocol terminals get true key-release events and work natively.
 
 	const HOLD_THRESHOLD_MS = 500; // minimum hold time before voice activates
+	const RELEASE_DETECT_MS = 200; // gap in key-repeat that means "released"
 	let kittyReleaseDetected = false;
-	let spaceDownTime: number | null = null; // timestamp when SPACE was first pressed
+	let spaceDownTime: number | null = null;
 	let holdActivationTimer: ReturnType<typeof setTimeout> | null = null;
-	let spaceConsumed = false; // whether we've committed to voice (past threshold)
-	let lastSpacePressTime = 0; // debounce rapid space presses from key-repeat
+	let spaceConsumed = false;
+	let lastSpacePressTime = 0;
+	let releaseDetectTimer: ReturnType<typeof setTimeout> | null = null;
 
 	function clearHoldTimer() {
 		if (holdActivationTimer) {
@@ -1038,6 +1038,49 @@ export default function (pi: ExtensionAPI) {
 		}
 	}
 
+	function clearReleaseTimer() {
+		if (releaseDetectTimer) {
+			clearTimeout(releaseDetectTimer);
+			releaseDetectTimer = null;
+		}
+	}
+
+	/** Called when we detect the user has released SPACE (non-Kitty) */
+	function onSpaceReleaseDetected() {
+		releaseDetectTimer = null;
+
+		// If we're still in the threshold wait (< 500ms), user just tapped space
+		if (spaceDownTime && !spaceConsumed) {
+			clearHoldTimer();
+			spaceDownTime = null;
+			spaceConsumed = false;
+			// Insert a space character
+			if (ctx?.hasUI) {
+				ctx.ui.setEditorText((ctx.ui.getEditorText() || "") + " ");
+				hideHoldHintWidget();
+			}
+			return;
+		}
+
+		// If we're recording, stop
+		if (spaceConsumed && voiceState === "recording") {
+			isHolding = false;
+			spaceConsumed = false;
+			spaceDownTime = null;
+			stopVoiceRecording("editor");
+		}
+	}
+
+	/** Reset the release detection timer — called on every space press */
+	function resetReleaseDetect() {
+		clearReleaseTimer();
+		// If we're in a hold state (threshold pending or recording),
+		// start a timer to detect release
+		if (spaceDownTime || spaceConsumed || voiceState === "recording") {
+			releaseDetectTimer = setTimeout(onSpaceReleaseDetected, RELEASE_DETECT_MS);
+		}
+	}
+
 	function setupHoldToTalk() {
 		if (!ctx?.hasUI) return;
 
@@ -1048,25 +1091,20 @@ export default function (pi: ExtensionAPI) {
 
 			// ── SPACE handling ──
 			if (matchesKey(data, "space")) {
-				// RULE: If editor has content, SPACE always types a space — never voice
-				const editorText = ctx?.hasUI ? ctx.ui.getEditorText() : "";
-				if (editorText && editorText.trim().length > 0) {
-					clearHoldTimer();
-					spaceDownTime = null;
-					spaceConsumed = false;
-					return undefined; // let the default space character through
-				}
+				// Check editor content — hold-to-talk still works even with content,
+				// but a quick tap types a space as normal
+				const editorHasContent = !!(ctx?.hasUI && ctx.ui.getEditorText()?.trim().length);
 
 				// ── Kitty key-release ──
 				if (isKeyRelease(data)) {
 					kittyReleaseDetected = true;
+					clearReleaseTimer();
 
 					// Released before threshold → type a space character
 					if (spaceDownTime && !spaceConsumed) {
 						clearHoldTimer();
 						spaceDownTime = null;
 						spaceConsumed = false;
-						// Insert a space into editor
 						if (ctx?.hasUI) ctx.ui.setEditorText((ctx.ui.getEditorText() || "") + " ");
 						return { consume: true };
 					}
@@ -1088,40 +1126,39 @@ export default function (pi: ExtensionAPI) {
 				// ── Kitty key-repeat: ALWAYS suppress while holding/recording ──
 				if (isKeyRepeat(data)) {
 					if (spaceDownTime || spaceConsumed || isHolding || voiceState === "recording") {
+						resetReleaseDetect(); // keep resetting — still holding
 						return { consume: true };
 					}
 					return undefined;
 				}
 
-				// === Key PRESS (initial press only) ===
+				// === Key PRESS ===
+				// In non-Kitty terminals, holding a key sends rapid press events.
+				// We use these to detect "still holding" and the gap to detect "released".
 
-				const now = Date.now();
-
-				// Debounce: ignore rapid presses within 100ms (terminal key-repeat
-				// generates press events in non-Kitty terminals since there's no
-				// key-repeat flag — they all look like fresh presses)
-				if (now - lastSpacePressTime < 100) {
-					lastSpacePressTime = now;
-					return { consume: true }; // suppress repeat
-				}
-				lastSpacePressTime = now;
+				// Reset release detection — user is still holding
+				resetReleaseDetect();
 
 				// If transcribing → ignore
 				if (voiceState === "transcribing") {
 					return { consume: true };
 				}
 
-				// If already recording: In Kitty mode, release handles stop.
-				// In non-Kitty, we can't safely detect "real second press" vs
-				// key-repeat. Use Ctrl+Shift+V instead. Just consume.
+				// If already recording → just consume (release detect handles stop)
 				if (voiceState === "recording") {
 					return { consume: true };
 				}
 
-				// Idle → start the hold timer
-				if (voiceState === "idle" && !spaceDownTime) {
-					spaceDownTime = now;
+				// If we already started the hold timer, this is a repeat → consume
+				if (spaceDownTime) {
+					return { consume: true };
+				}
+
+				// Idle, first press → start the hold timer
+				if (voiceState === "idle") {
+					spaceDownTime = Date.now();
 					spaceConsumed = false;
+					lastSpacePressTime = Date.now();
 
 					// Show a subtle "preparing" indicator
 					if (ctx?.hasUI) {
@@ -1129,11 +1166,10 @@ export default function (pi: ExtensionAPI) {
 					}
 
 					// After threshold: activate voice recording
+					// Works regardless of whether editor has content — hold always activates voice
 					holdActivationTimer = setTimeout(() => {
 						holdActivationTimer = null;
-						// Double-check: still idle, still holding, editor still empty
-						const currentText = ctx?.hasUI ? ctx.ui.getEditorText() : "";
-						if (voiceState === "idle" && spaceDownTime && !(currentText && currentText.trim().length > 0)) {
+						if (voiceState === "idle" && spaceDownTime) {
 							spaceConsumed = true;
 							isHolding = true;
 							startVoiceRecording("editor").then((ok) => {
@@ -1149,7 +1185,7 @@ export default function (pi: ExtensionAPI) {
 						}
 					}, HOLD_THRESHOLD_MS);
 
-					return { consume: true }; // consume now — we'll insert space on early release
+					return { consume: true };
 				}
 
 				if (isHolding || spaceConsumed) return { consume: true };
@@ -1159,14 +1195,13 @@ export default function (pi: ExtensionAPI) {
 			// ── Any other key while holding space (pre-threshold) → cancel hold, insert space ──
 			if (spaceDownTime && !spaceConsumed && !matchesKey(data, "space")) {
 				clearHoldTimer();
-				// Insert the space that was consumed during hold detection
+				clearReleaseTimer();
 				if (ctx?.hasUI) {
 					ctx.ui.setEditorText((ctx.ui.getEditorText() || "") + " ");
 					hideHoldHintWidget();
 				}
 				spaceDownTime = null;
 				spaceConsumed = false;
-				// Don't consume this key — let it through
 				return undefined;
 			}
 
@@ -1187,7 +1222,6 @@ export default function (pi: ExtensionAPI) {
 					return undefined;
 				}
 
-				// Toggle: stop if recording
 				if (voiceState === "recording") {
 					isHolding = false;
 					stopVoiceRecording("btw");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codexstar/pi-listen",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "description": "Voice input, first-run onboarding, and side-channel BTW conversations for Pi",
   "type": "module",
   "keywords": [