omnirush 0.8.5 → 0.9.0

package/assets/extensions/omnirush/voice/core/types.ts

@@ -0,0 +1,102 @@
+/** 16 kHz mono signed 16-bit PCM: the only format voice-core produces and uploads. */
+export const VOICE_SAMPLE_RATE = 16_000;
+
+export type VoiceErrorKind =
+  /** The microphone delivered only silence (RMS never rose above the no-signal floor). */
+  | "no_signal"
+  /** There was sound, but nothing that transcribed to words. */
+  | "no_speech"
+  /** The transcription service could not be reached, or kept failing. */
+  | "network"
+  /** Voice is switched off for this account or server (503 voice_unavailable). */
+  | "unavailable"
+  /** The service could not decode the audio (422 audio_unreadable). */
+  | "unreadable"
+  /** Too many requests or the daily audio budget is spent (429). */
+  | "rate_limited"
+  /** The account is signed out or its session expired (401). */
+  | "signed_out"
+  /** The OS or the user refused microphone access. */
+  | "permission_denied"
+  /** No microphone is connected, or the chosen one is gone. */
+  | "no_device"
+  /** The microphone exists but could not be opened (in use, driver error). */
+  | "capture_failed"
+  /** Three failures in a short window: voice pauses for a moment. */
+  | "breaker_open"
+  /** The recording or a segment was larger than the service accepts. */
+  | "too_large";
+
+export class VoiceError extends Error {
+  readonly kind: VoiceErrorKind;
+  readonly retryable: boolean;
+  /** How long the service asked to wait before the next try, when it said. */
+  readonly retryAfterMs: number | null;
+  readonly status: number | null;
+
+  constructor(kind: VoiceErrorKind, message: string, options: { retryable?: boolean; retryAfterMs?: number | null; status?: number | null } = {}) {
+    super(message);
+    this.name = "VoiceError";
+    this.kind = kind;
+    this.retryable = options.retryable ?? false;
+    this.retryAfterMs = options.retryAfterMs ?? null;
+    this.status = options.status ?? null;
+  }
+}
+
+export function isVoiceError(value: unknown): value is VoiceError {
+  return value instanceof VoiceError;
+}
+
+/** One speech segment's upload. */
+export type TranscribeRequest = {
+  /** A complete RIFF/WAVE file, 16 kHz mono s16le. */
+  wav: Uint8Array;
+  segmentIndex: number;
+  recordingId: string;
+  /** BCP-47 hint, or null for auto-detect. */
+  language: string | null;
+  keyterms: readonly string[];
+  durationMs: number;
+};
+
+export type TranscribeResult = { text: string };
+
+export interface Transcriber {
+  /** Resolves with the segment's text; rejects with a VoiceError (or anything, read as a network failure). */
+  transcribe(request: TranscribeRequest, signal: AbortSignal): Promise<TranscribeResult>;
+}
+
+/**
+ * Where PCM comes from: a microphone, a WAV file (tests), a native recorder
+ * (CLI). Frames are 16 kHz mono Int16 of any length.
+ */
+export interface AudioSource {
+  start(onFrames: (frames: Int16Array) => void, onEnd?: (error?: VoiceError) => void): Promise<void>;
+  stop(): void;
+}
+
+export type VoicePhase = "idle" | "arming" | "recording" | "finalizing" | "done" | "cancelled" | "error";
+
+export type VoiceSnapshot = {
+  phase: VoicePhase;
+  /** The last 16 input levels, 0..1, oldest first. */
+  levels: number[];
+  elapsedMs: number;
+  /** Text of the finished segments, in order, stopped at the first one still in flight. */
+  text: string;
+  /** Segments uploaded (or queued) whose text has not arrived yet. */
+  pending: number;
+  /** Segments that failed for good; their audio is lost, the rest of the text is kept. */
+  failed: number;
+  error: VoiceError | null;
+};
+
+export type VoiceResult = {
+  text: string;
+  /** Words in `text`, counting CJK characters one by one. */
+  words: number;
+  segments: number;
+  /** Set when nothing usable came back (no signal, no speech, service down) or part of it was lost. */
+  error: VoiceError | null;
+};

package/assets/extensions/omnirush/voice/core/wav.ts

@@ -0,0 +1,95 @@
+import { VOICE_SAMPLE_RATE } from "./types";
+
+/** A RIFF/WAVE file holding `samples` as 16-bit PCM, mono. */
+export function encodeWav(samples: Int16Array, sampleRate = VOICE_SAMPLE_RATE): Uint8Array {
+  const dataBytes = samples.length * 2;
+  const bytes = new Uint8Array(44 + dataBytes);
+  const view = new DataView(bytes.buffer);
+  const ascii = (offset: number, text: string) => {
+    for (let index = 0; index < text.length; index += 1) view.setUint8(offset + index, text.charCodeAt(index));
+  };
+  ascii(0, "RIFF");
+  view.setUint32(4, 36 + dataBytes, true);
+  ascii(8, "WAVE");
+  ascii(12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true); // PCM
+  view.setUint16(22, 1, true); // mono
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, sampleRate * 2, true);
+  view.setUint16(32, 2, true);
+  view.setUint16(34, 16, true);
+  ascii(36, "data");
+  view.setUint32(40, dataBytes, true);
+  for (let index = 0; index < samples.length; index += 1) view.setInt16(44 + index * 2, samples[index]!, true);
+  return bytes;
+}
+
+export type DecodedWav = {
+  sampleRate: number;
+  /** Mono, -1..1 (channels averaged). */
+  samples: Float32Array;
+};
+
+/**
+ * Reads a PCM WAV file: 8/16/24/32-bit integer or 32-bit float, any channel
+ * count and sample rate. Used by the file input override, never on mic audio.
+ */
+export function decodeWav(input: Uint8Array): DecodedWav {
+  const view = new DataView(input.buffer, input.byteOffset, input.byteLength);
+  const tag = (offset: number) => String.fromCharCode(...input.subarray(offset, offset + 4));
+  if (input.byteLength < 12 || tag(0) !== "RIFF" || tag(8) !== "WAVE") throw new Error("Not a WAV file");
+  let format = 0;
+  let channels = 0;
+  let sampleRate = 0;
+  let bits = 0;
+  let offset = 12;
+  while (offset + 8 <= input.byteLength) {
+    const id = tag(offset);
+    const size = view.getUint32(offset + 4, true);
+    const body = offset + 8;
+    if (id === "fmt ") {
+      format = view.getUint16(body, true);
+      channels = view.getUint16(body + 2, true);
+      sampleRate = view.getUint32(body + 4, true);
+      bits = view.getUint16(body + 14, true);
+      if (format === 0xfffe && size >= 26) format = view.getUint16(body + 24, true);
+    } else if (id === "data") {
+      if (!channels || !sampleRate || !bits) throw new Error("WAV data before its format");
+      const end = Math.min(input.byteLength, body + size);
+      const width = bits / 8;
+      const frames = Math.floor((end - body) / (width * channels));
+      const samples = new Float32Array(frames);
+      for (let frame = 0; frame < frames; frame += 1) {
+        let sum = 0;
+        for (let channel = 0; channel < channels; channel += 1) {
+          const at = body + (frame * channels + channel) * width;
+          sum += readSample(view, at, format, bits);
+        }
+        samples[frame] = sum / channels;
+      }
+      return { sampleRate, samples };
+    }
+    offset = body + size + (size % 2);
+  }
+  throw new Error("WAV file has no data");
+}
+
+function readSample(view: DataView, at: number, format: number, bits: number): number {
+  if (format === 3 && bits === 32) return view.getFloat32(at, true);
+  if (format !== 1) throw new Error(`Unsupported WAV format ${format}`);
+  switch (bits) {
+    case 8:
+      return (view.getUint8(at) - 128) / 128;
+    case 16:
+      return view.getInt16(at, true) / 32768;
+    case 24: {
+      const value = view.getUint8(at) | (view.getUint8(at + 1) << 8) | (view.getInt8(at + 2) << 16);
+      return value / 8388608;
+    }
+    case 32:
+      return view.getInt32(at, true) / 2147483648;
+    default:
+      throw new Error(`Unsupported WAV bit depth ${bits}`);
+  }
+}

package/assets/extensions/omnirush/voice/keys.ts

@@ -0,0 +1,435 @@
+/**
+ * Push-to-talk key handling for a terminal (pure: timers and clock are
+ * injected, so the heuristics are unit-tested without a pty).
+ *
+ * Terminals have no key-up event in their legacy encoding, so there are
+ * two paths:
+ *
+ * - Kitty keyboard protocol (kitty, WezTerm, Ghostty, foot, recent iTerm2):
+ *   real press / repeat / release events. The agent core enables the
+ *   protocol with flags 1|2|4; a plain text key such as Space only reports
+ *   its release with flag 8 ("all keys as escape codes"), which voice mode
+ *   turns on while hold-to-talk is armed (see kitty.ts). A press held past
+ *   HOLD_MS (or auto-repeating) records, the release stops; a quick tap
+ *   still types a space.
+ * - Legacy terminals: the auto-repeat heuristic. A held key auto-repeats;
+ *   recording starts after WARMUP_EVENTS rapid events, the warm-up spaces
+ *   are stripped (the first one reached the editor, the rest were held
+ *   back), and RELEASE_MS without a repeat means the key was released.
+ *
+ * Modifier combos (alt+m, ctrl+space, …) are not text, so they start on
+ * the first event with no warm-up. Tap mode toggles instead of holding.
+ */
+
+export type VoiceMode = "hold" | "tap";
+
+export interface VoiceKey {
+  /** Canonical id, e.g. "space", "alt+m", "ctrl+space". */
+  id: string;
+  /** The key without modifiers: "space" or a single character. */
+  base: string;
+  ctrl: boolean;
+  alt: boolean;
+  shift: boolean;
+  super: boolean;
+  /** Plain text key (types a character), i.e. needs the warm-up. */
+  text: boolean;
+  /** Kitty codepoint of the base key. */
+  codepoint: number;
+}
+
+const RESERVED = new Set(["ctrl+c", "ctrl+d", "ctrl+z", "ctrl+m", "ctrl+i", "ctrl+j", "ctrl+[", "enter", "escape", "esc", "tab", "backspace"]);
+
+/** Parse a key setting; throws with a user-facing message when unusable. */
+export function parseVoiceKey(raw: string): VoiceKey {
+  const value = String(raw || "").trim().toLowerCase().replace(/\s+/g, "");
+  if (!value) throw new Error("empty key");
+  if (value.includes("capslock") || value.includes("caps")) {
+    throw new Error("Caps Lock can't be used: terminals don't deliver it to programs");
+  }
+  if (RESERVED.has(value)) throw new Error(`${value} is reserved by the prompt`);
+  const parts = value.split("+");
+  const base = parts.pop() ?? "";
+  const mods = new Set(parts);
+  for (const mod of mods) {
+    if (!["ctrl", "alt", "shift", "super", "meta", "option", "cmd"].includes(mod)) throw new Error(`unknown modifier "${mod}"`);
+  }
+  const alt = mods.has("alt") || mods.has("meta") || mods.has("option");
+  const ctrl = mods.has("ctrl");
+  const shift = mods.has("shift");
+  const sup = mods.has("super") || mods.has("cmd");
+  let codepoint: number;
+  if (base === "space") codepoint = 32;
+  else if ([...base].length === 1) codepoint = base.codePointAt(0)!;
+  else throw new Error(`unsupported key "${base}" (use space or a single character, with ctrl/alt/shift)`);
+  const text = !ctrl && !alt && !sup;
+  if (text && base !== "space") throw new Error(`a plain "${base}" would stop you typing it — use space or add a modifier (e.g. alt+${base})`);
+  if (shift && text) throw new Error("shift+space types a space in most terminals — use space or ctrl/alt+space");
+  const canonical = [ctrl && "ctrl", alt && "alt", shift && "shift", sup && "super", base].filter(Boolean).join("+");
+  if (RESERVED.has(canonical)) throw new Error(`${canonical} is reserved by the prompt`);
+  return { id: canonical, base, ctrl, alt, shift, super: sup, text, codepoint };
+}
+
+export interface KittyKeyEvent {
+  codepoint: number;
+  /** Modifier bits (shift 1, alt 2, ctrl 4, super 8), lock bits removed. */
+  modifiers: number;
+  event: "press" | "repeat" | "release";
+}
+
+const KITTY_CSI_U = /^\x1b\[(\d+)(?::(\d*))?(?::(\d+))?(?:;(\d+)(?::(\d+))?)?(?:;[\d:]*)?u$/;
+
+/** Parse a Kitty CSI-u key event (`CSI cp[:alts] [; mods[:event]] u`). */
+export function parseKittyKey(data: string): KittyKeyEvent | null {
+  const m = KITTY_CSI_U.exec(data);
+  if (!m) return null;
+  const codepoint = Number(m[1]);
+  const mods = m[4] ? Number(m[4]) - 1 : 0;
+  const ev = m[5] ? Number(m[5]) : 1;
+  return {
+    codepoint,
+    modifiers: mods & 0b1111,
+    event: ev === 3 ? "release" : ev === 2 ? "repeat" : "press",
+  };
+}
+
+function modifierBits(key: VoiceKey): number {
+  return (key.shift ? 1 : 0) | (key.alt ? 2 : 0) | (key.ctrl ? 4 : 0) | (key.super ? 8 : 0);
+}
+
+/** Does a Kitty event belong to the voice key? */
+export function kittyMatches(key: VoiceKey, ev: KittyKeyEvent): boolean {
+  if (ev.modifiers !== modifierBits(key)) return false;
+  if (ev.codepoint === key.codepoint) return true;
+  // Some terminals report the shifted codepoint for letters.
+  return key.base.length === 1 && ev.codepoint === key.base.toUpperCase().codePointAt(0);
+}
+
+/** Legacy / modifyOtherKeys encodings of the voice key (press only). */
+export function legacyMatches(key: VoiceKey, data: string): boolean {
+  if (key.text) return data === " " || data === "　"; // CJK IME full-width space too
+  const mot = /^\x1b\[27;(\d+);(\d+)~$/.exec(data); // xterm modifyOtherKeys
+  if (mot) return Number(mot[2]) === key.codepoint && Number(mot[1]) - 1 === modifierBits(key);
+  if (key.alt && !key.ctrl && !key.super) {
+    const ch = key.base === "space" ? " " : key.shift ? key.base.toUpperCase() : key.base;
+    return data === `\x1b${ch}`;
+  }
+  if (key.ctrl && !key.alt && !key.super && !key.shift) {
+    if (key.base === "space") return data === "\x00";
+    const code = key.base.toUpperCase().charCodeAt(0);
+    if (code >= 64 && code <= 95) return data === String.fromCharCode(code - 64);
+  }
+  if (key.ctrl && key.alt && !key.super && !key.shift) {
+    if (key.base === "space") return data === "\x1b\x00";
+    const code = key.base.toUpperCase().charCodeAt(0);
+    if (code >= 64 && code <= 95) return data === `\x1b${String.fromCharCode(code - 64)}`;
+  }
+  return false;
+}
+
+/** Esc or Ctrl+C in any encoding. */
+export function isCancelKey(data: string): boolean {
+  if (data === "\x1b" || data === "\x03") return true;
+  const ev = parseKittyKey(data);
+  if (!ev || ev.event === "release") return false;
+  return (ev.codepoint === 27 && ev.modifiers === 0) || (ev.codepoint === 99 && ev.modifiers === 4);
+}
+
+/** Enter in any encoding (tap mode: stop and send). */
+export function isEnterKey(data: string): boolean {
+  if (data === "\r") return true;
+  const ev = parseKittyKey(data);
+  return !!ev && ev.event === "press" && ev.codepoint === 13 && ev.modifiers === 0;
+}
+
+export interface Timers {
+  set(fn: () => void, ms: number): unknown;
+  clear(handle: unknown): void;
+}
+
+export const realTimers: Timers = {
+  set: (fn, ms) => setTimeout(fn, ms),
+  clear: (handle) => clearTimeout(handle as any),
+};
+
+export interface KeyTimings {
+  /**
+   * Legacy: rapid auto-repeats (each within repeatGapMs of the previous)
+   * needed before recording starts. The first press types a space; every
+   * event after it is held back until the hold is confirmed or abandoned.
+   */
+  warmupRepeats: number;
+  /** Legacy: the first auto-repeat can take this long (OS repeat delay). */
+  firstRepeatMs: number;
+  /** Legacy: max gap between rapid repeats during the warm-up. */
+  repeatGapMs: number;
+  /** Legacy: this long without a repeat means released. */
+  releaseMs: number;
+  /** Legacy combos: release fallback before the first repeat was seen. */
+  comboFirstReleaseMs: number;
+  /** Kitty: a press held this long starts recording. */
+  holdMs: number;
+  /** Tap mode: key events closer than this belong to one (auto-repeating) press. */
+  tapDebounceMs: number;
+}
+
+export const DEFAULT_TIMINGS: KeyTimings = {
+  warmupRepeats: 4,
+  firstRepeatMs: 700,
+  repeatGapMs: 120,
+  releaseMs: 150,
+  comboFirstReleaseMs: 700,
+  holdMs: 200,
+  tapDebounceMs: 250,
+};
+
+/** What to do with an input: let it through (to the editor) or swallow it. */
+export type KeyAction = { type: "pass" } | { type: "consume" };
+
+export interface KeyCallbacks {
+  /** Legacy warm-up in progress ("keep holding…"). */
+  onWarmup?(): void;
+  /** Warm-up abandoned: the held-back spaces must be typed after all. */
+  onWarmupAbort?(heldBack: number): void;
+  /** Start recording; `strip` spaces already reached the editor and must be removed. */
+  onStart(strip: number): void;
+  /** Key released (hold) or pressed again (tap): finalize. `send` = Enter in tap mode. */
+  onStop(send: boolean): void;
+  onCancel(): void;
+  /** A Kitty press turned out to be a quick tap: type the key (a space) now. */
+  typeKey?(): void;
+}
+
+export interface KeyControllerOptions {
+  mode: VoiceMode;
+  key: VoiceKey;
+  /** Kitty release events are available for this key right now. */
+  kitty: () => boolean;
+  /** May a recording start now (editor focused, no overlay, tap: editor empty for Space). */
+  canStart: () => boolean;
+  callbacks: KeyCallbacks;
+  timings?: Partial<KeyTimings>;
+  timers?: Timers;
+  now?: () => number;
+}
+
+type Phase = "idle" | "warmup" | "armed" | "recording";
+
+/**
+ * Turns raw terminal input into start/stop/cancel of a recording. Returns
+ * what to do with each input (let it through, swallow it, or replace it).
+ */
+export class KeyController {
+  phase: Phase = "idle";
+  private readonly t: KeyTimings;
+  private readonly timers: Timers;
+  private readonly now: () => number;
+  private timer: unknown = null;
+  private count = 0;
+  private heldBack = 0;
+  private sawRepeat = false;
+  private lastKeyAt = -Infinity;
+
+  constructor(private readonly o: KeyControllerOptions) {
+    this.t = { ...DEFAULT_TIMINGS, ...(o.timings ?? {}) };
+    this.timers = o.timers ?? realTimers;
+    this.now = o.now ?? (() => Date.now());
+  }
+
+  get recording(): boolean {
+    return this.phase === "recording";
+  }
+
+  /** Reset to idle without callbacks (the extension ended the recording itself). */
+  reset(): void {
+    this.clearTimer();
+    this.phase = "idle";
+    this.count = 0;
+    this.heldBack = 0;
+    this.sawRepeat = false;
+  }
+
+  handle(data: string): KeyAction {
+    return this.o.mode === "tap" ? this.handleTap(data) : this.handleHold(data);
+  }
+
+  // ---- hold ---------------------------------------------------------------
+
+  private handleHold(data: string): KeyAction {
+    const key = this.o.key;
+    const kittyEvent = parseKittyKey(data);
+    const ours = kittyEvent ? kittyMatches(key, kittyEvent) : legacyMatches(key, data);
+
+    if (this.phase === "recording") {
+      if (isCancelKey(data) && !ours) {
+        this.reset();
+        this.o.callbacks.onCancel();
+        return { type: "consume" };
+      }
+      if (ours) {
+        if (kittyEvent && this.o.kitty()) {
+          if (kittyEvent.event === "release") {
+            this.reset();
+            this.o.callbacks.onStop(false);
+          }
+          return { type: "consume" };
+        }
+        // Legacy: every repeat pushes the inferred release further out.
+        this.sawRepeat = true;
+        this.armRelease();
+        return { type: "consume" };
+      }
+      // Other keys while holding: swallowed (releases are dropped too).
+      return { type: "consume" };
+    }
+
+    if (this.phase === "armed") {
+      if (ours && kittyEvent) {
+        if (kittyEvent.event === "repeat") return this.startRecording(0);
+        if (kittyEvent.event === "release") {
+          // Quick tap: type the key after all.
+          this.reset();
+          if (key.text) this.o.callbacks.typeKey?.();
+          return { type: "consume" };
+        }
+        return { type: "consume" };
+      }
+      // Something else interrupted a Kitty press: treat as a tap first.
+      this.reset();
+      if (key.text) this.o.callbacks.typeKey?.();
+      return { type: "pass" };
+    }
+
+    if (this.phase === "warmup") {
+      if (ours && !kittyEvent) {
+        // The first gap may be the OS repeat delay (or a typed space just
+        // before the hold): only a run of rapid repeats confirms a hold.
+        const now = this.now();
+        const gap = now - this.lastKeyAt;
+        this.lastKeyAt = now;
+        this.count = gap <= this.t.repeatGapMs ? this.count + 1 : 0;
+        if (this.count >= this.t.warmupRepeats) return this.startRecording(1);
+        this.heldBack++;
+        this.o.callbacks.onWarmup?.();
+        // Until two rapid repeats in a row, the next gap may still be the OS
+        // repeat delay of a press that followed a typed space.
+        this.armWarmupTimeout(this.count >= 2 ? this.t.repeatGapMs : this.t.firstRepeatMs);
+        return { type: "consume" };
+      }
+      // Another key: the spaces were typed on purpose.
+      this.abortWarmup();
+      return { type: "pass" };
+    }
+
+    // idle
+    if (!ours) return { type: "pass" };
+    if (kittyEvent && kittyEvent.event === "release") return { type: "consume" };
+    if (!this.o.canStart()) return { type: "pass" };
+    if (!key.text) {
+      // Modifier combo: no warm-up, starts on the first event.
+      return this.startRecording(0);
+    }
+    if (kittyEvent && this.o.kitty()) {
+      if (kittyEvent.event === "repeat") return this.startRecording(0);
+      this.phase = "armed";
+      this.setTimer(() => {
+        if (this.phase === "armed") this.startRecording(0);
+      }, this.t.holdMs);
+      return { type: "consume" };
+    }
+    // Legacy text key: the first space is typed; repeats decide.
+    this.phase = "warmup";
+    this.count = 0;
+    this.lastKeyAt = this.now();
+    this.heldBack = 0;
+    this.armWarmupTimeout(this.t.firstRepeatMs);
+    return { type: "pass" };
+  }
+
+  private startRecording(strip: number): KeyAction {
+    this.clearTimer();
+    this.phase = "recording";
+    this.count = 0;
+    this.heldBack = 0;
+    this.sawRepeat = false;
+    this.o.callbacks.onStart(strip);
+    if (!this.o.kitty() || !this.o.key.text) this.armRelease();
+    return { type: "consume" };
+  }
+
+  private armRelease(): void {
+    if (this.o.kitty()) {
+      // Kitty delivers the release; nothing to infer.
+      return;
+    }
+    const ms = !this.o.key.text && !this.sawRepeat ? this.t.comboFirstReleaseMs : this.t.releaseMs;
+    this.setTimer(() => {
+      if (this.phase !== "recording") return;
+      this.reset();
+      this.o.callbacks.onStop(false);
+    }, ms);
+  }
+
+  private armWarmupTimeout(ms: number): void {
+    this.setTimer(() => {
+      if (this.phase === "warmup") this.abortWarmup();
+    }, ms);
+  }
+
+  private abortWarmup(): void {
+    const heldBack = this.heldBack;
+    this.reset();
+    if (heldBack > 0) this.o.callbacks.onWarmupAbort?.(heldBack);
+  }
+
+  // ---- tap ----------------------------------------------------------------
+
+  private handleTap(data: string): KeyAction {
+    const key = this.o.key;
+    const kittyEvent = parseKittyKey(data);
+    const ours = kittyEvent ? kittyMatches(key, kittyEvent) : legacyMatches(key, data);
+    const now = this.now();
+    if (this.phase === "recording") {
+      if (ours) {
+        if (kittyEvent && kittyEvent.event !== "press") return { type: "consume" };
+        const gap = now - this.lastKeyAt;
+        this.lastKeyAt = now;
+        if (!kittyEvent && gap < this.t.tapDebounceMs) return { type: "consume" }; // auto-repeat of the starting press
+        this.reset();
+        this.o.callbacks.onStop(false);
+        return { type: "consume" };
+      }
+      if (isCancelKey(data)) {
+        this.reset();
+        this.o.callbacks.onCancel();
+        return { type: "consume" };
+      }
+      if (isEnterKey(data)) {
+        this.reset();
+        this.o.callbacks.onStop(true);
+        return { type: "consume" };
+      }
+      return { type: "consume" };
+    }
+    if (!ours) return { type: "pass" };
+    if (kittyEvent && kittyEvent.event !== "press") return { type: "consume" };
+    if (!this.o.canStart()) return { type: "pass" };
+    this.lastKeyAt = now;
+    this.phase = "recording";
+    this.o.callbacks.onStart(0);
+    return { type: "consume" };
+  }
+
+  private setTimer(fn: () => void, ms: number): void {
+    this.clearTimer();
+    this.timer = this.timers.set(() => {
+      this.timer = null;
+      fn();
+    }, ms);
+  }
+
+  private clearTimer(): void {
+    if (this.timer !== null) this.timers.clear(this.timer);
+    this.timer = null;
+  }
+}

package/assets/extensions/omnirush/voice/kitty.ts

@@ -0,0 +1,64 @@
+/**
+ * Kitty keyboard protocol helpers for hold-to-talk on a text key.
+ *
+ * The agent core negotiates flags 1|2|4 (disambiguate, event types,
+ * alternate keys). With those, plain text keys such as Space are still
+ * sent as text and their release is never reported. Flag 8 ("report all
+ * keys as escape codes") adds it, so while hold-to-talk on Space is armed
+ * voice mode sets flags 15 and translates every other text key back to
+ * its legacy bytes before anything else sees it: the editor, the core's
+ * keybindings and other extensions keep receiving what they always did.
+ * Turning voice off (or leaving) puts the core's flags back.
+ */
+
+import { parseKittyKey } from "./keys";
+
+/** The flags the agent core enables (pi-tui DESIRED_KITTY_KEYBOARD_PROTOCOL_FLAGS). */
+export const CORE_FLAGS = 7;
+/** Core flags plus "report all keys as escape codes". */
+export const ALL_KEYS_FLAGS = CORE_FLAGS | 8;
+
+/** CSI = flags ; 1 u — set the flags of the current stack entry (the core pops it on exit). */
+export function setFlagsSequence(flags: number): string {
+  return `\x1b[=${flags};1u`;
+}
+
+const CSI_U = /^\x1b\[(\d+)(?::(\d*))?(?::(\d+))?(?:;(\d+)(?::(\d+))?)?(?:;[\d:]*)?u$/;
+
+/**
+ * The legacy bytes of a flag-8 key event: text for printable keys with no
+ * modifier but Shift, "\r" / "\t" / "\x7f" for Enter / Tab / Backspace, ""
+ * (drop) for releases. Returns undefined for anything that is not a CSI-u
+ * key event or keeps its escape form (Ctrl/Alt combos, Esc, functional
+ * keys) — the core already understands those since it enabled flag 1.
+ */
+export function kittyToLegacy(data: string): string | undefined {
+  const m = CSI_U.exec(data);
+  if (!m) return undefined;
+  const ev = parseKittyKey(data);
+  if (!ev) return undefined;
+  if (ev.event === "release") return "";
+  const shift = (ev.modifiers & 1) !== 0;
+  if ((ev.modifiers & ~1) !== 0) return undefined;
+  const cp = ev.codepoint;
+  if (cp === 13) return shift ? undefined : "\r";
+  if (cp === 9) return shift ? "\x1b[Z" : "\t";
+  if (cp === 127 || cp === 8) return shift ? undefined : "\x7f";
+  if (cp === 27) return undefined;
+  // Private-use codepoints are functional keys (keypad, media, modifiers).
+  if (cp < 32 || (cp >= 57344 && cp <= 63743)) return undefined;
+  let out = cp;
+  if (shift) {
+    const shifted = m[2] ? Number(m[2]) : NaN;
+    if (Number.isFinite(shifted) && shifted > 0) out = shifted;
+    else {
+      const upper = String.fromCodePoint(cp).toUpperCase();
+      if ([...upper].length === 1) out = upper.codePointAt(0)!;
+    }
+  }
+  try {
+    return String.fromCodePoint(out);
+  } catch {
+    return undefined;
+  }
+}