@bojackduy/opencode-voice 0.7.0 → 0.8.0

package/README.md

@@ -554,6 +554,19 @@ Options:
 Not in v1: speaker diarization, automatic summaries/action items, and
 uploading the notes anywhere - the Markdown file stays local.
 
+### Global cancel
+
+| Command         | Keybind    | Description                        |
+| --------------- | ---------- | ---------------------------------- |
+| `/voice-cancel` | `leader+.` | Stop any in-flight voice operation |
+
+One keypress cancels whatever is running: batch recording (or its
+transcribe/normalize pipeline), streaming dictation, TTS playback (or a
+pending speech handoff), the voice-conversation loop, and live-notes capture
+(live notes finishes saving in the background, like `/voice-notes-cancel`).
+Idle invocations toast `Nothing to cancel`. Keybind override:
+`"keybinds": { "voice.cancel": "none" }`.
+
 ### Streaming dictation
 
 Live local dictation for short prompts: the mic stays on, partial

package/index.js

@@ -32,6 +32,7 @@
 //   /voice-notes-stop    - stop live notes, flush, and save (palette-only)
 //   /voice-notes-cancel  - stop live notes immediately, save in background (palette-only)
 //   /voice-notes-status  - show live-notes recording status (palette-only)
+//   /voice-cancel        - cancel everything in flight            (default: <leader>.)
 //   All also palette-accessible via Ctrl+P or /slash. Override via plugin options `keybinds`:
 //   { "keybinds": { "stt.record": "ctrl+r", "tts.speak-last": "none", "voice.conversation": "none" } }
 //   Weird keys [ ] ; were chosen because opencode doesn't use them and shift variants were ignored in terminals.
@@ -43,6 +44,7 @@ import { registerSTT } from "./lib/stt.js";
 import { registerTTS } from "./lib/tts.js";
 import { registerConversation } from "./lib/conversation.js";
 import { registerLiveNotes } from "./lib/live-notes.js";
+import { registerVoiceCancel } from "./lib/cancel.js";
 import { registerVoiceModel, resolveVoiceProviderModel } from "./lib/voice-model.js";
 import { createClient } from "./lib/llm-client.js";
 import { createLogger } from "./lib/logger.js";
@@ -112,6 +114,12 @@ export default {
     });
     shared.liveNotes = liveNotes.controller;
     const voiceModel = registerVoiceModel(api, kv, options, logger);
+    const cancel = registerVoiceCancel(api, options, logger, {
+      stt: stt.controller,
+      tts: tts.controller,
+      conversation: shared.conversation,
+      liveNotes: shared.liveNotes,
+    });
 
     api.command.register(() => [
       ...stt.commands,
@@ -119,6 +127,7 @@ export default {
       ...conversation.commands,
       ...liveNotes.commands,
       ...voiceModel.commands,
+      ...cancel.commands,
     ]);
   },
 };

package/lib/cancel.js

@@ -0,0 +1,106 @@
+// Voice: cancel everything - a global panic button for in-flight voice work.
+//
+// One keypress stops whatever is running: batch STT recording (or the
+// transcribe/normalize pipeline behind it), streaming dictation, TTS
+// playback (or a pending normalize handoff), the voice-conversation loop,
+// and live-notes capture (background-save semantics, like /voice-notes-cancel).
+// Idle invocations never throw and toast "Nothing to cancel".
+
+import { clearProcessingToast, clearStreamingToast } from "./stt.js";
+
+export function registerVoiceCancel(api, opts, logger, { stt, tts, conversation, liveNotes }) {
+  function toast(message, variant = "info") {
+    api.ui.toast({ message, variant, duration: 3000 });
+  }
+
+  function guarded(fn) {
+    try {
+      return fn();
+    } catch {
+      return undefined;
+    }
+  }
+
+  async function cancelEverything() {
+    const cancelled = [];
+    try {
+      // TTS playback: stop() also invalidates a normalize handoff still in
+      // flight via the speech generation guard.
+      const wasSpeaking = guarded(() => tts?.isSpeaking?.()) === true;
+      if (wasSpeaking) {
+        guarded(() => tts?.stop?.());
+        cancelled.push("TTS");
+      }
+
+      // Streaming dictation owns the mic; batch recording otherwise. A
+      // transcribe/normalize pipeline with no active recording is still
+      // cancelled via the same path (it bumps the pipeline generation so
+      // the stale transcript never lands).
+      const streaming = guarded(() => stt?.isStreaming?.()) === true;
+      if (streaming) {
+        await guarded(() => stt?.cancelStreaming?.());
+        cancelled.push("streaming");
+      } else {
+        const busy =
+          guarded(() => stt?.isRecording?.()) === true ||
+          guarded(() => stt?.isProcessing?.()) === true;
+        if (busy) {
+          guarded(() => stt?.cancel?.());
+          cancelled.push("recording");
+        }
+      }
+
+      if (guarded(() => conversation?.isActive?.()) === true) {
+        guarded(() => conversation?.stop?.("cancelled"));
+        cancelled.push("conversation");
+      }
+
+      if (guarded(() => liveNotes?.isActive?.()) === true) {
+        guarded(() => liveNotes?.cancel?.());
+        cancelled.push("live notes");
+      }
+
+      guarded(() => clearProcessingToast());
+      guarded(() => clearStreamingToast());
+
+      if (cancelled.length > 0) {
+        toast(`Cancelled: ${cancelled.join(", ")}`, "success");
+      } else {
+        toast("Nothing to cancel");
+      }
+      logger?.log?.("VOICE", `Cancel everything: ${cancelled.join(", ") || "idle"}`, "debug");
+    } catch (err) {
+      logger?.log?.("VOICE", `Cancel everything failed: ${err?.message || err}`, "error");
+    }
+  }
+
+  const DEFAULT_KEYBINDS = {
+    "voice.cancel": "<leader>.",
+  };
+  function kb(value) {
+    const overrides = opts?.keybinds;
+    if (!overrides || typeof overrides !== "object" || Array.isArray(overrides)) {
+      return DEFAULT_KEYBINDS[value];
+    }
+    if (!Object.prototype.hasOwnProperty.call(overrides, value)) return DEFAULT_KEYBINDS[value];
+    const v = overrides[value];
+    if (!v || v === "none") return undefined;
+    return v;
+  }
+
+  const commands = [
+    {
+      title: "Voice: cancel everything",
+      value: "voice.cancel",
+      category: "opencode-voice",
+      description: "Stop any in-flight voice operation (recording, dictation, speech, loop, notes)",
+      ...(kb("voice.cancel") ? { keybind: kb("voice.cancel") } : {}),
+      slash: { name: "voice-cancel" },
+      onSelect() {
+        void cancelEverything();
+      },
+    },
+  ];
+
+  return { commands };
+}

package/lib/live-notes.js

@@ -618,5 +618,5 @@ export function registerLiveNotes(api, kv, complete, opts, logger, deps = {}) {
     },
   ];
 
-  return { commands, controller: { isActive } };
+  return { commands, controller: { isActive, stop: stopCommand, cancel: cancelCommand } };
 }

package/lib/stt.js

@@ -271,6 +271,10 @@ let soxProc = null;
 let soxStderr = "";
 let recording = false;
 let processing = false;
+// Invalidated by cancelRecording/discardTurn: a cancel landing between
+// LLM normalization and transcript-insert must prevent the stale text from
+// landing afterwards. Checked in doTranscribePipeline before any append.
+let pipelineGeneration = 0;
 
 // ---- Conversation-mode hooks (wired by index.js) ----
 // When voice conversation is active, the plain record/submit keys defer to the
@@ -1516,6 +1520,7 @@ async function appendTurnText(client, renderer, toast, text, logger) {
 // Clears the sticky toast left up by transcribeTurn and resets the flags.
 
 function discardTurn() {
+  pipelineGeneration += 1;
   clearProcessingToast();
   processing = false;
   recording = false;
@@ -1524,6 +1529,7 @@ function discardTurn() {
 // Cancel an in-progress recording without transcribing.
 
 function cancelRecording(logger) {
+  pipelineGeneration += 1;
   recording = false;
   clearRecordingToast();
   forceKillSox(logger);
@@ -1541,7 +1547,16 @@ async function doTranscribePipeline(
   renderer,
 ) {
   logger?.log("STT", `Pipeline started submit=${submit}`, "debug");
+  const myGen = pipelineGeneration;
   const turn = await transcribeTurn(kv, complete, client, api, toast, systemPrompt, logger);
+  // A cancel during transcribe/normalize invalidates this turn: drop the
+  // stale text instead of appending it after the user cancelled.
+  if (myGen !== pipelineGeneration) {
+    clearProcessingToast();
+    processing = false;
+    recording = false;
+    return;
+  }
   if (!turn.text) return;
   if (submit) {
     await submitTurnText(client, renderer, toast, turn.text, logger);

package/lib/tts.js

@@ -281,6 +281,9 @@ export function registerTTS(api, kv, complete, prompts, opts, logger, deps = {})
 
   let piperProc = null;
   let playProc = null;
+  // Invalidated by stopSpeech: a cancel landing between LLM normalization
+  // and playback must prevent the stale speech from starting afterwards.
+  let speechGen = 0;
 
   function killProcs() {
     if (piperProc) {
@@ -387,6 +390,7 @@ export function registerTTS(api, kv, complete, prompts, opts, logger, deps = {})
   }
 
   function speak(text) {
+    const myGen = speechGen;
     if (!text) return Promise.resolve();
     const line = text.replace(/\n/g, " ").trim();
     if (!line) return Promise.resolve();
@@ -397,6 +401,8 @@ export function registerTTS(api, kv, complete, prompts, opts, logger, deps = {})
     // switching.
     const voiceModel = resolveVoiceOrWarn(line);
     if (!voiceModel) return Promise.resolve();
+    // A cancel (stopSpeech) during normalization invalidates this speech.
+    if (myGen !== speechGen) return Promise.resolve();
     logger?.log?.("TTS", `Speak requested chars=${line.length} voice=${voiceModel}`, "debug");
 
     return new Promise((resolve) => {
@@ -420,6 +426,9 @@ export function registerTTS(api, kv, complete, prompts, opts, logger, deps = {})
   }
 
   function stopSpeech() {
+    // Always invalidate: a pending normalize handoff must not speak after
+    // the cancel even when nothing is currently playing.
+    speechGen += 1;
     const wasPlaying = piperProc !== null || playProc !== null;
     killProcs();
     return wasPlaying;
@@ -458,7 +467,12 @@ export function registerTTS(api, kv, complete, prompts, opts, logger, deps = {})
     lastSpokenMessageID = result.lastMessageID;
 
     showProcessingToast("Normalizing response...");
+    const genBeforeNormalize = speechGen;
     const llmResult = await normalizeOrLocal(result.text, systemAuto, 4096);
+    if (genBeforeNormalize !== speechGen) {
+      clearProcessingToast();
+      return;
+    }
     if (!llmResult.text) {
       clearProcessingToast();
       logger?.log?.("TTS", `Auto normalization failed: ${llmResult.error}`, "warn");
@@ -499,7 +513,12 @@ export function registerTTS(api, kv, complete, prompts, opts, logger, deps = {})
     }
 
     showProcessingToast("Normalizing response...");
+    const manualGen = speechGen;
     const llmResult = await normalizeOrLocal(result.text, systemManual, 4096);
+    if (manualGen !== speechGen) {
+      clearProcessingToast();
+      return;
+    }
     if (!llmResult.text) {
       clearProcessingToast();
       logger?.log?.("TTS", `Manual normalization failed: ${llmResult.error}`, "warn");
@@ -536,10 +555,15 @@ export function registerTTS(api, kv, complete, prompts, opts, logger, deps = {})
 
     showProcessingToast("Normalizing response...");
     const tNormalize = Date.now();
+    const turnGen = speechGen;
     // Auto replies are narrated/summarized, so a tight cap is safe here (the
     // manual read-aloud keeps the full 4096).
     const llmResult = await normalizeOrLocal(result.text, systemAuto, 2048);
     const normalizeMs = Date.now() - tNormalize;
+    if (turnGen !== speechGen) {
+      clearProcessingToast();
+      return { spoken: false };
+    }
     if (!llmResult.text) {
       clearProcessingToast();
       logger?.log?.("TTS", `Conversation normalization failed: ${llmResult.error}`, "warn");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bojackduy/opencode-voice",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Speech-to-text and text-to-speech for OpenCode. Record voice prompts with whisper-cpp, hear responses via Piper TTS, with LLM normalization through any OpenAI-compatible endpoint.",
   "keywords": [
     "opencode",