stenograf 0.2.0__tar.gz → 0.2.2__tar.gz

{stenograf-0.2.0 → stenograf-0.2.2}/.claude/skills/verify/SKILL.md

@@ -8,6 +8,34 @@ description: How to run and observe stenograf end-to-end (TUI, live pass, finali
 The product surface is the `steno` CLI / Textual TUI. Everything is drivable
 headlessly via `--replay` — no mic, no system tap, no native helper needed.
 
+## Headless TUI smoke — real stack, no TTY, any platform
+
+CLI-mode green does NOT imply the launcher works: the CLI does its loader
+work *before* Textual owns stdio, the launcher does it *under* a live app —
+a code path no `--plain`/`--replay` run touches (this is how the win32
+EBADF meeting-start crash shipped despite a fully validated CLI,
+2026-07-12). Textual's `run_test` pilot drives the real launcher without a
+terminal, so "the TUI needs eyes" is true only for rendering — plumbing is
+verifiable headlessly:
+
+```python
+app = StenografApp()
+async with app.run_test(size=(100, 40)) as pilot:
+    await pilot.click("#start")          # Home -> setup form
+    await pilot.pause()
+    app.screen._submit()                 # form defaults -> meeting screen
+    # ... pilot.pause() until MeetingScreen._phase is CAPTURING (model load
+    # takes seconds), press "q" to stop+finalize, then inspect
+    # app._notifications — a "Meeting failed" toast is the failure signal.
+```
+
+Patch `stenograf.output.default_output_home` to a scratch dir first. On a
+machine with audio devices this runs the REAL provider + models end to end.
+When a test must fake (CI has no audio), fake at the hardware boundary
+(`capture.windows.default_devices`, the provider class), never at
+`loaders.make_provider`/`load_backends` — faking the orchestration seam is
+exactly what hid the EBADF crash from the UI suite.
+
 ## Build & launch
 
 No build step; run from the repo with uv:

{stenograf-0.2.0 → stenograf-0.2.2}/.github/workflows/release.yml

@@ -1,9 +1,9 @@
 name: release
 
-# Tag v<version> → build the wheel matrix, smoke-test clean installs on both
-# OSes, publish to PyPI (Trusted Publishing/OIDC — no token secrets) and attach
-# the artifacts to a GitHub release. workflow_dispatch runs everything except
-# the publish step, as a dry run.
+# Tag v<version> → build the wheel matrix, smoke-test a clean install on every
+# supported OS, publish to PyPI (Trusted Publishing/OIDC — no token secrets) and
+# attach the artifacts to a GitHub release. workflow_dispatch runs everything
+# except the publish step, as a dry run.
 
 on:
   push:
@@ -110,8 +110,60 @@ jobs:
       # installs, the CLI runs, and the headless model download works.
       - run: steno setup --models-only
 
+  smoke-windows:
+    # Windows ships the same pure wheel Linux does (no native helpers), so there
+    # is nothing extra to *build* — but nothing verified a clean Windows install
+    # before publish either, which is how 0.2.1 shipped a launcher that died on
+    # every meeting start. The launcher/TUI itself is covered by the headless
+    # real-stack smoke in ci.yml's windows unit job; this leg is the *installed
+    # artifact* check: the wheel installs, the CLI renders through a redirected
+    # stdout, and the pipeline runs end to end from a file.
+    needs: build-linux
+    runs-on: windows-latest
+    timeout-minutes: 45
+    defaults:
+      run:
+        shell: bash # wheel globs + $HOME; the runner ships Git bash
+    steps:
+      - uses: astral-sh/setup-uv@v8.3.2
+      - uses: actions/download-artifact@v8
+        with:
+          name: dist-linux
+          path: dist
+      # uv installs tool executables to ~/.local/bin on Windows too.
+      - run: echo "$HOME/.local/bin" >> "$GITHUB_PATH"
+      - run: uv tool install -p 3.13 ./dist/stenograf-*py3-none-any.whl
+      - run: steno --version
+      # ffmpeg is the bundled imageio-ffmpeg binary here — nothing to install.
+      - run: steno setup --models-only
+      - name: The report renders through a redirected stdout
+        # doctor *exits 1* on a runner by design: it has no audio endpoint, so
+        # the (non-optional) capture check fails. What this asserts is that the
+        # report renders at all — piped Windows stdout uses the legacy code page,
+        # and click.echo once crashed outright on the ✓/✗ glyphs (fixed by
+        # reconfiguring the streams with errors="replace"; this pins it down).
+        run: |
+          steno doctor > doctor.txt 2>&1 || true
+          cat doctor.txt
+          grep -q "ASR backend" doctor.txt
+          grep -q "ffmpeg" doctor.txt
+      - name: Pipeline smoke on a synthetic WAV
+        # Live WASAPI capture needs hardware no runner has; --replay drives the
+        # same pipeline from a file.
+        run: |
+          uv run --no-project --python 3.13 python - <<'EOF'
+          import math, struct, wave
+          with wave.open("smoke.wav", "wb") as w:
+              w.setnchannels(1); w.setsampwidth(2); w.setframerate(16000)
+              w.writeframes(b"".join(
+                  struct.pack("<h", int(8000 * math.sin(2 * math.pi * 440 * i / 16000)))
+                  for i in range(16000 * 3)))
+          EOF
+          steno start --replay smoke.wav --local 1 --remote 0 --lang en --out smoke-out
+          test -f smoke-out/transcript.json
+
   publish:
-    needs: [smoke-macos, smoke-linux]
+    needs: [smoke-macos, smoke-linux, smoke-windows]
     if: github.ref_type == 'tag'
     runs-on: ubuntu-latest
     timeout-minutes: 15

{stenograf-0.2.0 → stenograf-0.2.2}/CLAUDE.md

@@ -38,8 +38,13 @@ real PipeWire); GitHub Actions Ubuntu is the stable-distro CI reference.
   import-broken, and Voxtral needs 4.x); generation must stay bound to the
   thread that imported `mlx_lm` (guarded in code). **Linux CPU fallback =
   llama-cpp-python — its wheels are OFF-PyPI** (extra index URL required);
-  Ollama stays the default when a GPU box is available. Windows (future) =
-  onnxruntime-genai-directml + Phi-4-mini.
+  Ollama stays the default when a GPU box is available. **Windows (decided
+  2026-07-12): Ollama-default, no in-process backend unless Ollama proves
+  insufficient — then llama-cpp-python CPU GGUF (Phi-4-mini), same off-PyPI
+  wheel friction as Linux.** onnxruntime-genai-directml was rejected
+  (DX12-GPU-only on the EOL DirectML EP; coexistence with our
+  onnxruntime-directml would actually have been fine — it depends on the
+  same flavor). Details: PLAN.md §5 Phase 6 Track D.
 - **MLX on background threads**: materialize weights on the load thread or
   inference dies with "no Stream(gpu, 0)"; verify MLX-threading changes
   against the real backend, not mocks.

{stenograf-0.2.0 → stenograf-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stenograf
-Version: 0.2.0
+Version: 0.2.2
 Summary: Accuracy-first local meeting transcription for German and English. Audio stays in RAM; only text is written.
 Project-URL: Repository, https://github.com/daniel-om-weber/stenograf
 Project-URL: Issues, https://github.com/daniel-om-weber/stenograf/issues
@@ -11,6 +11,7 @@ Keywords: diarization,local,meetings,privacy,speech-to-text,transcription
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
@@ -103,6 +104,19 @@ installs the current main branch; building from the repository compiles the
 capture helper on your machine, which needs the Xcode command-line tools
 (`xcode-select --install`).
 
+### Windows
+
+Same one command, run from PowerShell — installs uv if missing, then stenograf,
+then the launcher:
+
+```powershell
+powershell -ExecutionPolicy Bypass -c "irm https://raw.githubusercontent.com/daniel-om-weber/stenograf/main/install.ps1 | iex"
+```
+
+Windows never prompts for the microphone, so capture stays silent until you flip
+the toggle under Settings > Privacy & security > Microphone. Windows Terminal is
+recommended for the live-caption TUI.
+
 ### From a checkout
 
 ```sh
@@ -236,11 +250,14 @@ dir = "~/Documents/Obsidian/Meetings"   # optional: also write one combined
 With `[notes.export]` set, every summarized meeting also produces a single
 self-contained markdown note (frontmatter, summary, action items, collapsible
 transcript) — drop the dir inside an Obsidian vault and meetings file
-themselves. Two more levers in `[notes]`: `instructions = "~/style.md"`
-appends your house style to the built-in prompt, and `thinking = false` skips
-the mlx model's reasoning pass (faster, less careful). Notes never run unless
-you ask (`--notes` or `steno notes`), and a notes failure never touches the
-transcript.
+themselves. Three more levers in `[notes]`: `instructions = "~/style.md"`
+appends your house style to the built-in prompt, `thinking = false` skips the
+mlx model's reasoning pass (faster, less careful), and `auto = true` makes
+notes the default for every meeting — `steno start` summarizes without
+`--notes`, and the launcher's "Generate notes after the meeting" switch starts
+on. Out of the box notes never run unless you ask (`--notes`, the launcher
+switch, or `steno notes` afterwards); with `auto = true`, `--no-notes` still
+skips them for one run. A notes failure never touches the transcript.
 
 ## Naming speakers across meetings
 

{stenograf-0.2.0 → stenograf-0.2.2}/PLAN.md

@@ -938,15 +938,211 @@ SIGINT-based macOS-provider teardown now skipped on win32) and **one real produc
 bug**: on Windows, piped/redirected output uses the legacy code page and `click.echo`
 crashed on ✓/← — the CLI entry now reconfigures stdout/stderr with
 `errors="replace"` on win32. `livekit` win_amd64 wheels confirmed (1.1.13 installs;
-AEC behaviour on Windows hardware still to be exercised). Still open in Phase 6: real
-`steno transcribe`/`steno start` with downloaded models, the `windows-latest` CI job +
-Windows classifier, setup messaging, the DirectML notes backend, the stenodiar port,
-and the Windows leg of the Phase-7 install story (deferred there 2026-07-12): an
-`install.ps1` one-liner (uv ships `irm https://astral.sh/uv/install.ps1 | iex`) plus
-the win32 branch of `stenograf/shortcut.py` — a Desktop `.lnk`, or simpler a `.cmd`
-wrapper, since `steno.exe` is a console app and any shortcut to it opens its own
-console window; `install_shortcut()` currently returns `None` on win32 so `steno
-setup` stays silent there.
+AEC behaviour on Windows hardware still to be exercised).
+
+**Closed since the capture track (recorded 2026-07-12):**
+
+- **ASR GPU acceleration (2026-07-11, commit 293545f):** `[asr] provider` setting /
+  `STENOGRAF_ASR_PROVIDER` (`cpu` default | `dml` | `cuda` | `auto`) with an
+  availability pre-check + canary decode + CPU fallback (`asr/parakeet_onnx.py`,
+  `asr/providers.py`). pyproject ships `onnxruntime-directml` on win32 via marker —
+  every ORT flavor installs the same package directory and silently clobbers the
+  others (verified), so extras can't express the swap. Measured on an RTX 4080 SUPER:
+  DML transcripts byte-identical to CPU, 107× vs 16× realtime. Gotcha for future EPs:
+  ORT does **not** raise on an unlisted provider — it warns and runs on the rest, so
+  always pre-check `get_available_providers()`.
+- The `windows-latest` CI job (unit suite; pyright stays macOS-only for the
+  marker-dep imports) and a `cargo check` leg for stenodiar's `cuda` feature.
+- The `Operating System :: Microsoft :: Windows` classifier (2026-07-12).
+- `steno setup` messaging (2026-07-12): a win32 branch reads `mic_access_blocked()`
+  up front and fails before the model download, mirroring the macOS grant step —
+  and, when allowed, tells the user Windows will never show a prompt.
+- The `shortcut.py` win32 branch (2026-07-12): a Desktop `Stenograf.cmd` — the
+  "simpler" option from the two scoped here, since `steno` is a console app (a
+  `.lnk` would open a console window anyway) and a text wrapper regenerates without
+  COM. The Desktop is resolved through the shell's `User Shell Folders` registry key
+  (OneDrive folder backup redirects it on a large share of Windows 11 machines;
+  `~/Desktop` would be an invisible decoy there), and the wrapper ends in
+  `if errorlevel 1 pause` so a startup crash stays readable instead of vanishing
+  with the console window.
+
+What remains for **full Windows support** is planned in the next subsection.
+
+### Phase 6 — remaining-work plan (planned 2026-07-12)
+
+**Definition of done:** a fresh Windows 11 machine goes one-liner install →
+`steno setup` → live meeting → diarized transcript + notes in
+`Documents\Meetings`, at parity with Linux, with no manual step beyond the
+mic privacy toggle. Four tracks: **A gates the "supported" claim**; B, C, D
+are independent of each other and of A (but A first — everything else builds
+on a verified core).
+
+**Track A — real-hardware validation (the gate).**
+
+State (desktop, 2026-07-12, Ryzen 9 5900X + RTX 4080 SUPER, Sharkoon Gaming
+DAC Pro S, output = headphones): **the automatable core is verified on the
+desktop; items 1–2 pass, item 3's live path smoke-passes, the ≥30-min/AEC gate
+and the notebook re-run stay open.** Measured on a 56.4 s piper-TTS clip
+(en_US-lessac-medium, the ci.yml sentence with "provisioning"/"October"):
+
+- **Item 1 — transcribe, PASS.** Warm CPU run (weights pre-cached): 8.3 s wall
+  → 6.8× RT end-to-end, but that is model-load-bound on a short clip; the
+  tool's own transcribe-only figure is **14.9× RT** (3.8 s). Sentinels present;
+  "backend"→"backhand" is the known TTS mishearing. `provider = "dml"`
+  (`STENOGRAF_ASR_PROVIDER=dml`) engaged ("asr: accelerated (DirectML)"), no
+  silent CPU fallback: transcript **byte-identical** to CPU (SHA-256 match on
+  transcript.{txt,md,json}), transcribe-only **35.3× RT** (1.6 s) →
+  **2.37× DML speedup** over CPU compute. Output files are clean UTF-8/ASCII,
+  no code-page mangling (the only mojibake seen — a UTF-16 BOM and a `✓`→`?`
+  glyph — is PowerShell's `*>` redirect + console codepage, not the tool).
+- **Item 2 — `steno start --replay`, PASS.** End-to-end via the `verify` flow
+  (mic replay, in-room): live caption emitted, finalize + transcript written,
+  both sentinels present.
+- **Item 3 (desktop smoke) — live WASAPI capture, PASS.** `--local 0 --remote
+  1` captured the Sharkoon **loopback** render stream (default output =
+  headphones, yet loopback still taps render); both sentinels present on a
+  single clean playback. Back-to-back double playback reorders/garbles the
+  ASR (a playback-overlap harness artifact, not a capture bug). Bonus
+  `--local 1 --remote 1` mic+system smoke: **both channels captured**, **AEC
+  armed** ("echo cancellation: on (mic cancelled against system audio)"),
+  stderr clean — **no far-end-missing / armed-backstop warnings**, and the
+  **silent-mic watchdog stayed quiet** (no false-positive). With headphones
+  output the mic heard nothing intelligible and all content arrived via the
+  system channel — expected on this box.
+- **Launcher meeting start was broken on Windows — found by the by-eye check,
+  fixed 2026-07-12:** every meeting died instantly with `[Errno 9] Bad file
+  descriptor` — click.echo under Textual's redirected stdio trips click's
+  Windows-only console probe (`msvcrt.get_osfhandle` on the proxy fd → EBADF)
+  at `make_provider`'s capture-device line. The loader seams now take
+  `announce=` (None = click CLI behavior; the TUIs pass their status sinks),
+  which also surfaces real loader progress in the meeting header. Verified by
+  driving the real launcher headlessly: capture → finalize → saved.
+- **Still open (needs the notebook, real speakers):** the ≥30-min
+  **speakers-not-headphones** AEC meeting (far-end re-anchor / echo-leak across
+  long system-silence gaps — item 3's AEC bullet and item 4's long run); the
+  **TUI-by-eye** check in Windows Terminal (live captions, resize, clean Ctrl-C);
+  and re-running items 1–3 on the **notebook's GPU** (different DML vendor tier).
+
+1. Real `steno transcribe` on a meeting-length recording with downloaded
+   models (fp32 ONNX, CPU): correctness + RTF on the notebook. Repeat with
+   `[asr] provider = "dml"` — byte-identity + speedup were verified on the
+   desktop's RTX 4080; re-confirm on the notebook's GPU (different vendor
+   tier is exactly what DML is for).
+2. `steno start --replay` end to end (the `verify` skill flow) on Windows.
+3. A real live meeting on the notebook — **speakers, not headphones**, both
+   channels captured. Checks, in order of risk:
+   - **AEC**: livekit's APM is installed but unexercised on Windows, and
+     laptop mics genuinely hear the speakers. Watch `far_end_missing_ticks`
+     and the armed-backstop warning across WASAPI loopback silence gaps; a
+     0.5 s re-anchor moves the far-end alignment, so confirm the AEC
+     re-converges after long system silence instead of leaking echo.
+   - TUI in Windows Terminal: live captions, resize, clean Ctrl-C shutdown.
+   - The silent-mic watchdog must not false-positive on real hardware.
+   - Finalize with diarization (sherpa known-count path) + notes via Ollama;
+     transcript + notes land in `Documents\Meetings`, no code-page mangling.
+4. Run the checklist **twice**: one short smoke, one ≥30-min meeting with
+   long system-silence stretches — the gap/zero-fill/re-anchor path only
+   shows up in the long one. Record results here; anything broken becomes a
+   task in this section.
+
+**Track B — stenodiar (estimated speaker counts).**
+
+State: **the patched CPU build is measured on Windows (2026-07-12, desktop
+Ryzen 9 5900X 12C/24T).** Prior state (2026-07-11): CPU 3.0× RT but still
+~1.1 cores, which **predated** the two vendored speakrs patches; CUDA 60× RT
+works via pip `nvidia-*-cu12` DLLs on PATH + `onnxruntime_providers_cuda.dll`
+beside the exe; rustup + VS 2022 Build Tools are installed there. The CPU exe
+is self-contained (~40 MB, ORT statically linked).
+
+1. **Done.** Rebuilt from the patched vendor tree (`native/stenodiar/vendor/`,
+   threads + model-list patches; CPU default features, `cargo build --release
+   --locked`) and re-measured on a 300 s mono-16 kHz cut of AMI ES2004a
+   Mix-Headset: **34.6–35.1 s wall/segment → 8.6× RT, ~6.0 cores** (208 s
+   CPU-time / 34.6 s wall), 3 speakers / 46 turns, byte-identical across the
+   two timed back-to-back runs. Right at the Linux **8.2×** figure (the
+   intra-op-thread patch is the same lever; embedding threads still cap at 8),
+   and a ~2.9× jump over the pre-patch Windows 3.0× — well past the ≥4× bar.
+2. Shipping decision (recommendation, not yet implemented): **GitHub Releases
+   attachment + a documented drop location**, not wheel bundling — a 40 MB
+   binary for an optional, sherpa-fallback feature does not belong in every
+   platform wheel, and `hatch_build.py` already keeps stenodiar off non-mac
+   wheels. `find_stenodiar` now handles the `.exe` suffix on win32 (via
+   `_HELPER_FILENAME`) and, as a dev/drop fallback, also checks
+   `native/stenodiar/target/release/`; the packaged-bin lookup
+   (`stenograf/bin/stenodiar.exe`) and `STENOGRAF_DIAR_HELPER` override are the
+   two Release-install landing spots.
+3. **Done.** `build.ps1` twin of `build.sh` added (CPU/ORT default, `--locked`,
+   copies `stenodiar.exe` next to the script; CUDA stays a manual `--features
+   cuda`); `native/README.md` and the `find_stenodiar` not-found message point
+   Windows at it.
+
+Exit: **met** — `steno doctor` finds the helper on Windows (the target/release
+fallback discovers a plain `cargo build`), and estimated-count diarization runs
+at 8.6× RT (≥4× bar cleared).
+
+**Track C — install story (the Phase-7 Windows leg).**
+
+1. `install.ps1` mirroring `install.sh`: install uv via the astral installer
+   (`irm https://astral.sh/uv/install.ps1 | iex` — **not** winget, whose uv
+   lands off-PATH), then `uv tool install --upgrade stenograf` (the
+   `<3.14` python cap already steers uv to 3.12/3.13), then `steno setup`.
+   Documented invocation is the piped one-liner — a downloaded, double-clicked
+   `.ps1` hits execution policy.
+2. CI parity with `install.sh`'s `sh -n` test: syntax-check via
+   `[ScriptBlock]::Create((Get-Content -Raw install.ps1))` (runs on the
+   windows-latest job, skipped elsewhere) + the same content asserts
+   (`tool install --upgrade stenograf`, ends in `setup`).
+3. README: a Windows install section — the one-liner, the privacy-toggle
+   note, Windows Terminal recommended.
+4. **Done (2026-07-13).** `release.yml` gained a `smoke-windows` leg and
+   `publish` now waits on it: a clean `uv tool install` of the pure wheel on
+   `windows-latest`, then `steno --version`, `setup --models-only`, a doctor
+   render, and a `--replay` pipeline run asserting `transcript.json`. Windows
+   builds nothing of its own (it ships the same pure wheel as Linux), so the
+   gap was never in *building* — it was that **no Windows install was exercised
+   before PyPI**, which is how 0.2.1 published a launcher that died on every
+   meeting start. Two notes for whoever touches this job: `steno doctor` exits
+   **1** on a runner by design (no audio endpoint → the non-optional capture
+   check fails), so the step tolerates that and asserts only that the report
+   *renders* — piped Windows stdout is legacy-code-page, the bug class that once
+   crashed `click.echo` on the ✓ glyph; and the replay clip is a 440 Hz tone, so
+   it finalizes to **0 entries** — the assertion is that the transcript is
+   written at all, not its content. The launcher/TUI stays covered by ci.yml's
+   windows unit job (headless real-stack smoke), not here.
+
+Exit: on a fresh VM (or fresh user account), the one-liner reaches
+"setup complete" and drops the Desktop launcher.
+
+**Track D — on-device notes backend — DECIDED 2026-07-12 (no code; the
+build gate stays "Ollama proves insufficient").**
+
+Re-researched against the DirectML EOL. The clobber fear was unfounded:
+`onnxruntime-genai-directml` (0.14.1, 2026-06-02, still released) does not
+bundle its own ORT — it pip-depends on **`onnxruntime-directml`**, the very
+flavor the ASR already ships, so it coexists cleanly (the CPU flavor
+`onnxruntime-genai` depends on base `onnxruntime` and IS disqualified by the
+one-flavor rule). **Rejected anyway**: DX12-GPU-only with no CPU fallback,
+built entirely on the EOL DirectML EP — the wrong bet when Microsoft's
+investment moved to Windows ML. The successors aren't pip-reachable today:
+Windows ML genai is NuGet/C#-only Preview (no Python wheel); Foundry Local
+(GA 2026-06) requires a DX12 GPU and pulls `onnxruntime-core`/-genai (real
+conflict risk), an Ollama-class service rather than an in-process analog.
+
+**Decision: stay Ollama-default on Windows. If an in-process pip backend is
+ever needed, use llama-cpp-python (CPU GGUF)** — the same fallback CLAUDE.md
+already records for Linux CPU, same off-PyPI extra-index friction, zero ORT
+entanglement. Caveat: the official wheel index's Windows cp313 CPU wheel is
+stale (0.3.2) — build from source (VS Build Tools installed on the desktop)
+or a third-party index. Model: Phi-4-mini stays fine as Q4 GGUF (Qwen2.5-3B /
+Llama-3.2-3B as smaller CPU-friendly alternatives). Revisit the ONNX route
+only when Windows ML genai ships an out-of-preview Python wheel.
+
+**Watch-items (not tasks):** `onnxruntime-directml` wheels ceasing to track
+ORT patch releases (swap the marker back to plain `onnxruntime`; the provider
+setting degrades to CPU with a warning — designed in); mid-meeting default-
+device switches stay unfollowed on Windows (WASAPI has no `@DEFAULT_MONITOR@`
+alias — accepted asymmetry vs Linux); Windows ML as the eventual multi-vendor
+EP path for ASR, once dynamic-shape conformer models are validated there.
 
 ---
 

{stenograf-0.2.0 → stenograf-0.2.2}/README.md

@@ -68,6 +68,19 @@ installs the current main branch; building from the repository compiles the
 capture helper on your machine, which needs the Xcode command-line tools
 (`xcode-select --install`).
 
+### Windows
+
+Same one command, run from PowerShell — installs uv if missing, then stenograf,
+then the launcher:
+
+```powershell
+powershell -ExecutionPolicy Bypass -c "irm https://raw.githubusercontent.com/daniel-om-weber/stenograf/main/install.ps1 | iex"
+```
+
+Windows never prompts for the microphone, so capture stays silent until you flip
+the toggle under Settings > Privacy & security > Microphone. Windows Terminal is
+recommended for the live-caption TUI.
+
 ### From a checkout
 
 ```sh
@@ -201,11 +214,14 @@ dir = "~/Documents/Obsidian/Meetings"   # optional: also write one combined
 With `[notes.export]` set, every summarized meeting also produces a single
 self-contained markdown note (frontmatter, summary, action items, collapsible
 transcript) — drop the dir inside an Obsidian vault and meetings file
-themselves. Two more levers in `[notes]`: `instructions = "~/style.md"`
-appends your house style to the built-in prompt, and `thinking = false` skips
-the mlx model's reasoning pass (faster, less careful). Notes never run unless
-you ask (`--notes` or `steno notes`), and a notes failure never touches the
-transcript.
+themselves. Three more levers in `[notes]`: `instructions = "~/style.md"`
+appends your house style to the built-in prompt, `thinking = false` skips the
+mlx model's reasoning pass (faster, less careful), and `auto = true` makes
+notes the default for every meeting — `steno start` summarizes without
+`--notes`, and the launcher's "Generate notes after the meeting" switch starts
+on. Out of the box notes never run unless you ask (`--notes`, the launcher
+switch, or `steno notes` afterwards); with `auto = true`, `--no-notes` still
+skips them for one run. A notes failure never touches the transcript.
 
 ## Naming speakers across meetings
 

stenograf-0.2.2/install.ps1

@@ -0,0 +1,28 @@
+# stenograf installer — one command sets up everything:
+#
+#   powershell -ExecutionPolicy Bypass -c "irm https://raw.githubusercontent.com/daniel-om-weber/stenograf/main/install.ps1 | iex"
+#
+# Installs uv if missing, installs stenograf as a uv tool, then runs
+# `steno setup` (permission prompts, desktop launcher, model downloads).
+# Safe to re-run: every step is idempotent and re-running upgrades stenograf.
+$ErrorActionPreference = "Stop"
+
+$uvHome = Join-Path $env:USERPROFILE ".local\bin\uv.exe"
+if (-not (Get-Command uv -ErrorAction SilentlyContinue) -and -not (Test-Path $uvHome)) {
+    Write-Host "installing uv (https://docs.astral.sh/uv/) ..."
+    powershell -ExecutionPolicy Bypass -c "irm https://astral.sh/uv/install.ps1 | iex"
+}
+$uv = (Get-Command uv -ErrorAction SilentlyContinue).Source
+if (-not $uv) { $uv = $uvHome }
+
+& $uv tool install --upgrade stenograf
+
+# A freshly created uv bin dir isn't on this shell's PATH yet — ask uv where it is.
+$steno = (Get-Command steno -ErrorAction SilentlyContinue).Source
+if (-not $steno) { $steno = Join-Path (& $uv tool dir --bin) "steno.exe" }
+
+& $steno setup
+
+Write-Host ""
+Write-Host "stenograf is installed. Start it from the desktop launcher above,"
+Write-Host "or run: steno"

{stenograf-0.2.0 → stenograf-0.2.2}/native/README.md

@@ -11,7 +11,9 @@ VBx can; stenograf routes estimate-mode diarization through it and known
 counts through sherpa (see `stenograf/diarization/speakrs.py`). Raw mono
 16 kHz s16le PCM goes in on stdin, JSON speaker turns come out on stdout.
 Build with `stenodiar/build.sh` (needs a Rust toolchain: `brew install rust`);
-no signing needed — it touches no TCC-guarded resource. The first run per
+on Windows use `stenodiar/build.ps1` (rustup + VS Build Tools; CPU/ORT default,
+CUDA a manual `--features cuda` opt-in); no signing needed — it touches no
+TCC-guarded resource. The first run per
 machine downloads models and compiles them for CoreML (minutes; `--warmup`
 does it eagerly). Without the binary, stenograf silently falls back to
 sherpa-only diarization.

stenograf-0.2.2/native/stenodiar/build.ps1

@@ -0,0 +1,14 @@
+# Build the stenodiar diarization helper and drop the binary next to this
+# script, where stenograf's dev fallback looks for it (twin of build.sh for
+# Windows). Needs a Rust toolchain (rustup) and the VS Build Tools linker. No
+# signing: stenodiar touches no guarded resource, so an unsigned binary is fine.
+$ErrorActionPreference = "Stop"
+Set-Location $PSScriptRoot
+
+# Default features = ORT CPU (matches the shipped Linux/Windows path); CUDA is a
+# manual opt-in — cargo build --release --features cuda (nvidia-*-cu12 DLLs +
+# onnxruntime_providers_cuda.dll on PATH). CoreML is macOS-only (build.sh).
+cargo build --release --locked
+Copy-Item target\release\stenodiar.exe stenodiar.exe -Force
+
+Write-Output "built: $(Join-Path (Get-Location) 'stenodiar.exe')"

{stenograf-0.2.0 → stenograf-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stenograf"
-version = "0.2.0"
+version = "0.2.2"
 description = "Accuracy-first local meeting transcription for German and English. Audio stays in RAM; only text is written."
 readme = "README.md"
 license = "MIT"
@@ -15,6 +15,7 @@ classifiers = [
     "Development Status :: 3 - Alpha",
     "Environment :: Console",
     "Operating System :: MacOS",
+    "Operating System :: Microsoft :: Windows",
     "Operating System :: POSIX :: Linux",
     "Programming Language :: Python :: 3.12",
     "Topic :: Multimedia :: Sound/Audio :: Speech",

{stenograf-0.2.0 → stenograf-0.2.2}/src/stenograf/capture/streaming.py

@@ -193,9 +193,14 @@ class QueueStreamingProvider[TransportT](CaptureProvider):
         try:
             self._pump(channel, transport)
         finally:
-            if not self._stop_event.is_set():
-                self.stop()
-            self._queue.put(channel)
+            try:
+                if not self._stop_event.is_set():
+                    self.stop()
+            finally:
+                # The sentinel is the only way frames() learns this channel is
+                # done, so it must survive a teardown that raises — otherwise
+                # frames() waits on an empty queue with every pump already dead.
+                self._queue.put(channel)
 
     def _emit(self, channel: Channel, samples: np.ndarray) -> None:
         """Stamp a frame onto the session clock and hand it to ``frames()``."""

{stenograf-0.2.0 → stenograf-0.2.2}/src/stenograf/capture/windows.py

@@ -245,10 +245,14 @@ class WindowsCaptureProvider(QueueStreamingProvider[None]):
         # Pumps notice the stop event within one frame read (~frame_ms +
         # WASAPI's silence threshold) and release their devices on the way
         # out. Skip the current thread: stop() also runs *from* a pump on an
-        # unexpected stream death.
+        # unexpected stream death. Skip threads that have not started either:
+        # a pump dying this early can land inside start()'s register-then-start
+        # window, and joining an unstarted thread raises. Nothing is lost by
+        # skipping — the stop event is already set, so a pump that starts after
+        # this exits on its first loop check.
         current = threading.current_thread()
         for thread in self._threads.values():
-            if thread is not current:
+            if thread is not current and thread.ident is not None:
                 thread.join(timeout=5)
 
 

{stenograf-0.2.0 → stenograf-0.2.2}/src/stenograf/cli/doctor_cmd.py

@@ -35,18 +35,22 @@ def doctor() -> None:
     help="Skip the permission prompts and only download the models (headless machines, CI).",
 )
 def setup(models_only: bool) -> None:
-    """One-time setup: permission prompts, desktop launcher, model downloads.
-
-    Launches the capture helper so macOS shows both permission prompts (mic +
-    system audio) now instead of at the start of your first meeting — nothing
-    is recorded — then installs a double-clickable launcher and downloads
-    every model the first meeting would otherwise stop to fetch. macOS scopes
-    the grant to the app the helper was launched from, so re-run this from
-    each terminal app (or IDE) you will run meetings from; the models are
-    cached machine-wide.
+    """One-time setup: capture permissions, desktop launcher, model downloads.
+
+    macOS: launches the capture helper so both permission prompts (mic +
+    system audio) appear now instead of at the start of your first meeting —
+    nothing is recorded; the grant is scoped to the app the helper was
+    launched from, so re-run this from each terminal app (or IDE) you will
+    run meetings from. Windows: no prompt exists, so the microphone privacy
+    toggle is checked and named instead. Then installs a double-clickable
+    launcher and downloads every model the first meeting would otherwise
+    stop to fetch; the models are cached machine-wide.
     """
-    if not models_only and sys.platform == "darwin":
-        _grant_capture_permissions()  # only macOS gates capture behind TCC prompts
+    if not models_only:
+        if sys.platform == "darwin":
+            _grant_capture_permissions()  # only macOS gates capture behind TCC prompts
+        elif sys.platform == "win32":
+            _check_windows_mic_access()  # no prompt exists — read the privacy toggle now
 
     # The launcher lands before the model download: the download can fail (and
     # models fetch on first use anyway), the shortcut shouldn't be lost to that.
@@ -56,10 +60,10 @@ def setup(models_only: bool) -> None:
 
         if (shortcut := install_shortcut()) is not None:
             click.echo(click.style("✓", fg="green") + f" launcher installed: {shortcut}")
-            if sys.platform == "darwin":
-                click.echo("  Double-click it to start stenograf — no terminal needed.")
-            else:
+            if sys.platform.startswith("linux"):  # menu entry; macOS/Windows land on the Desktop
                 click.echo('  Look for "Stenograf" in your application menu.')
+            else:
+                click.echo("  Double-click it to start stenograf — no terminal needed.")
 
     # Permissions first (they need the user at the keyboard), then the long
     # unattended part: everything a first meeting would otherwise stop to fetch.
@@ -73,6 +77,27 @@ def setup(models_only: bool) -> None:
     click.echo(click.style("✓", fg="green") + " setup complete.")
 
 
+def _check_windows_mic_access() -> None:
+    """Fail setup loud when the Windows mic privacy toggle denies capture.
+
+    Windows never prompts desktop apps for the microphone (no TCC
+    equivalent) — a denied toggle just makes the stream deliver zeros — so
+    setup reads the consent store up front, mirroring the macOS grant step's
+    fail-before-models behavior, and tells the user no prompt is coming.
+    """
+    from stenograf.capture.windows import mic_access_blocked
+
+    if (blocked := mic_access_blocked()) is not None:
+        raise click.ClickException(f"{blocked}, then re-run `steno setup`")
+    click.echo(
+        click.style("✓", fg="green") + " microphone access is allowed in Windows privacy settings."
+    )
+    click.echo(
+        "  Windows shows no permission prompt — if the mic ever records only silence, "
+        "check Settings > Privacy & security > Microphone."
+    )
+
+
 def _grant_capture_permissions() -> None:
     if sys.platform != "darwin":
         raise click.ClickException(