fix(settings,ci): code review part 3, settings, release, CI and the e2e harness (#71) (#72)

Settings: the colour editor saves the whole setup into Custom and is a theme
pick (#8, #29); ThemeSwitchAsk registers once (#22); a hex field commits only
a changed draft (#26); the dictation key is never a key that types or a chord
the terminal owns, and a press elsewhere ends the capture (#27); the editor
takes the focus, traps Tab and hears Escape, the pencil is its own button
(#28); a finished download reads fresh state before picking the model (#30).

Release and CI: release.yml tags the built commit (#11); core-release runs
from main only (#34), waits for terminal-gate by name and its success (#38),
and opens an issue when a core change cannot be released; core-version also
requires the core version above the base's (#39).

Harness: a time limit per scenario and closeApp (#35), profiles removed after
each scenario (#36), the poll's first verdict awaited instead of 6 s (#37).

Core 0.15.3, app 0.18.3. New reviewSettings e2e and unit tests.


Claude-Session: https://claude.ai/code/session_01LJbePcRzre7AusNzPNS2Bk

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Author: Maxaubert

package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-term-core",
-  "version": "0.15.2",
+  "version": "0.15.3",
   "description": "What Prism Terminal and Prism share: the terminal (pty, shells, agent detection and indicator, themes, links, the panel, dictation) and the update chip with its window. TypeScript source, compiled by the host.",
   "license": "MIT",
   "private": true,

renderer/components/ThemeSwitchAsk.tsx

@@ -23,17 +23,27 @@ export default function ThemeSwitchAsk({
   onCancel: () => void
 }): JSX.Element {
   const save = useRef<HTMLButtonElement>(null)
+  // Registered ONCE (code review 2026-09-24, #22). Keyed on an inline
+  // onCancel, every render of the settings page re-ran this: the focus jumped
+  // back to Save from wherever Tab had taken it (Enter then saved instead of
+  // discarding), and the listener was torn down and put back, the race
+  // UpdateDialog measured as an Escape that did nothing. The latest onCancel
+  // is read through a ref.
+  const cancel = useRef(onCancel)
+  useEffect(() => {
+    cancel.current = onCancel
+  })
   useEffect(() => {
     save.current?.focus()
     const key = (e: KeyboardEvent): void => {
       if (e.key !== 'Escape') return
       e.preventDefault()
       e.stopPropagation()
-      onCancel()
+      cancel.current()
     }
     window.addEventListener('keydown', key, true)
     return () => window.removeEventListener('keydown', key, true)
-  }, [onCancel])
+  }, [])
   return (
     <div
       data-theme-switch-ask

renderer/lib/dictationKey.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest'
 import {
   DEFAULT_HOTKEY,
+  usableHotkey,
   formatHotkey,
   initialKeyState,
   isHotkeyEvent,
@@ -462,3 +463,34 @@ describe('keyEvtFromDom', () => {
     })
   })
 })
+
+// Code review 2026-09-24, #27: the dictation key is swallowed in every shell,
+// so it may never be a key that types or a chord the terminal owns.
+describe('usableHotkey', () => {
+  const hk = (code: string, mods: Partial<Record<'ctrl' | 'alt' | 'shift' | 'meta', boolean>> = {}) => ({
+    code,
+    ctrl: false,
+    alt: false,
+    shift: false,
+    meta: false,
+    ...mods
+  })
+  it('takes the default, a bare modifier, a function key and a free chord', () => {
+    expect(usableHotkey(DEFAULT_HOTKEY)).toBe(true)
+    expect(usableHotkey(hk('ControlLeft'))).toBe(true)
+    expect(usableHotkey(hk('F9'))).toBe(true)
+    expect(usableHotkey(hk('Pause'))).toBe(true)
+    expect(usableHotkey(hk('KeyD', { ctrl: true, shift: true }))).toBe(true)
+    expect(usableHotkey(hk('Space', { alt: true }))).toBe(true)
+  })
+  it('refuses a key that types, with or without Shift', () => {
+    for (const code of ['KeyA', 'Enter', 'Space', 'Tab', 'Backspace', 'Digit1'])
+      expect(usableHotkey(hk(code))).toBe(false)
+    expect(usableHotkey(hk('KeyA', { shift: true }))).toBe(false)
+  })
+  it('refuses the chords the terminal owns', () => {
+    for (const code of ['KeyC', 'KeyV', 'KeyW', 'KeyT', 'KeyF', 'Tab', 'Digit2', 'Comma'])
+      expect(usableHotkey(hk(code, { ctrl: true }))).toBe(false)
+    expect(usableHotkey(hk('KeyC', { ctrl: true, shift: true }))).toBe(false)
+  })
+})

renderer/lib/dictationKey.ts

@@ -365,6 +365,23 @@ export function parseHotkeyFromEvent(evt: KeyEvt | KeyChord | DomKeyLike): Hotke
   return { code: evt.code, ctrl: evt.ctrl, alt: evt.alt, shift: evt.shift, meta: evt.meta }
 }
 
+/**
+ * Whether a key may be the dictation key at all (code review 2026-09-24, #27).
+ * Dictation swallows its key in every shell, so a key that TYPES (a letter,
+ * Enter, Space, a Shift+letter) would stop the terminal from typing it until
+ * somebody found Reset, and a chord the terminal owns (Ctrl+C, Ctrl+V, the tab
+ * chords) would take that job away. Allowed: a bare modifier (the default is
+ * Right Alt), a function key or Pause / Scroll Lock alone, or a chord with Ctrl,
+ * Alt or Win that the terminal does not already use.
+ */
+export function usableHotkey(h: Hotkey): boolean {
+  if (isBareModifier(h)) return true
+  if (!h.ctrl && !h.alt && !h.meta)
+    return /^F([1-9]|1[0-9]|2[0-4])$/.test(h.code) || h.code === 'Pause' || h.code === 'ScrollLock'
+  if (h.ctrl && !h.alt && !h.meta && /^(Key[CVWTF]|Tab|Digit[1-9]|Comma)$/.test(h.code)) return false
+  return true
+}
+
 /** The fields of a DOM KeyboardEvent the reducer reads, named structurally so
  *  this file stays free of the DOM. */
 export interface DomKeyLike {

renderer/lib/dictationPrefs.ts

@@ -1,5 +1,5 @@
 import { useSyncExternalStore } from 'react'
-import { DEFAULT_HOTKEY, type DictMode, type Hotkey } from './dictationKey'
+import { DEFAULT_HOTKEY, usableHotkey, type DictMode, type Hotkey } from './dictationKey'
 
 /**
  * Dictation's settings (#13). VALUES ARE PER APP: each app has its own
@@ -66,8 +66,11 @@ export function dictationHotkey(): Hotkey {
   if (raw) {
     try {
       const v = JSON.parse(raw) as Partial<Hotkey>
-      if (typeof v.code === 'string' && v.code)
-        hotkeyParsed = { code: v.code, ctrl: !!v.ctrl, alt: !!v.alt, shift: !!v.shift, meta: !!v.meta }
+      const hk = typeof v.code === 'string' && v.code
+        ? { code: v.code, ctrl: !!v.ctrl, alt: !!v.alt, shift: !!v.shift, meta: !!v.meta }
+        : null
+      // A key that types, saved before the rule existed, reads as the default.
+      if (hk && usableHotkey(hk)) hotkeyParsed = hk
     } catch {
       /* a damaged value reads as the default */
     }

renderer/settings/Dictation.tsx

@@ -2,8 +2,9 @@ import { useCallback, useEffect, useRef, useState, type JSX, type ReactNode } fr
 import { dictationHost } from '../host'
 import { catalogEntry, LANGUAGES, recommendedModel, visibleModels } from '../../shared/dictationCatalog'
 import type { CatalogEntry, DownloadFailure, EngineInfo, ItemStatus } from '../../shared/dictationTypes'
-import { DEFAULT_HOTKEY, formatHotkey, parseHotkeyFromEvent, type Hotkey } from '../lib/dictationKey'
+import { DEFAULT_HOTKEY, formatHotkey, parseHotkeyFromEvent, usableHotkey, type Hotkey } from '../lib/dictationKey'
 import {
+  dictationModel,
   setDictationEnabled,
   setDictationHotkey,
   setDictationLanguage,
@@ -83,7 +84,9 @@ function HotkeyField({ value, disabled }: { value: Hotkey; disabled: boolean }):
       const hk = parseHotkeyFromEvent(e)
       if (!hk) return
       if (isModifier(e.code)) bare = hk
-      else {
+      // A key that types, or a chord the terminal owns, is not taken (#27):
+      // the field keeps listening for one that can be.
+      else if (usableHotkey(hk)) {
         setDictationHotkey(hk)
         setListening(false)
       }
@@ -97,13 +100,21 @@ function HotkeyField({ value, disabled }: { value: Hotkey; disabled: boolean }):
       }
     }
     const stop = (): void => setListening(false)
+    // A press anywhere else ends the capture: left armed, the next key typed
+    // on the page became the dictation key. The button's own press is its
+    // click's to answer.
+    const away = (e: PointerEvent): void => {
+      if (!(e.target instanceof Element && e.target.closest('#dictation-hotkey'))) setListening(false)
+    }
     window.addEventListener('keydown', down, true)
     window.addEventListener('keyup', up, true)
     window.addEventListener('blur', stop)
+    window.addEventListener('pointerdown', away, true)
     return () => {
       window.removeEventListener('keydown', down, true)
       window.removeEventListener('keyup', up, true)
       window.removeEventListener('blur', stop)
+      window.removeEventListener('pointerdown', away, true)
     }
   }, [listening])
   const isDefault = JSON.stringify(value) === JSON.stringify(DEFAULT_HOTKEY)
@@ -365,11 +376,18 @@ export function DictationSettings(): JSX.Element | null {
   const download = (id: string): void => {
     setFailures((prev) => without(prev, id))
     setStatus((prev) => [...prev.filter((s) => s.id !== id), { id, state: 'downloading', received: 0 }])
-    void api.dictationDownload(id).then((res) => {
+    void api.dictationDownload(id).then(async (res) => {
       setProgress((prev) => without(prev, id))
       if (!res.ok) setFailures((prev) => ({ ...prev, [id]: res.reason }))
-      // The first model anyone downloads is the one they meant to use.
-      else if (catalogEntry(id)?.kind === 'model' && !installed(model)) setDictationModel(id)
+      else if (catalogEntry(id)?.kind === 'model') {
+        // The first model anyone downloads is the one they meant to use. Read
+        // NOW, not from the render the click came from (code review
+        // 2026-09-24, #30): a second download finishing after the first had
+        // become the model, or after a pick with Use, replaced it unasked.
+        const current = dictationModel()
+        const on = await api.dictationStatus()
+        if (!on.some((s) => s.id === current && s.state === 'installed')) setDictationModel(id)
+      }
       refresh()
     })
   }