scribe-cli 1.0.1__tar.gz → 1.1.0__tar.gz

{scribe_cli-1.0.1 → scribe_cli-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scribe-cli
-Version: 1.0.1
+Version: 1.1.0
 Summary: Speech-to-text CLI and system-tray app for dictating into any focused window. Local (vosk, faster-whisper) or cloud (groq, openai) backends, batch or streaming.
 Author-email: Mahé Perrette <mahe.perrette@gmail.com>
 License: MIT License
@@ -217,7 +217,8 @@ I personally use [OpenAI](https://openai.com/api/) with `gpt-4o-mini-transcribe`
 - [Installation & dependencies](docs/installation.md) — PortAudio,
   extras, Ubuntu / GNOME tray libs.
 - [Backends in detail](docs/backends.md) — model lists, when to pick
-  which, the realtime model.
+  which, the realtime model, [Streaming recipes](docs/backends.md#streaming-recipes--two-profiles)
+  (Balanced / Patient profiles).
 - [Output modes & typer backends](docs/output.md) — keystroke vs
   clipboard, Wayland / `eitype`, `--type-direct`.
 - [System tray & global hotkeys](docs/tray.md) — menu tree, icon

{scribe_cli-1.0.1 → scribe_cli-1.1.0}/README.md

@@ -113,7 +113,8 @@ I personally use [OpenAI](https://openai.com/api/) with `gpt-4o-mini-transcribe`
 - [Installation & dependencies](docs/installation.md) — PortAudio,
   extras, Ubuntu / GNOME tray libs.
 - [Backends in detail](docs/backends.md) — model lists, when to pick
-  which, the realtime model.
+  which, the realtime model, [Streaming recipes](docs/backends.md#streaming-recipes--two-profiles)
+  (Balanced / Patient profiles).
 - [Output modes & typer backends](docs/output.md) — keystroke vs
   clipboard, Wayland / `eitype`, `--type-direct`.
 - [System tray & global hotkeys](docs/tray.md) — menu tree, icon

{scribe_cli-1.0.1 → scribe_cli-1.1.0}/docs/backends.md

@@ -164,6 +164,31 @@ the one place a separate "dictionary" really exists — everywhere else
 `--words` is just a convenience to keep your word list out of the
 prompt string in the CLI.
 
+### Prompt style biases output style
+
+Whisper mirrors the *style* of whatever prompt it receives. A
+prompt like `"Tierney Comet"` (a bare wordlist) biases the model
+toward unpunctuated, list-style output — sentences come out without
+periods. A prompt like `"Tierney, Comet."` (or any prose ending in a
+period) biases it toward punctuated output. Two practical
+consequences:
+
+- **`--prompt` is yours to control.** If your `prompt.txt` ends with
+  a period and looks like a sentence, your transcripts will be
+  punctuated. If it ends with a bare keyword, they probably won't.
+  This effect is most visible in **Stream mode**, where Whisper sees
+  short audio chunks and leans more heavily on the prompt for style
+  cues.
+- **`--words` is auto-formatted by scribe.** For backends that fold
+  words into the prompt (`whisper-futo`, `openai`, `groq`), scribe
+  renders the word list as `"word1, word2, …, wordN."` — comma-
+  separated with a single terminal period — so your `words.txt` can
+  stay a bare list with no special formatting and the bias still
+  comes out punctuated. Stray punctuation on individual entries is
+  stripped first, so `words.txt` content is normalised regardless of
+  layout. On `whisper` (faster-whisper, local), words go to the
+  dedicated `hotwords` channel and bypass the prompt entirely.
+
 Both flags read from the corresponding `*-file` argument when present.
 Inline + file inputs are combined.
 
@@ -250,6 +275,21 @@ Once the buffer has grown to at least `--stream-chunk-min` (default
 (default 10 s) regardless of silence, to cap latency. The session
 continues until you stop it manually.
 
+The **first** chunk of a streaming thread uses a different floor:
+`--stream-first-chunk-min` (default 3 s). The bootstrap chunk has no
+prior text to bias Whisper's punctuation/casing, so a longer audio
+window lets the model produce a properly-punctuated transcript whose
+tail then seeds the rolling prompt for every chunk after it.
+Subsequent chunks fall back to `--stream-chunk-min`. The override
+also re-engages right after a context-reset silence (i.e. when a long
+pause cleared the rolling tail — see *Cross-chunk prompt context*
+below). Set `--stream-first-chunk-min` equal to `--stream-chunk-min`
+to disable the override. It's automatically inactive when
+`--stream-context-length 0` (Patient profile), where there is no
+rolling context to bootstrap. Internally clamped to `≤
+--stream-chunk-max` so a misconfigured pair can't deadlock the
+chunker.
+
 ### Does pseudo-streaming change the API cost?
 
 For cloud backends, going from one big transcription to N chunked
@@ -321,3 +361,40 @@ arbitrarily long pauses.
 
 Short pauses (mid-sentence punctuation) keep the context; the cut at
 the start of every new recording also clears it.
+
+### Streaming recipes — two profiles
+
+The defaults stream phrases in as you talk; the Patient profile waits
+for natural pauses and transcribes one utterance at a time. They make
+opposite trade-offs around the same fundamental tension: short audio
+windows give Whisper less to work with, so cross-chunk *context*
+matters more in Balanced, less in Patient.
+
+#### Balanced (default)
+
+```bash
+scribe --stream
+```
+
+Phrases commit every ~10 s or on a 0.6 s pause, with a 200-char
+rolling prompt carrying earlier text forward as context for each new
+chunk. Whisper sees short audio windows in isolation; the rolling
+context partially compensates by telling the model what was just
+said. Good live-feel, small per-chunk accuracy hit vs. Patient.
+
+#### Patient (auto-clip)
+
+```bash
+scribe --stream \
+       --stream-chunk-min 0.5 \
+       --stream-chunk-max 300 \
+       --stream-chunk-silence-break 2 \
+       --stream-context-length 0
+```
+
+Each utterance is a complete self-contained sentence. scribe waits
+for a 2 s pause, transcribes the whole thing at once, then waits for
+the next one. No rolling context (`context-length 0`) because each
+chunk is already a full utterance — there's nothing short to
+compensate for. Highest per-chunk accuracy; no text appears until
+you finish talking.

{scribe_cli-1.0.1 → scribe_cli-1.1.0}/docs/cli.md

@@ -121,6 +121,7 @@ silence-chunking knobs; they have their own end-of-utterance signal.
 | `--clip`                          | default | Transcribe the whole recording at end. Same as the tray's **Mode: Clip**.                 |
 | `--stream-chunk-max SECS`         | `10`    | Maximum chunk duration in seconds. Force-cut fires at this threshold when no silence pause has been detected (default `10`). |
 | `--stream-chunk-min SECS`         | `1.5`   | Minimum chunk size before a silence-cut is allowed (default `1.5`). Prevents very short clips that cause Whisper hallucinations. |
+| `--stream-first-chunk-min SECS`   | `3.0`   | Minimum chunk size for the *first* chunk of a streaming thread (default `3.0`). Higher than `--stream-chunk-min` so the bootstrap chunk has enough audio for Whisper to produce a punctuated transcript whose tail seeds the rolling prompt for the rest. Applies on recording start and right after a context-reset silence. Inactive when `--stream-context-length 0`. Clamped to `≤ --stream-chunk-max`. Set equal to `--stream-chunk-min` to disable. |
 | `--stream-chunk-silence-break SECS` | `0.6` | Silence duration that triggers a chunk cut (default `0.6`). Special value `0` enables Auto mode (best-silence-in-window at force-cut time). |
 | `--stream-context-reset-silence X` | `3.0`  | Multiplier of `--stream-chunk-silence-break` above which the rolling cross-chunk prompt context is discarded (default `3.0`, i.e. 1.8 s at default silence-break). Use `inf` to never reset. |
 | `--clip-timeout SECS`             | `120`   | Auto-stop after this many seconds in Clip mode (default `120`). |

{scribe_cli-1.0.1 → scribe_cli-1.1.0}/scribe/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.1'
-__version_tuple__ = version_tuple = (1, 0, 1)
+__version__ = version = '1.1.0'
+__version_tuple__ = version_tuple = (1, 1, 0)
 
-__commit_id__ = commit_id = 'g768aa6b57'
+__commit_id__ = commit_id = 'g9b8b835fd'

{scribe_cli-1.0.1 → scribe_cli-1.1.0}/scribe/app.py

@@ -144,6 +144,29 @@ DEFAULT_WORDS_FILE = os.path.join(SCRIBE_CONFIG_DIR, "words.txt")
 DEFAULT_OUTPUT_FILE = os.path.join(platformdirs.user_desktop_dir(), "scribe-notes.txt")
 
 
+def autodiscover_prompt_files(o):
+    """Persist auto-discovered ``prompt.txt`` / ``words.txt`` defaults into
+    the argparse namespace ``o`` so downstream consumers (the tray menu's
+    "Prompt file: …" label, the runtime reload helper) can read them as
+    first-class state instead of re-deriving the defaults. Mirrors the
+    fallback condition in :func:`_resolve_prompt_and_words` exactly: only
+    fires when both the inline flag and the file flag are *unset* — passing
+    ``--prompt ""`` / ``--prompt-file ""`` still suppresses the default.
+    ``o.prompt`` / ``o.prompt_file`` (and the words counterparts) are
+    expected to exist (argparse fills them with ``None``); missing attrs
+    are tolerated for tests that build minimal namespaces."""
+    if (getattr(o, "prompt", None) is None
+            and getattr(o, "prompt_file", None) is None
+            and os.path.exists(DEFAULT_PROMPT_FILE)):
+        o.prompt_file = DEFAULT_PROMPT_FILE
+        print(f"Using default prompt file: {DEFAULT_PROMPT_FILE}")
+    if (getattr(o, "words", None) is None
+            and getattr(o, "words_file", None) is None
+            and os.path.exists(DEFAULT_WORDS_FILE)):
+        o.words_file = DEFAULT_WORDS_FILE
+        print(f"Using default words file: {DEFAULT_WORDS_FILE}")
+
+
 def _resolve_prompt_and_words(prompt_text, prompt_file, words, words_file):
     """Read --prompt-file / --words-file from disk and merge with the inline
     flags. Returns ``(prompt_str_or_None, words_list_or_empty)``.
@@ -178,6 +201,43 @@ def _resolve_prompt_and_words(prompt_text, prompt_file, words, words_file):
     return (prompt_text or None), words
 
 
+_WORD_STRIP_CHARS = " \t\r\n.,;:!?"
+
+
+def _format_words_for_prompt(words):
+    """Render a `--words` list as a punctuated string suitable for joining
+    into a Whisper-family prompt. ``["Tierney", "Comet"]`` → ``"Tierney,
+    Comet."``. Trailing period biases the model toward emitting periods
+    of its own (Whisper mirrors prompt style); comma separator avoids the
+    "every word is its own sentence" look. Strips any stray punctuation
+    the user may have left on individual entries so the output is well-
+    formed regardless of input. Returns ``""`` for an empty list."""
+    cleaned = [w.strip(_WORD_STRIP_CHARS) for w in (words or [])]
+    cleaned = [w for w in cleaned if w]
+    if not cleaned:
+        return ""
+    return ", ".join(cleaned) + "."
+
+
+def compose_prompt_for_backend(backend, prompt_text, words):
+    """Compose ``(prompt, hotwords)`` for a backend, applying the words-
+    auto-format rule. faster-whisper has a dedicated `hotwords` channel so
+    we keep words separate and untouched; every other prompt-using backend
+    (whisper-futo / openai / groq) gets words folded into the prompt as a
+    punctuated sentence so the prompt style biases Whisper toward
+    punctuated output. Returns ``(None, None)`` when both sides are empty
+    so callers can skip the kwarg entirely."""
+    if backend == "whisper":
+        return ((prompt_text or None),
+                (" ".join(words) if words else None))
+    words_blob = _format_words_for_prompt(words)
+    if prompt_text and words_blob:
+        merged = f"{prompt_text} {words_blob}"
+    else:
+        merged = prompt_text or words_blob
+    return ((merged or None), None)
+
+
 def _build_backend_kwargs(backend, model, language, samplerate, duration,
                           silence_db, stream_chunk_silence_break, realtime_commit_silence,
                           vad_mode, vad_threshold, vad_min_silence_ms,
@@ -185,17 +245,11 @@ def _build_backend_kwargs(backend, model, language, samplerate, duration,
                           download_folder_whisper_futo,
                           realtime_delay, realtime_gate,
                           pseudo_streaming, stream_chunk_max,
-                          stream_chunk_min, stream_context_reset_silence,
+                          stream_chunk_min, stream_first_chunk_min,
+                          stream_context_reset_silence,
                           stream_context_length,
-                          prompt_text, words, dry_run=False):
-    # Cloud whisper variants (OpenAI batch, Groq, OpenAI realtime) take a
-    # single `prompt` string — fold the word list into it. faster-whisper
-    # gets the word list separately via `hotwords=` (dedicated biasing
-    # channel), so we pass it through unmerged.
-    merged_prompt = prompt_text
-    if words and backend != "whisper":
-        word_blob = " ".join(words)
-        merged_prompt = f"{prompt_text} {word_blob}" if prompt_text else word_blob
+                          prompt_text, words, dry_run=False, debug=False):
+    composed_prompt, composed_hotwords = compose_prompt_for_backend(backend, prompt_text, words)
 
     vad_kwargs = dict(vad_mode=vad_mode, vad_threshold=vad_threshold,
                       vad_min_silence_ms=vad_min_silence_ms)
@@ -204,7 +258,7 @@ def _build_backend_kwargs(backend, model, language, samplerate, duration,
         return dict(model_name=model, language=language, samplerate=samplerate,
                     timeout=None,
                     model_kwargs={"download_root": download_folder_vosk},
-                    dry_run=dry_run)
+                    dry_run=dry_run, debug=debug)
     if backend == "whisper":
         return dict(model_name=model, language=language, samplerate=samplerate,
                     timeout=duration,
@@ -213,12 +267,13 @@ def _build_backend_kwargs(backend, model, language, samplerate, duration,
                     silence_thresh=silence_db,
                     pseudo_streaming=pseudo_streaming, stream_chunk_max=stream_chunk_max,
                     stream_chunk_min=stream_chunk_min,
+                    stream_first_chunk_min=stream_first_chunk_min,
                     stream_context_reset_silence=stream_context_reset_silence,
                     stream_context_length=stream_context_length,
-                    prompt=prompt_text,
-                    hotwords=(" ".join(words) if words else None),
+                    prompt=composed_prompt,
+                    hotwords=composed_hotwords,
                     model_kwargs={"download_root": download_folder_whisper},
-                    dry_run=dry_run,
+                    dry_run=dry_run, debug=debug,
                     **vad_kwargs)
     if backend == "whisper-futo":
         # pywhispercpp 1.4.1 exposes `initial_prompt`; the backend folds
@@ -232,11 +287,12 @@ def _build_backend_kwargs(backend, model, language, samplerate, duration,
                     silence_thresh=silence_db,
                     pseudo_streaming=pseudo_streaming, stream_chunk_max=stream_chunk_max,
                     stream_chunk_min=stream_chunk_min,
+                    stream_first_chunk_min=stream_first_chunk_min,
                     stream_context_reset_silence=stream_context_reset_silence,
                     stream_context_length=stream_context_length,
-                    prompt=merged_prompt,
+                    prompt=composed_prompt,
                     download_folder=download_folder_whisper_futo,
-                    dry_run=dry_run,
+                    dry_run=dry_run, debug=debug,
                     **vad_kwargs)
     if backend in ("openai", "groq"):
         from scribe.backends.openai_api import REALTIME_MODELS
@@ -247,10 +303,11 @@ def _build_backend_kwargs(backend, model, language, samplerate, duration,
                       silence_thresh=silence_db,
                       pseudo_streaming=pseudo_streaming, stream_chunk_max=stream_chunk_max,
                       stream_chunk_min=stream_chunk_min,
+                      stream_first_chunk_min=stream_first_chunk_min,
                       stream_context_reset_silence=stream_context_reset_silence,
                       stream_context_length=stream_context_length,
-                      prompt=merged_prompt,
-                      dry_run=dry_run,
+                      prompt=composed_prompt,
+                      dry_run=dry_run, debug=debug,
                       **vad_kwargs)
         if backend == "openai" and model in REALTIME_MODELS:
             kwargs["realtime_delay"] = realtime_delay
@@ -272,10 +329,11 @@ def get_transcriber(model=None, backend=None, dummy=False, interactive=True, lan
                     download_folder_whisper_futo=None,
                     realtime_delay="medium", realtime_gate=True,
                     pseudo_streaming=False, stream_chunk_max=10.0,
-                    stream_chunk_min=1.5, stream_context_reset_silence=3.0,
+                    stream_chunk_min=1.5, stream_first_chunk_min=3.0,
+                    stream_context_reset_silence=3.0,
                     stream_context_length=200,
                     prompt=None, prompt_file=None, words=None, words_file=None,
-                    dry_run=False, **kwargs):
+                    dry_run=False, debug=False, **kwargs):
     if dummy:
         return DummyTranscriber("whisper", "dummy")
     if model and not backend:
@@ -313,9 +371,10 @@ def get_transcriber(model=None, backend=None, dummy=False, interactive=True, lan
                                           download_folder_whisper_futo,
                                           realtime_delay, realtime_gate,
                                           pseudo_streaming, stream_chunk_max,
-                                          stream_chunk_min, stream_context_reset_silence,
+                                          stream_chunk_min, stream_first_chunk_min,
+                                          stream_context_reset_silence,
                                           stream_context_length,
-                                          prompt_text, word_list, dry_run=dry_run)
+                                          prompt_text, word_list, dry_run=dry_run, debug=debug)
     try:
         return _build_transcriber(backend, **backend_kwargs)
     except Exception as error:
@@ -378,6 +437,10 @@ def get_parser():
                             "Used by tests/test_backend_matrix.py to exercise the "
                             "recording pipeline without network access or every "
                             "model on disk.")
+    group.add_argument("--debug", action="store_true", dest="debug",
+                       help="Log one line per STT request (model, language, "
+                            "prompt, audio length) for diagnosing transcription "
+                            "issues.")
 
     group = parser.add_argument_group("Output")
     group.add_argument("-m", "--mode",
@@ -480,6 +543,16 @@ def get_parser():
     group.add_argument("--streaming-window", type=lambda s: 2.0 * float(s),
                        dest="stream_chunk_max", default=argparse.SUPPRESS,
                        help=argparse.SUPPRESS)
+    group.add_argument("--stream-first-chunk-min", default=3.0, type=float,
+                       dest="stream_first_chunk_min",
+                       help="Minimum chunk size in seconds for the *first* chunk "
+                            "of a streaming thread (default: %(default)s). Higher "
+                            "than --stream-chunk-min so the bootstrap chunk has "
+                            "enough audio for Whisper to produce a punctuated "
+                            "transcript, whose tail then seeds the rolling prompt "
+                            "for subsequent chunks. Applies on recording start and "
+                            "right after a context-reset silence. Clamped to "
+                            "<= --stream-chunk-max.")
     group.add_argument("--stream-chunk-min", default=1.5, type=float,
                        help="Minimum chunk size in seconds before a silence-cut "
                             "is allowed in --stream mode (default: %(default)s). "
@@ -788,6 +861,14 @@ def main(args=None):
     parser = get_parser()
     o = parser.parse_args(args)
 
+    # Surface auto-discovered prompt.txt / words.txt defaults on the
+    # namespace before downstream consumers read it. Without this, the
+    # tray menu's "Prompt file: …" / "Words file: …" labels show "(none)"
+    # even when scribe is actively biasing on a default file — the file
+    # was being loaded by `_resolve_prompt_and_words`, but the resolved
+    # path stayed local to that function and never propagated to `o`.
+    autodiscover_prompt_files(o)
+
     # Reconcile --stream / --clip with the legacy --pseudo-streaming flag.
     # --stream / --clip win when present; otherwise the existing
     # --pseudo-streaming boolean drives the default.

{scribe_cli-1.0.1 → scribe_cli-1.1.0}/scribe/backends/openai_api.py

@@ -57,6 +57,7 @@ class OpenaiAPITranscriber(WhisperTranscriber):
         buffer.name = "audio.wav"  # Set a filename with a valid extension
         prompt = self.compose_prompt(self._prompt)
         extra = {"prompt": prompt} if prompt else {}
+        self.debug_log_request(audio_bytes, model=self.model_name, prompt=prompt)
         try:
             transcription = self.model.audio.transcriptions.create(
                 model=self.model_name,

{scribe_cli-1.0.1 → scribe_cli-1.1.0}/scribe/backends/whisper.py

@@ -33,12 +33,16 @@ class WhisperTranscriber(AbstractTranscriber):
             self.update_streaming_context(text)
             return {"text": text}
         audio_array = np.frombuffer(audio_bytes, dtype=np.int16).flatten().astype(np.float32) / 32768.0
+        composed_prompt = self.compose_prompt(self._prompt)
+        self.debug_log_request(audio_bytes, model=self.model_name,
+                               language=self.language, prompt=composed_prompt,
+                               hotwords=self._hotwords)
         segments, _info = self.model.transcribe(
             audio_array,
             language=self.language,
             vad_filter=True,
             beam_size=1,
-            initial_prompt=self.compose_prompt(self._prompt),
+            initial_prompt=composed_prompt,
             hotwords=self._hotwords,
             no_speech_threshold=0.6,
             log_prob_threshold=-1.0,

{scribe_cli-1.0.1 → scribe_cli-1.1.0}/scribe/backends/whisper_futo.py

@@ -165,6 +165,11 @@ class WhisperFutoTranscriber(AbstractTranscriber):
         # recording is a single longer utterance.
         if self.pseudo_streaming:
             kwargs["max_tokens"] = max(12, int(duration_s * 12))
+        self.debug_log_request(audio_bytes, model=self.model_name,
+                               language=kwargs.get("language"),
+                               prompt=kwargs.get("initial_prompt"),
+                               audio_ctx=kwargs.get("audio_ctx"),
+                               max_tokens=kwargs.get("max_tokens"))
         segments = self.model.transcribe(audio, **kwargs)
         text = "".join(s.text for s in segments)
         if self.pseudo_streaming:

{scribe_cli-1.0.1 → scribe_cli-1.1.0}/scribe/dialog.py

@@ -7,6 +7,32 @@ Kept scribe-local for now so the worktree is self-contained; promotion to
 from __future__ import annotations
 
 
+def select_file_open(
+    title: str = "Choose file",
+    initial_dir: str | None = None,
+    initial_file: str | None = None,
+    filetypes: list[tuple[str, str]] | None = None,
+) -> str | None:
+    """Open a native 'Open' file dialog for an existing file. Returns the
+    chosen path or None if the user cancelled. Same Tk-lifecycle pattern as
+    ``select_file_save`` (withdrawn root, destroy in finally) so repeated
+    invocations from the tray menu don't leak top-level windows."""
+    from tkinter import Tk, filedialog
+
+    root = Tk()
+    root.withdraw()
+    try:
+        path = filedialog.askopenfilename(
+            title=title,
+            initialdir=initial_dir,
+            initialfile=initial_file,
+            filetypes=filetypes or [("All files", "*.*"), ("Text", "*.txt")],
+        )
+        return path or None
+    finally:
+        root.destroy()
+
+
 def select_file_save(
     title: str = "Choose output file",
     initial_dir: str | None = None,

{scribe_cli-1.0.1 → scribe_cli-1.1.0}/scribe/menu.py

@@ -514,6 +514,73 @@ class AppState(AbstractFrontendApp):
         self._refresh_tray_menu()
         return True
 
+    def cb_pick_prompt_file_path(self, view, item):
+        """Open a native 'Open File' dialog and route the chosen file as the
+        prompt source. Updates ``o.prompt_file`` + ``self.params``, then
+        re-resolves the prompt/words and pushes the result into the live
+        transcriber's ``_prompt`` / ``_hotwords`` so the new bias takes
+        effect on the next chunk. Cancel → no-op."""
+        return self._pick_prompt_or_words("prompt_file", "Choose prompt file")
+
+    def cb_pick_words_file_path(self, view, item):
+        """Same as :meth:`cb_pick_prompt_file_path` but for the words file."""
+        return self._pick_prompt_or_words("words_file", "Choose words file")
+
+    def cb_reload_prompt_files(self, view, item):
+        """Re-read the currently-selected prompt + words files from disk
+        without opening a dialog. Lets the user edit ``prompt.txt`` /
+        ``words.txt`` in a text editor and pick up the change with a single
+        click instead of having to re-select the same file via the picker."""
+        self._reload_prompt_into_transcriber()
+        self._refresh_tray_menu()
+        return True
+
+    def _pick_prompt_or_words(self, attr, title):
+        """Shared core for the two file pickers — ``attr`` is the namespace
+        key (``"prompt_file"`` or ``"words_file"``) and ``title`` is the
+        dialog caption."""
+        from os.path import basename, dirname
+
+        from scribe.app import SCRIBE_CONFIG_DIR
+        from scribe.dialog import select_file_open
+
+        current = getattr(self.o, attr, None)
+        initial_dir = dirname(current) if current else SCRIBE_CONFIG_DIR
+        initial_file = basename(current) if current else None
+        path = select_file_open(title=title,
+                                initial_dir=initial_dir,
+                                initial_file=initial_file)
+        if path is None:
+            return True
+        setattr(self.o, attr, path)
+        self.params[attr] = path
+        self._reload_prompt_into_transcriber()
+        self._refresh_tray_menu()
+        return True
+
+    def _reload_prompt_into_transcriber(self):
+        """Re-resolve ``--prompt`` / ``--prompt-file`` / ``--words`` /
+        ``--words-file`` from the current ``self.o`` snapshot and push the
+        composed result into the live transcriber. No-op when no transcriber
+        is attached (e.g. during early menu construction in tests)."""
+        from scribe.app import _resolve_prompt_and_words, compose_prompt_for_backend
+
+        prompt_text, word_list = _resolve_prompt_and_words(
+            getattr(self.o, "prompt", None),
+            getattr(self.o, "prompt_file", None),
+            getattr(self.o, "words", None),
+            getattr(self.o, "words_file", None),
+        )
+        t = self.transcriber
+        if t is None:
+            return
+        backend = getattr(t, "backend", None)
+        composed_prompt, composed_hotwords = compose_prompt_for_backend(
+            backend, prompt_text, word_list)
+        t._prompt = composed_prompt
+        if hasattr(t, "_hotwords"):
+            t._hotwords = composed_hotwords
+
     def cb_set_input_mode(self, type_direct: bool) -> Callable:
         """Factory: callback for the Keyboard → Input mode radio.
 
@@ -1175,7 +1242,7 @@ def _stream_advanced_submenu(app_state) -> Menu:
 
     chunk_max_item = Item("max",
                           _picker_submenu("Chunk max",
-                                          [3.0, 5.0, 10.0, 20.0, None],
+                                          [3.0, 5.0, 10.0, 15.0, 20.0, None],
                                           get_chunk_max, _chunk_max_label,
                                           app_state.cb_set_stream_chunk_max),
                           help="Chunk max",
@@ -1202,7 +1269,7 @@ def _stream_advanced_submenu(app_state) -> Menu:
 
     context_reset_item = Item("reset",
                               _picker_submenu("Context reset",
-                                              [1.0, 1.5, 2.0, 3.0, 5.0, 10.0, math.inf],
+                                              [1.0, 1.5, 2.0, 3.0, 5.0, 8.0, 10.0, math.inf],
                                               get_context_reset, _context_reset_label,
                                               app_state.cb_set_stream_context_reset_silence),
                               help="Context reset",
@@ -1312,6 +1379,51 @@ def _keyboard_advanced_submenu(app_state) -> Menu:
     return Menu(items, name="Keyboard (advanced)")
 
 
+def _prompt_status_label(o) -> str:
+    """Short status string for the Options → Prompt label: which of the two
+    files is loaded, e.g. ``"prompt+words"``, ``"words only"``, ``"none"``.
+    Keeps the menu line compact while still telling the user whether *any*
+    bias is in effect; basenames live inside the submenu items."""
+    has_prompt = bool(getattr(o, "prompt_file", None) or getattr(o, "prompt", None))
+    has_words = bool(getattr(o, "words_file", None) or getattr(o, "words", None))
+    if has_prompt and has_words:
+        return "prompt + words"
+    if has_prompt:
+        return "prompt only"
+    if has_words:
+        return "words only"
+    return "none"
+
+
+def _prompt_files_submenu(app_state) -> Menu:
+    """Options → Prompt submenu: pickers for the prompt file and words file.
+
+    Each leaf's label shows the basename of the currently-loaded file (or
+    "(none)") so the user can see at a glance which file is biasing the
+    model. Click → native Open File dialog. Mirrors the Output → Choose
+    path… picker UX. Both fall back to ``~/.config/scribe/`` (resolved via
+    platformdirs in :data:`scribe.app.SCRIBE_CONFIG_DIR`) as the initial
+    directory when no file is currently set."""
+    from os.path import basename
+
+    def _label(attr, kind):
+        path = getattr(app_state.o, attr, None)
+        return f"{kind} file: {basename(path) if path else '(none)'}"
+
+    prompt_item = Item("prompt", app_state.cb_pick_prompt_file_path,
+                       help="Prompt file (free-text style hint)")
+    prompt_item.label_fn = lambda: _label("prompt_file", "Prompt")
+    words_item = Item("words", app_state.cb_pick_words_file_path,
+                      help="Words file (vocabulary bias)")
+    words_item.label_fn = lambda: _label("words_file", "Words")
+    # Reload re-reads the currently-selected files from disk — handy after
+    # editing prompt.txt / words.txt in a text editor, no need to re-select
+    # them via the picker.
+    reload_item = Item("Reload now", app_state.cb_reload_prompt_files,
+                       help="Re-read the selected files from disk")
+    return Menu([prompt_item, words_item, reload_item], name="Prompt")
+
+
 def _toggle_options_menu(app_state) -> Menu:
     is_terminal = _is_terminal_frontend(app_state)
 
@@ -1336,6 +1448,17 @@ def _toggle_options_menu(app_state) -> Menu:
     output_item = Item("output", _output_mode_submenu(app_state), help="Output")
     output_item.label_fn = lambda: f"Output: {_output_mode_label(app_state.o)}"
 
+    # Prompt sub-menu: file pickers for the prompt file + words file so the
+    # user can see which file is biasing the model and swap it without
+    # restarting. Visible only for backends that actually consume the
+    # prompt; vosk silently ignores it and openai-realtime rejects it
+    # server-side.
+    prompt_item = Item("prompt", _prompt_files_submenu(app_state), help="Prompt")
+    prompt_item.label_fn = lambda: (
+        f"Prompt: "
+        f"{_prompt_status_label(app_state.o)}"
+    )
+
     # Keyboard sub-menu: only meaningful when Output=Keyboard. Holds the
     # Input mode (keystroke vs paste) and the Backend typer radio.
     keyboard_item = Item("kbd", _keyboard_advanced_submenu(app_state),
@@ -1351,6 +1474,7 @@ def _toggle_options_menu(app_state) -> Menu:
         stream_advanced_item,
         clip_timeout_item,
         output_item,
+        prompt_item,
         keyboard_item,
         Item("x", app_state.cb_toggle_frontend, help="Toggle tray app mode",
              checked=lambda item: getattr(app_state.o, "frontend", None) == "tray",