diff --git a/PRIVACY.md b/PRIVACY.md
index 3bf8b1e5..32b5e3df 100644
--- a/PRIVACY.md
+++ b/PRIVACY.md
@@ -71,6 +71,23 @@ into the Claude session where you asked for the report, which, like anything in
 session, goes to Anthropic. It sends nothing anywhere else, and writes only its own cursor
 (`catch-up.json`) beside the list. It runs only when you ask for it.
 
+## Dictating from any app
+
+With dictation on and Settings > Dictation > "Dictate from any app" on (the default when dictation
+is on), a small helper watches the keyboard so the dictation key works with another app in front.
+It reads only the dictation key's own keys, notes only THAT another key was pressed while they are
+held (never which), and, only while the widget's list of sessions is open, the digits 1 to 9 and
+Esc (which it keeps from the app in front). It writes nothing anywhere and sends nothing. What you
+say is handled as all dictation is: transcribed on your PC, then sent to the Claude session you
+pick, or to the orchestrator tab.
+
+With more than one copy of Prism Terminal open (for example a stable copy beside the installed
+app), one copy runs the dictation for all of them. The copies talk over a local named pipe that
+only your Windows account uses: the running copy asks the others for their tab list (the tab's
+name, folder and whether Claude runs there) so the list of sessions shows every copy's, and hands a
+copy the words to type into one of its tabs. Nothing on the pipe leaves your PC, and nothing is
+written to disk.
+
 ## What programs in a tab can do
 
 A program running in a tab (Claude Code's /copy, or anything you reach over ssh) can put text ON
diff --git a/core/dictation-host/parakeetHost.ps1 b/core/dictation-host/parakeetHost.ps1
new file mode 100644
index 00000000..5713a1a6
--- /dev/null
+++ b/core/dictation-host/parakeetHost.ps1
@@ -0,0 +1,129 @@
+# THE RESIDENT PARAKEET HOST (owner, 2026-10-17: "It needs to be ready at all
+# times"; the startup is "the important bit"). parakeet-cli loads the model for
+# every pass: MEASURED on the owner's RTX 5090, 0.72 to 0.86 s a pass whatever
+# the clip's length, nearly all of it start-up. This keeps ONE model loaded in
+# a long-lived Windows PowerShell (the app's helper pattern, no new binary) and
+# calls the engine's own parakeet.dll for each pass: 24 ms (1 s clip) to 170 ms
+# (60 s clip) on the GPU, the text identical to parakeet-cli's, MEASURED.
+# Report: research/prism-terminal/2026-10-17-dictation-performance.md.
+#
+# args:   <engine folder> <model> <gpu 1|0> <threads> [<cache folder>]
+# stdin:  "pass <n>" + LF, then n bytes of a 16 kHz mono PCM16 WAV; "quit" ends it.
+# stdout: "ready" once the model is loaded; per pass "ok <base64 of the UTF-8
+#         text>" or "err <why>". Nothing else is ever written there.
+#
+# The C# is compiled ONCE into <cache folder> (keyed by its own hash) and
+# loaded from there afterwards, so a start pays no compiler.
+param([string]$dir, [string]$model, [int]$gpu = 1, [int]$threads = 4, [string]$cache = '')
+$ErrorActionPreference = 'Stop'
+$src = @'
+using System;
+using System.IO;
+using System.Text;
+using System.Runtime.InteropServices;
+public static class PTParakeetHost {
+  [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)] static extern IntPtr LoadLibraryW(string path);
+  [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)] static extern bool SetDllDirectoryW(string path);
+  [DllImport("ggml.dll", CallingConvention = CallingConvention.Cdecl)] static extern void ggml_backend_load_all();
+  [StructLayout(LayoutKind.Sequential)] public struct CtxParams { [MarshalAs(UnmanagedType.I1)] public bool use_gpu; public int gpu_device; }
+  // parakeet.h's parakeet_full_params, field for field (passed BY VALUE).
+  [StructLayout(LayoutKind.Sequential)] public struct FullParams {
+    public int strategy; public int n_threads; public int offset_ms; public int duration_ms;
+    [MarshalAs(UnmanagedType.I1)] public bool no_context; public int audio_ctx;
+    public IntPtr seg_cb, seg_ud, tok_cb, tok_ud, prog_cb, prog_ud, enc_cb, enc_ud, abort_cb, abort_ud;
+  }
+  [DllImport("parakeet.dll", CallingConvention = CallingConvention.Cdecl)] static extern IntPtr parakeet_init_from_file_with_params([MarshalAs(UnmanagedType.LPStr)] string path, CtxParams p);
+  [DllImport("parakeet.dll", CallingConvention = CallingConvention.Cdecl)] static extern IntPtr parakeet_full_default_params_by_ref(int strategy);
+  [DllImport("parakeet.dll", CallingConvention = CallingConvention.Cdecl)] static extern void parakeet_free_params(IntPtr p);
+  [DllImport("parakeet.dll", CallingConvention = CallingConvention.Cdecl)] static extern int parakeet_full(IntPtr ctx, FullParams p, float[] samples, int n);
+  [DllImport("parakeet.dll", CallingConvention = CallingConvention.Cdecl)] static extern int parakeet_full_n_segments(IntPtr ctx);
+  [DllImport("parakeet.dll", CallingConvention = CallingConvention.Cdecl)] static extern IntPtr parakeet_full_get_segment_text(IntPtr ctx, int i);
+  [UnmanagedFunctionPointer(CallingConvention.Cdecl)] delegate void LogCb(int level, IntPtr text, IntPtr ud);
+  [DllImport("parakeet.dll", CallingConvention = CallingConvention.Cdecl)] static extern void parakeet_log_set(LogCb cb, IntPtr ud);
+  static readonly LogCb quiet = (l, t, u) => { };
+
+  static string Utf8(IntPtr p) {
+    if (p == IntPtr.Zero) return "";
+    int n = 0; while (Marshal.ReadByte(p, n) != 0) n++;
+    var b = new byte[n]; Marshal.Copy(p, b, 0, n); return Encoding.UTF8.GetString(b);
+  }
+  // The app's own WAV (16-bit mono, 16 kHz): the samples of its "data" chunk.
+  static float[] Pcm(byte[] wav) {
+    int i = 12;
+    while (i + 8 <= wav.Length) {
+      int len = BitConverter.ToInt32(wav, i + 4);
+      if (len < 0) break;
+      if (wav[i] == 'd' && wav[i + 1] == 'a' && wav[i + 2] == 't' && wav[i + 3] == 'a') {
+        int n = Math.Min(len, wav.Length - i - 8) / 2;
+        var f = new float[n];
+        for (int k = 0; k < n; k++) f[k] = BitConverter.ToInt16(wav, i + 8 + k * 2) / 32768f;
+        return f;
+      }
+      i += 8 + len + (len & 1);
+    }
+    return new float[0];
+  }
+  static string ReadLine(Stream s) {
+    var b = new StringBuilder();
+    while (true) {
+      int c = s.ReadByte();
+      if (c < 0) return null;
+      if (c == '\n') return b.ToString().TrimEnd('\r');
+      if (b.Length > 64) return "";
+      b.Append((char)c);
+    }
+  }
+  public static void Run(string dir, string model, bool gpu, int threads) {
+    var output = Console.Out;
+    SetDllDirectoryW(dir);
+    LoadLibraryW(Path.Combine(dir, "ggml.dll"));
+    LoadLibraryW(Path.Combine(dir, "parakeet.dll"));
+    parakeet_log_set(quiet, IntPtr.Zero);
+    ggml_backend_load_all();
+    IntPtr ctx = parakeet_init_from_file_with_params(model, new CtxParams { use_gpu = gpu, gpu_device = 0 });
+    if (ctx == IntPtr.Zero) { output.WriteLine("err the model did not load"); output.Flush(); return; }
+    IntPtr dp = parakeet_full_default_params_by_ref(0);
+    var fp = (FullParams)Marshal.PtrToStructure(dp, typeof(FullParams));
+    parakeet_free_params(dp);
+    fp.n_threads = threads;
+    output.WriteLine("ready"); output.Flush();
+    var input = Console.OpenStandardInput();
+    while (true) {
+      string head = ReadLine(input);
+      if (head == null || head == "quit") return;
+      int n;
+      if (!head.StartsWith("pass ") || !int.TryParse(head.Substring(5), out n) || n < 0 || n > 64 * 1024 * 1024) { output.WriteLine("err a bad request"); output.Flush(); return; }
+      var wav = new byte[n]; int got = 0;
+      while (got < n) { int r = input.Read(wav, got, n - got); if (r <= 0) return; got += r; }
+      var pcm = Pcm(wav);
+      if (pcm.Length == 0) { output.WriteLine("ok "); output.Flush(); continue; }
+      int rc = parakeet_full(ctx, fp, pcm, pcm.Length);
+      if (rc != 0) { output.WriteLine("err the pass failed (" + rc + ")"); output.Flush(); continue; }
+      var sb = new StringBuilder();
+      int segs = parakeet_full_n_segments(ctx);
+      for (int s = 0; s < segs; s++) sb.Append(Utf8(parakeet_full_get_segment_text(ctx, s)));
+      output.WriteLine("ok " + Convert.ToBase64String(Encoding.UTF8.GetBytes(sb.ToString().Trim())));
+      output.Flush();
+    }
+  }
+}
+'@
+$loaded = $false
+if ($cache) {
+  try {
+    $sha = [Security.Cryptography.SHA256]::Create()
+    $hash = ([BitConverter]::ToString($sha.ComputeHash([Text.Encoding]::UTF8.GetBytes($src))) -replace '-', '').Substring(0, 16)
+    $dll = Join-Path $cache "pt-parakeet-host-$hash.dll"
+    if (-not (Test-Path -LiteralPath $dll)) {
+      New-Item -ItemType Directory -Force -Path $cache | Out-Null
+      $tmp = Join-Path $cache "pt-parakeet-host-$hash-$PID.dll"
+      Add-Type -TypeDefinition $src -OutputAssembly $tmp -OutputType Library
+      Move-Item -LiteralPath $tmp -Destination $dll -Force -ErrorAction SilentlyContinue
+      if (Test-Path -LiteralPath $tmp) { Remove-Item -LiteralPath $tmp -Force -ErrorAction SilentlyContinue }
+    }
+    Add-Type -LiteralPath $dll
+    $loaded = $true
+  } catch { $loaded = $false }
+}
+if (-not $loaded) { Add-Type -TypeDefinition $src }
+[PTParakeetHost]::Run($dir, $model, $gpu -eq 1, $threads)
diff --git a/core/main/__fixtures__/fakeParakeetHost.mjs b/core/main/__fixtures__/fakeParakeetHost.mjs
new file mode 100644
index 00000000..9b5a9864
--- /dev/null
+++ b/core/main/__fixtures__/fakeParakeetHost.mjs
@@ -0,0 +1,37 @@
+// A stand-in for core/dictation-host/parakeetHost.ps1: the same protocol on
+// stdin and stdout, run by Node. argv: <engine folder> <model> <gpu 1|0>
+// <threads> [<cache>]. FAKE_HOST=never: it never says "ready".
+// Each answer's text is JSON of what it saw: the pass number, the bytes, its pid.
+// The globals by name, as fakeParakeetCli.mjs does (the eslint config).
+import { Buffer } from 'node:buffer'
+import process from 'node:process'
+import { setInterval } from 'node:timers'
+const [dir, model, gpu] = process.argv.slice(2)
+if (process.env.FAKE_HOST === 'never') {
+  setInterval(() => {}, 1000)
+} else {
+  process.stdout.write('ready\n')
+  let buf = Buffer.alloc(0)
+  let need = -1
+  let n = 0
+  process.stdin.on('data', (d) => {
+    buf = Buffer.concat([buf, d])
+    for (;;) {
+      if (need < 0) {
+        const i = buf.indexOf(10)
+        if (i < 0) return
+        const head = buf.subarray(0, i).toString()
+        buf = buf.subarray(i + 1)
+        if (head === 'quit') process.exit(0)
+        need = Number(head.slice(5))
+      }
+      if (buf.length < need) return
+      const bytes = need
+      buf = buf.subarray(need)
+      need = -1
+      n += 1
+      const text = JSON.stringify({ n, bytes, pid: process.pid, gpu: gpu === '1', model, dir })
+      process.stdout.write(`ok ${Buffer.from(text, 'utf8').toString('base64')}\n`)
+    }
+  })
+}
diff --git a/core/main/dictationEngine.test.ts b/core/main/dictationEngine.test.ts
index 01a926ec..5354580f 100644
--- a/core/main/dictationEngine.test.ts
+++ b/core/main/dictationEngine.test.ts
@@ -406,6 +406,17 @@ describe('standing down', () => {
     expect(w.launched).toHaveLength(2)
   })
 
+  // Prism Terminal's dictation service (owner, 2026-10-17: "It needs to be
+  // ready at all times"): Infinity never stands down; stop() still ends it.
+  it('never stands down with an idleMs of Infinity', async () => {
+    const w = world({}, { idleMs: Infinity })
+    await w.engine.transcribe(req())
+    await sleep(300)
+    expect(w.engine.info().running).toBe(true)
+    w.engine.stop()
+    await until(() => gone(w.children[0]))
+  })
+
   it('counts the idle time from the LAST request, not the first', async () => {
     const w = world({}, { idleMs: 500 })
     await w.engine.transcribe(req())
@@ -631,3 +642,85 @@ describe('a Parakeet model', () => {
     await until(() => gone(w.children[0]))
   })
 })
+
+// THE RESIDENT PARAKEET HOST (2026-10-17): the model kept loaded in one
+// process (core/dictation-host/parakeetHost.ps1), parakeet-cli only when it
+// cannot start. The stand-in speaks its protocol, run by this Node.
+const HOST_FIXTURE = join(dirname(fileURLToPath(import.meta.url)), '__fixtures__', 'fakeParakeetHost.mjs')
+function hostWorld(env: Record<string, string> = {}, knobs: Partial<Knobs> = {}): World & { hosts: ChildProcess[] } {
+  const hosts: ChildProcess[] = []
+  const w = world(knobs, {
+    powershell: 'FAKE-POWERSHELL',
+    parakeetHost: () => ({ script: 'parakeetHost.ps1', cache: null }),
+    spawnImpl: ((file: string, args: string[], options: { env?: NodeJS.ProcessEnv }) => {
+      let child: ChildProcess
+      if (file === 'FAKE-POWERSHELL') {
+        // The host's own argv after `-File <script>`.
+        const rest = args.slice(args.indexOf('-File') + 2)
+        child = spawn(process.execPath, [HOST_FIXTURE, ...rest], { ...options, env: { ...options.env, ...env } })
+        hosts.push(child)
+      } else child = spawn(file, args, options)
+      allChildren.push(child)
+      return child
+    }) as typeof spawn
+  })
+  return { ...w, hosts }
+}
+const hostSaw = (r: TranscribeResult): { n: number; bytes: number; pid: number; gpu: boolean; model: string } => {
+  if (!r.ok) throw new Error(`expected an answer, got ${r.reason}: ${r.detail ?? ''}`)
+  return JSON.parse(r.text)
+}
+
+describe('the resident Parakeet host', () => {
+  it('answers every pass from ONE process that keeps the model, and runs no parakeet-cli', async () => {
+    const w = hostWorld()
+    const a = hostSaw(await w.engine.transcribe(req({ modelId: 'pk' })))
+    const b = hostSaw(await w.engine.transcribe(req({ modelId: 'pk' })))
+    expect([a.n, b.n]).toEqual([1, 2])
+    expect(b.pid).toBe(a.pid)
+    expect(a.bytes).toBe(WAV.byteLength)
+    expect(a.model).toBe(MODELS.pk)
+    expect(w.launched).toHaveLength(0)
+    expect(w.hosts).toHaveLength(1)
+  })
+
+  it('falls back to parakeet-cli when the host never gets ready, and does not try it again', async () => {
+    const w = hostWorld({ FAKE_HOST: 'never' }, {})
+    const eng = createDictationEngine({
+      cpuDir: () => w.cpuDir,
+      store: { modelPath: (id) => MODELS[id] ?? null, gpuEngineDir: () => null },
+      hasNvidia: async () => false,
+      engineFor: (id) => (id === 'pk' ? 'parakeet' : 'whisper'),
+      startTimeoutMs: 300,
+      powershell: 'FAKE-POWERSHELL',
+      parakeetHost: () => ({ script: 'parakeetHost.ps1', cache: null }),
+      spawnImpl: ((file: string, args: string[], options: { env?: NodeJS.ProcessEnv }) => {
+        const child =
+          file === 'FAKE-POWERSHELL'
+            ? spawn(process.execPath, [HOST_FIXTURE, ...args.slice(args.indexOf('-File') + 2)], { ...options, env: { ...options.env, FAKE_HOST: 'never' } })
+            : spawn(file, args, options)
+        if (file === 'FAKE-POWERSHELL') w.hosts.push(child)
+        allChildren.push(child)
+        return child
+      }) as typeof spawn,
+      command: (_exePath, args) => ({ file: process.execPath, args: [PARAKEET_FIXTURE, ...args] })
+    })
+    engines.push(eng)
+    expect((await eng.transcribe(req({ modelId: 'pk' }))).ok).toBe(true)
+    expect((await eng.transcribe(req({ modelId: 'pk' }))).ok).toBe(true)
+    expect(w.hosts).toHaveLength(1)
+    await until(() => w.hosts.every(gone))
+  })
+
+  it('is ended by stop(), and by a Whisper model taking over', async () => {
+    const w = hostWorld()
+    await w.engine.transcribe(req({ modelId: 'pk' }))
+    expect(w.engine.info().running).toBe(true)
+    w.engine.stop()
+    await until(() => w.hosts.every(gone))
+    await w.engine.transcribe(req({ modelId: 'pk' }))
+    expect(w.hosts).toHaveLength(2)
+    seen(await w.engine.transcribe(req({ modelId: 'base' })))
+    await until(() => w.hosts.every(gone))
+  })
+})
diff --git a/core/main/dictationEngine.ts b/core/main/dictationEngine.ts
index e2594793..e2c4a341 100644
--- a/core/main/dictationEngine.ts
+++ b/core/main/dictationEngine.ts
@@ -1,4 +1,5 @@
 import { spawn, type ChildProcess } from 'child_process'
+import { SYS } from './sysTools'
 import { randomBytes } from 'crypto'
 import { request } from 'http'
 import { createServer } from 'net'
@@ -42,6 +43,14 @@ import type {
  * (its `-f -`, read into memory, MEASURED: "read 352078 bytes from stdin"),
  * and the text comes back on stdout. So this path writes no audio to disk
  * either. It has no language switch: the model detects the language itself.
+ *
+ * ...UNLESS THE HOST GIVES A RESIDENT HOST (2026-10-17, owner: "It needs to be
+ * ready at all times"). `parakeetHost` names `core/dictation-host/
+ * parakeetHost.ps1`, a long-lived Windows PowerShell that keeps the model
+ * loaded and calls parakeet.dll per pass. MEASURED on the owner's RTX 5090:
+ * 24 to 170 ms a pass (1 s to 60 s clips) against parakeet-cli's 0.72 to
+ * 0.86 s, the text identical; ready 0.9 s after spawn, paid once. A host that
+ * will not start is not asked again this session: parakeet-cli answers.
  * ------------------------------------------------------------------ */
 
 /** The first CUDA run compiles its kernels for about 9 s (MEASURED), so a
@@ -122,6 +131,11 @@ export interface DictationEngineDeps {
   engineFor?: (modelId: string) => 'whisper' | 'parakeet'
   /** Threads for a Parakeet pass on the CPU. */
   threads?: number
+  /** The resident Parakeet host's script, and where it may cache its compiled
+   *  code; null or absent: one parakeet-cli per pass. */
+  parakeetHost?: () => { script: string; cache: string | null } | null
+  /** Windows PowerShell, which runs that script. */
+  powershell?: string
   /** What to actually launch for an engine exe and its argv. The default is
    *  the exe itself; the tests run a Node script through process.execPath. */
   command?: (exePath: string, args: string[]) => { file: string; args: string[] }
@@ -154,6 +168,19 @@ interface Job {
 }
 
 type Launch = { ok: true; server: Server } | { ok: false; detail: string }
+
+/** The resident Parakeet host: one model on one engine, kept loaded. */
+interface ParakeetHost {
+  child: ChildProcess
+  kind: EngineKind
+  dir: string
+  modelPath: string
+  ready: Promise<boolean>
+  exited: boolean
+  /** Whoever waits on its next line ("ready", "ok ...", "err ..."), and on its exit. */
+  waiter: ((line: string | null) => void) | null
+  stderr: string
+}
 type Answer = { ok: true; text: string } | { ok: false; detail: string; died: boolean }
 
 const STOPPED: TranscribeResult = { ok: false, reason: 'engine-failed', detail: 'dictation was stopped' }
@@ -252,6 +279,9 @@ export function createDictationEngine(deps: DictationEngineDeps): DictationEngin
   let current: Server | null = null
   /** The Parakeet pass in flight, so stop() can end it. */
   let pass: ChildProcess | null = null
+  let phost: ParakeetHost | null = null
+  /** The resident host would not start: parakeet-cli for the rest of the session. */
+  let hostBroken = false
   /** The model a Parakeet pass last answered for: there is no resident
    *  process to be warm, but the first GPU pass compiles kernels (16 s,
    *  MEASURED) and a partial must not queue behind that. */
@@ -425,6 +455,123 @@ export function createDictationEngine(deps: DictationEngineDeps): DictationEngin
     })
   }
 
+  function killHost(h: ParakeetHost): void {
+    if (phost === h) phost = null
+    if (h.exited) return
+    try {
+      h.child.stdin?.end('quit\n')
+    } catch {
+      /* gone */
+    }
+    h.child.kill()
+  }
+
+  /** The host's next protocol line, or null when it exits first. */
+  function nextLine(h: ParakeetHost): Promise<string | null> {
+    return new Promise((resolve) => {
+      if (h.exited) return resolve(null)
+      h.waiter = resolve
+    })
+  }
+
+  function startHost(kind: EngineKind, dir: string, modelPath: string, script: string, cache: string | null): ParakeetHost {
+    const args = ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', script, dir, modelPath, kind === 'gpu' ? '1' : '0', String(threads)]
+    if (cache) args.push(cache)
+    const child = spawnImpl(deps.powershell ?? SYS.powershell, args, { cwd: dir, env: childEnv(kind, dir), windowsHide: true, stdio: ['pipe', 'pipe', 'pipe'] })
+    const h: ParakeetHost = { child, kind, dir, modelPath, ready: Promise.resolve(false), exited: false, waiter: null, stderr: '' }
+    let buf = ''
+    child.stdout?.setEncoding('utf8')
+    child.stdout?.on('data', (d: string) => {
+      buf += d
+      let i
+      while ((i = buf.indexOf('\n')) >= 0) {
+        const line = buf.slice(0, i).trim()
+        buf = buf.slice(i + 1)
+        // Only its own words: anything a native library printed is not.
+        if (!/^(ready|ok|err)\b/.test(line)) continue
+        const w = h.waiter
+        h.waiter = null
+        w?.(line)
+      }
+    })
+    child.stderr?.setEncoding('utf8')
+    child.stderr?.on('data', (c: string) => {
+      h.stderr = (h.stderr + c).slice(-STDERR_KEEP)
+    })
+    const gone = (): void => {
+      if (h.exited) return
+      h.exited = true
+      if (phost === h) phost = null
+      const w = h.waiter
+      h.waiter = null
+      w?.(null)
+    }
+    child.once('error', (e) => {
+      h.stderr = (h.stderr + e.message).slice(-STDERR_KEEP)
+      gone()
+    })
+    child.once('close', gone)
+    child.stdin?.on('error', () => {})
+    h.ready = new Promise<boolean>((resolve) => {
+      const timer = setTimeout(() => {
+        resolve(false)
+        killHost(h)
+      }, startTimeoutMs)
+      void nextLine(h).then((l) => {
+        clearTimeout(timer)
+        resolve(l === 'ready')
+      })
+    })
+    return h
+  }
+
+  /** One pass on the resident host: started (or restarted for another model or
+   *  engine) as needed. Null when there is no host to use: parakeet-cli then. */
+  async function hostOnce(kind: EngineKind, dir: string, modelPath: string, wav: Uint8Array): Promise<Answer | null> {
+    const spec = hostBroken ? null : deps.parakeetHost?.() ?? null
+    if (!spec) return null
+    let h = phost
+    if (h && (h.exited || h.kind !== kind || h.dir !== dir || h.modelPath !== modelPath)) {
+      killHost(h)
+      h = null
+    }
+    if (!h) {
+      h = startHost(kind, dir, modelPath, spec.script, spec.cache)
+      phost = h
+    }
+    if (!(await h.ready)) {
+      // Never ready: the host itself (PowerShell, the script) or the engine.
+      // The per-pass path says which, and the host is not tried again.
+      killHost(h)
+      hostBroken = true
+      return null
+    }
+    const answer = new Promise<Answer>((resolve) => {
+      const timer = setTimeout(() => {
+        resolve({ ok: false, detail: `no answer after ${requestTimeoutMs} ms`, died: false })
+        killHost(h!)
+      }, requestTimeoutMs)
+      void nextLine(h!).then((l) => {
+        clearTimeout(timer)
+        if (l === null) resolve({ ok: false, detail: h!.stderr.trim() || 'the Parakeet host exited', died: true })
+        else if (l.startsWith('ok')) resolve({ ok: true, text: Buffer.from(l.slice(3).trim(), 'base64').toString('utf8').trim() })
+        else resolve({ ok: false, detail: l.slice(4), died: false })
+      })
+    })
+    try {
+      h.child.stdin?.write(`pass ${wav.byteLength}\n`)
+      h.child.stdin?.write(Buffer.from(wav.buffer, wav.byteOffset, wav.byteLength))
+    } catch {
+      /* its exit answers */
+    }
+    return answer
+  }
+
+  /** One pass, on the resident host when there is one, else a fresh parakeet-cli. */
+  async function parakeetPass(kind: EngineKind, dir: string, modelPath: string, wav: Uint8Array): Promise<Answer> {
+    return (await hostOnce(kind, dir, modelPath, wav)) ?? parakeetOnce(kind, dir, modelPath, wav)
+  }
+
   /** A pass for a Parakeet model: the same choice of engine and the same
    *  once-and-for-good fall back to the CPU as a Whisper server gets. */
   async function runParakeet(req: TranscribeRequest, modelPath: string, stopped: () => boolean): Promise<TranscribeResult> {
@@ -434,7 +581,7 @@ export function createDictationEngine(deps: DictationEngineDeps): DictationEngin
     if (stopped()) return STOPPED
     if (!want) return { ok: false, reason: 'no-engine' }
     let kind = want.kind
-    let answer = await parakeetOnce(kind, want.dir, modelPath, req.wav)
+    let answer = await parakeetPass(kind, want.dir, modelPath, req.wav)
     if (stopped()) return STOPPED
     // Only a GPU engine that DIED falls back, Whisper's own rule: an "error:"
     // about the audio or a timeout is not the card's fault, and the switch
@@ -448,7 +595,7 @@ export function createDictationEngine(deps: DictationEngineDeps): DictationEngin
       const cpuDir = deps.cpuDir()
       if (!cpuDir) return { ok: false, reason: 'engine-failed', detail: answer.detail }
       kind = 'cpu'
-      answer = await parakeetOnce(kind, cpuDir, modelPath, req.wav)
+      answer = await parakeetPass(kind, cpuDir, modelPath, req.wav)
       if (stopped()) return STOPPED
     }
     lastKind = kind
@@ -599,6 +746,8 @@ export function createDictationEngine(deps: DictationEngineDeps): DictationEngin
     if (!modelPath) return { ok: false, reason: 'no-model' }
     if (runnerFor(req.modelId) === 'parakeet') return runParakeet(req, modelPath, stopped)
     const language = req.language || 'auto'
+    // A resident Parakeet host holds a model nobody uses now.
+    if (phost) killHost(phost)
 
     const want = await pick()
     if (stopped()) return STOPPED
@@ -653,13 +802,19 @@ export function createDictationEngine(deps: DictationEngineDeps): DictationEngin
 
   function armIdle(): void {
     if (idleTimer) clearTimeout(idleTimer)
+    // Never stands down (a host that keeps it ready at all times, Prism
+    // Terminal's dictation service): only `stop()` ends it.
+    if (!Number.isFinite(idleMs)) return
     // unref: a timer five minutes out must not be what keeps a quitting app alive.
     idleTimer = setTimeout(() => {
       idleTimer = null
-      if (running || !current) return
+      if (running || (!current && !phost)) return
       const left = lastUsed + idleMs - now()
       if (left > 0) armIdle()
-      else kill(current)
+      else {
+        if (current) kill(current)
+        if (phost) killHost(phost)
+      }
     }, Math.max(1, lastUsed + idleMs - now()))
     idleTimer.unref()
   }
@@ -673,7 +828,7 @@ export function createDictationEngine(deps: DictationEngineDeps): DictationEngin
     }
     if (!job) {
       lastUsed = now()
-      if (current) armIdle()
+      if (current || phost) armIdle()
       return
     }
     if (idleTimer) {
@@ -747,13 +902,14 @@ export function createDictationEngine(deps: DictationEngineDeps): DictationEngin
         pass.kill()
         pass = null
       }
+      if (phost) killHost(phost)
       parakeetWarm = null
     },
 
     info() {
       // `engine` is the kind of the server that is up, or of the last one that
       // was, so Settings can still say which engine answered after a stand-down.
-      return { running: current !== null || pass !== null, engine: current ? current.kind : lastKind, gpuFellBack }
+      return { running: current !== null || pass !== null || phost !== null, engine: current ? current.kind : lastKind, gpuFellBack }
     }
   }
 }
diff --git a/core/main/dictationIpc.ts b/core/main/dictationIpc.ts
index fb305528..b4e7f624 100644
--- a/core/main/dictationIpc.ts
+++ b/core/main/dictationIpc.ts
@@ -37,6 +37,12 @@ export interface DictationIpcDeps {
   /** `%LOCALAPPDATA%\PrismDictation`: models and the GPU pack, shared by both apps. */
   sharedRoot: string
   hasNvidia(): Promise<boolean>
+  /** How long the engine stays up with nothing to do (default five minutes);
+   *  Infinity keeps it ready until dictation is switched off. */
+  idleMs?: number
+  /** The resident Parakeet host (`core/dictation-host/parakeetHost.ps1`, wherever
+   *  the host ships it) and a folder for its compiled code; absent: parakeet-cli per pass. */
+  parakeetHost?: () => { script: string; cache: string | null } | null
   /** Test seams. */
   store?: DictationStore
   engine?: DictationEngine
@@ -59,6 +65,8 @@ export function registerDictationIpc(deps: DictationIpcDeps): () => void {
       cpuDir: deps.cpuEngineDir,
       store,
       hasNvidia: deps.hasNvidia,
+      idleMs: deps.idleMs,
+      parakeetHost: deps.parakeetHost,
       // The GPU engine's own kernel cache, beside the models both apps share
       // (see DICTATION_CUDA_CACHE_BYTES): compiled once, kept for good.
       cudaCacheDir: () => {
diff --git a/core/package.json b/core/package.json
index 6a06bdec..bb5a2836 100644
--- a/core/package.json
+++ b/core/package.json
@@ -1,6 +1,6 @@
 {
   "name": "prism-term-core",
-  "version": "0.42.0",
+  "version": "0.43.0",
   "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,
diff --git a/core/renderer/components/TerminalPanel.tsx b/core/renderer/components/TerminalPanel.tsx
index 19e81f44..b48a2e3e 100644
--- a/core/renderer/components/TerminalPanel.tsx
+++ b/core/renderer/components/TerminalPanel.tsx
@@ -1357,12 +1357,16 @@ export default function TerminalPanel({
     }
   }, [sessionId])
 
+  // `isolate`: xterm's own layers carry z-indexes up to 11 (its link underline
+  // canvas, decorations, the scrollbar); without a stacking context of their
+  // own they painted OVER the skeleton (z 1) as thin blue lines (owner,
+  // 2026-10-17: "these horizontal thin lines" while the sessions load).
   return (
     <div className="relative h-full w-full min-h-0 min-w-0">
       <div
         ref={box}
         data-term-region
-        className={`h-full w-full min-h-0 min-w-0 p-1 ${paintsGround() ? 'bg-[var(--p-bg)]' : ''}`}
+        className={`isolate h-full w-full min-h-0 min-w-0 p-1 ${paintsGround() ? 'bg-[var(--p-bg)]' : ''}`}
       />
       {(resumingNow || leaving) && <ResumeSkeleton leaving={!resumingNow} />}
     </div>
diff --git a/core/renderer/lib/dictation.ts b/core/renderer/lib/dictation.ts
index 0ab92d0a..90dc59a6 100644
--- a/core/renderer/lib/dictation.ts
+++ b/core/renderer/lib/dictation.ts
@@ -131,6 +131,69 @@ interface Recording {
 let rec: Recording | null = null
 let messageTimer: number | null = null
 
+/**
+ * DICTATING FROM OUTSIDE THE APP (owner, 2026-10-16: "you can start the
+ * dictation while not having the app in focus"). A host with a global key
+ * (Prism Terminal's globalDictKey) starts and stops a recording through
+ * `dictationOutside`; it belongs to no tab (`OUTSIDE`), and what was heard goes
+ * to the host's `setDictationRoute` sink instead of being pasted: the host
+ * decides where it goes (the orchestrator, or a session the owner picks). A
+ * host that sets none never starts one.
+ */
+export const OUTSIDE = '\u0000outside'
+export type RouteResult = { text: string } | { message: string }
+let routeSink: ((r: RouteResult) => void) | null = null
+export function setDictationRoute(sink: ((r: RouteResult) => void) | null): void {
+  routeSink = sink
+}
+export function dictationOutside(action: 'start' | 'stop' | 'cancel'): void {
+  if (action === 'start') {
+    if (!routeSink || !dictationEnabled() || !dictationHost()) return
+    // No model: said in the host's widget, where the owner is looking.
+    if (!dictationModel()) return routeSink({ message: 'Choose a speech model in Settings' })
+    void begin(OUTSIDE)
+  } else if (action === 'stop') stop()
+  else cancel()
+}
+/*
+ * ONE KEY PATH (Prism Terminal, owner 2026-10-17: "the dictation in the app
+ * and outside seem like two different things ... they should be the same
+ * thing"). A host whose main process reads the key everywhere (a keyboard
+ * hook) turns the window's own key reading off, drives every recording with
+ * `dictationOutside`, and has the words pasted into the tab in front with
+ * `pasteIntoFront` when its own window was in front. A host that sets none of
+ * this (Prism) reads the key in its window as before.
+ */
+let pageKeys = true
+let autoWarm = true
+let frontSession: (() => string | null) | null = null
+/** Whether this window reads the dictation key itself (on unless a host says). */
+export function setDictationPageKeys(on: boolean): void {
+  pageKeys = on
+}
+/** Whether this window warms the engine on its own (off in a copy whose
+ *  dictation another copy runs, so only one engine is resident). */
+export function setDictationAutoWarm(on: boolean): void {
+  autoWarm = on
+}
+/** Have the engine ready now (idempotent in main). */
+export function keepDictationWarm(): void {
+  warmEngine()
+}
+/** Paste dictated words at the cursor of the tab in front, never Enter. */
+export function pasteIntoFront(text: string): boolean {
+  const id = frontSession?.()
+  return !!id && pasteTextInto(id, text + ' ')
+}
+
+/** Said to the sink when the recording is the outside one, else on the pill. */
+function tell(r: Recording, message: string): void {
+  if (r.sessionId === OUTSIDE) {
+    routeSink?.({ message })
+    setView(IDLE)
+  } else say(message)
+}
+
 function say(message: string): void {
   if (messageTimer !== null) clearTimeout(messageTimer)
   setView({ ...IDLE, message })
@@ -190,7 +253,7 @@ async function begin(sessionId: string): Promise<void> {
   } catch (err) {
     rec = null
     resumeMedia(r)
-    say(FAILURE_TEXT[(typeof err === 'string' ? err : 'failed') as CaptureFailure] ?? FAILURE_TEXT.failed)
+    tell(r, FAILURE_TEXT[(typeof err === 'string' ? err : 'failed') as CaptureFailure] ?? FAILURE_TEXT.failed)
     return
   }
   // The key was released (or Escape pressed) while the mic was still opening.
@@ -226,6 +289,7 @@ function finishCancel(r: Recording): void {
   if (rec === r) rec = null
   resumeMedia(r)
   if (dictationSounds()) cancelCue()
+  if (r.sessionId === OUTSIDE) routeSink?.({ message: 'Cancelled' })
   setView(IDLE)
 }
 
@@ -236,6 +300,7 @@ async function finishStop(r: Recording): Promise<void> {
   if (!host || samples.length < MIN_SECONDS * TARGET_RATE) {
     if (rec === r) rec = null
     resumeMedia(r)
+    if (r.sessionId === OUTSIDE) routeSink?.({ message: 'Heard nothing' })
     setView(IDLE)
     return
   }
@@ -257,7 +322,8 @@ async function finishStop(r: Recording): Promise<void> {
   if (rec === r) rec = null
   resumeMedia(r)
   if (!res.ok) {
-    say(
+    tell(
+      r,
       res.reason === 'no-model'
         ? 'Choose a model in Settings'
         : res.reason === 'no-engine'
@@ -267,7 +333,14 @@ async function finishStop(r: Recording): Promise<void> {
     return
   }
   const text = cleanTranscript(res.text)
-  if (!text) return say('Heard nothing')
+  if (!text) return tell(r, 'Heard nothing')
+  // From outside the app: the host routes it (and presses Enter there, by the
+  // owner's own route), never a paste into whatever tab is in front.
+  if (r.sessionId === OUTSIDE) {
+    routeSink?.({ text })
+    setView(IDLE)
+    return
+  }
   // A trailing space, so the next dictation (or the next typed word) does not
   // run into this one. Never a newline: that is Enter.
   if (!pasteTextInto(r.sessionId, text + ' ')) return say('That tab has closed')
@@ -324,7 +397,13 @@ export function armDictation(activeSession: () => string | null): () => void {
     else if (out.action === 'cancel') cancel()
   }
 
-  const onKey = (e: KeyboardEvent): void =>
+  frontSession = activeSession
+  const onKey = (e: KeyboardEvent): void => {
+    // Another reader has the key (the host's hook): nothing held here either.
+    if (!pageKeys) {
+      keyState = initialKeyState()
+      return
+    }
     feed(
       {
         type: e.type === 'keydown' ? 'down' : 'up',
@@ -338,6 +417,7 @@ export function armDictation(activeSession: () => string | null): () => void {
       },
       e
     )
+  }
   const onBlur = (): void => feed({ type: 'blur', at: performance.now() })
 
   let warmTimer: number | null = null
@@ -347,7 +427,7 @@ export function armDictation(activeSession: () => string | null): () => void {
     // opened), and again when its model or language changes; off means off,
     // so nothing is warmed while it is off.
     if (warmTimer !== null) clearTimeout(warmTimer)
-    warmTimer = want ? window.setTimeout(() => {
+    warmTimer = want && autoWarm ? window.setTimeout(() => {
       warmTimer = null
       warmEngine()
     }, armed ? 500 : 3000) : null
diff --git a/core/renderer/lib/dictationKey.test.ts b/core/renderer/lib/dictationKey.test.ts
index cccbc44e..fa09e506 100644
--- a/core/renderer/lib/dictationKey.test.ts
+++ b/core/renderer/lib/dictationKey.test.ts
@@ -15,6 +15,10 @@ import {
   type KeyState
 } from './dictationKey'
 
+/** The bare Right Alt the solo rules were written for (the default until
+ *  2026-10-16): every AltGr rule is still held on it. */
+const RIGHT_ALT: Hotkey = { code: 'AltRight', ctrl: false, alt: false, shift: false, meta: false }
+
 type Mods = Partial<Pick<Hotkey, 'ctrl' | 'alt' | 'shift' | 'meta'>> & { repeat?: boolean }
 
 const key = (type: 'down' | 'up', code: string, at: number, m: Mods = {}): KeyEvt => ({
@@ -46,7 +50,7 @@ interface Step {
 function run(
   events: KeyEvt[],
   mode: DictMode,
-  hotkey: Hotkey = DEFAULT_HOTKEY,
+  hotkey: Hotkey = RIGHT_ALT,
   holdMs?: number
 ): { steps: Step[]; actions: KeyAction[]; state: KeyState } {
   let state = initialKeyState()
@@ -63,8 +67,12 @@ const CHORD: Hotkey = { code: 'KeyD', ctrl: true, alt: false, shift: true, meta:
 const F9: Hotkey = { code: 'F9', ctrl: false, alt: false, shift: false, meta: false }
 
 describe('the default', () => {
-  it('is a bare Right Alt', () => {
-    expect(DEFAULT_HOTKEY).toEqual({ code: 'AltRight', ctrl: false, alt: false, shift: false, meta: false })
+  // Owner, 2026-10-16: Ctrl+Win, since right Alt is AltGr on a Norwegian
+  // keyboard and the key now works from any app.
+  it('is Ctrl+Win', () => {
+    expect(DEFAULT_HOTKEY).toEqual({ code: 'MetaLeft', ctrl: true, alt: false, shift: false, meta: true })
+    expect(formatHotkey(DEFAULT_HOTKEY)).toBe('Ctrl+Win')
+    expect(usableHotkey(DEFAULT_HOTKEY)).toBe(true)
   })
   it('starts idle', () => {
     expect(initialKeyState().phase).toBe('idle')
@@ -84,7 +92,7 @@ describe('hold mode, bare modifier', () => {
   })
 
   it('honours a holdMs of its own', () => {
-    const r = run([raltDown(0), tick(200), tick(350)], 'hold', DEFAULT_HOTKEY, 350)
+    const r = run([raltDown(0), tick(200), tick(350)], 'hold', RIGHT_ALT, 350)
     expect(r.steps.map((s) => s.action)).toEqual([null, null, 'start'])
   })
 
@@ -354,17 +362,17 @@ describe('a chord or a plain key', () => {
 
 describe('isHotkeyEvent', () => {
   it('a bare modifier matches itself, its own flag notwithstanding', () => {
-    expect(isHotkeyEvent(raltDown(0), DEFAULT_HOTKEY)).toBe(true)
-    expect(isHotkeyEvent(down('AltRight', 0, { ctrl: true, alt: true }), DEFAULT_HOTKEY)).toBe(true)
-    expect(isHotkeyEvent(down('AltLeft', 0, { alt: true }), DEFAULT_HOTKEY)).toBe(false)
-    expect(isHotkeyEvent(raltDown(0, { shift: true }), DEFAULT_HOTKEY)).toBe(false)
+    expect(isHotkeyEvent(raltDown(0), RIGHT_ALT)).toBe(true)
+    expect(isHotkeyEvent(down('AltRight', 0, { ctrl: true, alt: true }), RIGHT_ALT)).toBe(true)
+    expect(isHotkeyEvent(down('AltLeft', 0, { alt: true }), RIGHT_ALT)).toBe(false)
+    expect(isHotkeyEvent(raltDown(0, { shift: true }), RIGHT_ALT)).toBe(false)
   })
   it('only Right Alt is forgiven a Ctrl: that is AltGr, and no other key has one', () => {
-    const lalt: Hotkey = { ...DEFAULT_HOTKEY, code: 'AltLeft' }
+    const lalt: Hotkey = { ...RIGHT_ALT, code: 'AltLeft' }
     expect(isHotkeyEvent(down('AltLeft', 0, { ctrl: true, alt: true }), lalt)).toBe(false)
   })
   it('an up matches on the code alone, whatever is still held', () => {
-    expect(isHotkeyEvent(up('AltRight', 0, { ctrl: true }), DEFAULT_HOTKEY)).toBe(true)
+    expect(isHotkeyEvent(up('AltRight', 0, { ctrl: true }), RIGHT_ALT)).toBe(true)
     expect(isHotkeyEvent(up('KeyD', 0), CHORD)).toBe(true)
   })
   it('a chord matches its modifiers exactly', () => {
@@ -373,8 +381,8 @@ describe('isHotkeyEvent', () => {
     expect(isHotkeyEvent(down('KeyD', 0, { ctrl: true, shift: true, alt: true }), CHORD)).toBe(false)
   })
   it('a tick and a blur are nobody\'s key', () => {
-    expect(isHotkeyEvent(tick(0), DEFAULT_HOTKEY)).toBe(false)
-    expect(isHotkeyEvent(blur(0), DEFAULT_HOTKEY)).toBe(false)
+    expect(isHotkeyEvent(tick(0), RIGHT_ALT)).toBe(false)
+    expect(isHotkeyEvent(blur(0), RIGHT_ALT)).toBe(false)
   })
 })
 
@@ -387,7 +395,7 @@ describe('formatHotkey', () => {
     meta: m.meta ?? false
   })
   it('names a bare modifier by its side', () => {
-    expect(formatHotkey(DEFAULT_HOTKEY)).toBe('Right Alt')
+    expect(formatHotkey(RIGHT_ALT)).toBe('Right Alt')
     expect(formatHotkey(h('ControlLeft'))).toBe('Left Ctrl')
     expect(formatHotkey(h('ShiftRight'))).toBe('Right Shift')
     expect(formatHotkey(h('MetaLeft'))).toBe('Left Win')
@@ -410,7 +418,7 @@ describe('formatHotkey', () => {
 
 describe('parseHotkeyFromEvent', () => {
   it('a bare modifier press is that modifier, with its own flag dropped', () => {
-    expect(parseHotkeyFromEvent(raltDown(0))).toEqual(DEFAULT_HOTKEY)
+    expect(parseHotkeyFromEvent(raltDown(0))).toEqual(RIGHT_ALT)
     expect(parseHotkeyFromEvent(down('ControlLeft', 0, { ctrl: true }))).toEqual({
       code: 'ControlLeft',
       ctrl: false,
@@ -420,7 +428,7 @@ describe('parseHotkeyFromEvent', () => {
     })
   })
   it('AltGr is read as Right Alt, not as Ctrl+Right Alt', () => {
-    expect(parseHotkeyFromEvent(down('AltRight', 0, { ctrl: true, alt: true }))).toEqual(DEFAULT_HOTKEY)
+    expect(parseHotkeyFromEvent(down('AltRight', 0, { ctrl: true, alt: true }))).toEqual(RIGHT_ALT)
   })
   it('a chord keeps its modifiers', () => {
     expect(parseHotkeyFromEvent(down('KeyD', 0, { ctrl: true, shift: true }))).toEqual(CHORD)
@@ -438,7 +446,7 @@ describe('parseHotkeyFromEvent', () => {
     const dom = { type: 'keydown', code: 'KeyD', ctrlKey: true, altKey: false, shiftKey: true, metaKey: false }
     expect(parseHotkeyFromEvent(dom)).toEqual(CHORD)
     const altGr = { type: 'keydown', code: 'AltRight', ctrlKey: true, altKey: true, shiftKey: false, metaKey: false }
-    expect(parseHotkeyFromEvent(altGr)).toEqual(DEFAULT_HOTKEY)
+    expect(parseHotkeyFromEvent(altGr)).toEqual(RIGHT_ALT)
     expect(parseHotkeyFromEvent({ ...dom, code: 'Escape' })).toBeNull()
   })
   it('round-trips through the reducer: what was bound is what is recognised', () => {
@@ -476,7 +484,7 @@ describe('usableHotkey', () => {
     ...mods
   })
   it('takes the default, a bare modifier, a function key and a free chord', () => {
-    expect(usableHotkey(DEFAULT_HOTKEY)).toBe(true)
+    expect(usableHotkey(RIGHT_ALT)).toBe(true)
     expect(usableHotkey(hk('ControlLeft'))).toBe(true)
     expect(usableHotkey(hk('F9'))).toBe(true)
     expect(usableHotkey(hk('Pause'))).toBe(true)
@@ -494,3 +502,39 @@ describe('usableHotkey', () => {
     expect(usableHotkey(hk('KeyC', { ctrl: true, shift: true }))).toBe(false)
   })
 })
+
+// CTRL+WIN, A CHORD OF MODIFIERS (owner, 2026-10-16): either key first, the
+// solo rules (it decides while nothing else is pressed), either key's up stops.
+describe('a chord of modifiers (Ctrl+Win)', () => {
+  const CW = DEFAULT_HOTKEY
+  const ctrlDown = (at: number, o: Partial<Record<'ctrl' | 'meta', boolean>> = {}) => down('ControlLeft', at, { ctrl: true, ...o })
+  const winDown = (at: number, o: Partial<Record<'ctrl' | 'meta', boolean>> = {}) => down('MetaLeft', at, { meta: true, ...o })
+
+  it('records on a hold, Ctrl first or Win first, and stops on either key going up', () => {
+    const a = run([ctrlDown(0), winDown(10, { ctrl: true }), tick(210), up('MetaLeft', 900, { ctrl: true })], 'hold', CW)
+    expect(a.actions.filter(Boolean)).toEqual(['start', 'stop'])
+    const b = run([winDown(0), ctrlDown(10, { meta: true }), tick(210), up('ControlLeft', 900, { meta: true })], 'hold', CW)
+    expect(b.actions.filter(Boolean)).toEqual(['start', 'stop'])
+  })
+
+  it('never dictates Ctrl+Win+Left (switching desktops): the arrow cancels it, unswallowed', () => {
+    const r = run([ctrlDown(0), winDown(10, { ctrl: true }), down('ArrowLeft', 60, { ctrl: true, meta: true }), tick(210)], 'hold', CW)
+    expect(r.actions.filter(Boolean)).toEqual([])
+    expect(r.steps[2].swallow).toBe(false)
+  })
+
+  it('is not Ctrl alone, nor Win alone, nor Ctrl+Shift+Win', () => {
+    expect(isHotkeyEvent(ctrlDown(0), CW)).toBe(false)
+    expect(isHotkeyEvent(winDown(0), CW)).toBe(false)
+    expect(isHotkeyEvent(winDown(0, { ctrl: true }), CW)).toBe(true)
+    expect(isHotkeyEvent(down('MetaLeft', 0, { ctrl: true, meta: true, shift: true }), CW)).toBe(false)
+  })
+
+  it('binds from the keys as pressed, and names itself by its modifiers', () => {
+    expect(parseHotkeyFromEvent(winDown(0, { ctrl: true }))).toEqual(CW)
+    expect(parseHotkeyFromEvent(ctrlDown(0, { meta: true }))).toEqual({ code: 'ControlLeft', ctrl: true, alt: false, shift: false, meta: true })
+    expect(formatHotkey({ code: 'ControlLeft', ctrl: true, alt: false, shift: false, meta: true })).toBe('Ctrl+Win')
+    // Right Alt with the Ctrl AltGr brings is still the bare key.
+    expect(parseHotkeyFromEvent(down('AltRight', 0, { ctrl: true, alt: true }))).toEqual(RIGHT_ALT)
+  })
+})
diff --git a/core/renderer/lib/dictationKey.ts b/core/renderer/lib/dictationKey.ts
index f3ff6b29..02bfb740 100644
--- a/core/renderer/lib/dictationKey.ts
+++ b/core/renderer/lib/dictationKey.ts
@@ -27,7 +27,15 @@ export interface Hotkey {
   meta: boolean
 }
 
-export const DEFAULT_HOTKEY: Hotkey = { code: 'AltRight', ctrl: false, alt: false, shift: false, meta: false }
+/**
+ * CTRL+WIN (owner, 2026-10-16: "we'll change it from being right Alt to being
+ * control plus the windows key"): right Alt is AltGr on the owner's Norwegian
+ * keyboard, and the key now works from any app (globalDictKey), where AltGr
+ * types @ { [ in everything else. A MODIFIER CHORD: either key may go first,
+ * and it follows the solo rules below, so Ctrl+Win+Left (switch desktops)
+ * never dictates. A user's own saved key is kept; only the default moved.
+ */
+export const DEFAULT_HOTKEY: Hotkey = { code: 'MetaLeft', ctrl: true, alt: false, shift: false, meta: true }
 
 export type DictMode = 'hold' | 'toggle'
 
@@ -115,11 +123,35 @@ export function initialKeyState(): KeyState {
   return { phase: 'idle', held: false, downAt: 0, polluted: false, altGr: false, escHeld: false }
 }
 
-/** A modifier bound on its own, which is what the solo rules apply to. */
+/** A modifier bound on its own. */
 function isBareModifier(h: Hotkey): boolean {
   return h.code in MODIFIER_FLAG && !h.ctrl && !h.alt && !h.shift && !h.meta
 }
 
+/** The modifiers a binding made only of modifiers holds down: its own key's
+ *  flag and every flag it names (Ctrl+Win: ctrl and meta). */
+function chordSet(h: Hotkey): Set<'ctrl' | 'alt' | 'shift' | 'meta'> {
+  const set = new Set(FLAGS.filter((f) => h[f]))
+  const own = MODIFIER_FLAG[h.code]
+  if (own) set.add(own)
+  return set
+}
+
+/** Only modifiers: a bare one (Right Alt) or a chord of them (Ctrl+Win). The
+ *  SOLO rules apply to both: it decides while nothing else is pressed, so a
+ *  key that is typed with it (AltGr's @, Ctrl+Win+Left) is never dictation. */
+function isSolo(h: Hotkey): boolean {
+  return h.code in MODIFIER_FLAG
+}
+
+/** A key of this solo binding: the bare key itself, or any key of a chord's
+ *  modifiers, left or right (Ctrl+Win takes either Ctrl, either Win). */
+function isSoloKey(code: string, h: Hotkey): boolean {
+  if (isBareModifier(h)) return code === h.code
+  const flag = MODIFIER_FLAG[code]
+  return !!flag && chordSet(h).has(flag)
+}
+
 /**
  * Is this event the hotkey?
  *
@@ -138,6 +170,14 @@ function isBareModifier(h: Hotkey): boolean {
  */
 export function isHotkeyEvent(evt: KeyEvt | KeyChord, hotkey: Hotkey): boolean {
   if (evt.type === 'tick' || evt.type === 'blur') return false
+  // A chord of modifiers: either of its keys, the moment the held set is
+  // exactly the chord (the second key down completes it, whichever it is).
+  if (isSolo(hotkey) && !isBareModifier(hotkey)) {
+    if (!isSoloKey(evt.code, hotkey)) return false
+    if (evt.type === 'up') return true
+    const set = chordSet(hotkey)
+    return FLAGS.every((f) => !!evt[f] === set.has(f))
+  }
   if (evt.code !== hotkey.code) return false
   if (evt.type === 'up') return true
   if (!isBareModifier(hotkey)) return FLAGS.every((f) => evt[f] === hotkey[f])
@@ -157,7 +197,8 @@ export function isHotkeyEvent(evt: KeyEvt | KeyChord, hotkey: Hotkey): boolean {
  */
 export function reduceKey(state: KeyState, evt: KeyEvt, cfg: KeyConfig): KeyResult {
   const holdMs = cfg.holdMs ?? DEFAULT_HOLD_MS
-  const bare = isBareModifier(cfg.hotkey)
+  // Solo: a bare modifier or a chord of modifiers (Ctrl+Win) decides alone.
+  const bare = isSolo(cfg.hotkey)
   const stay = (swallow = false): KeyResult => ({ state, action: null, swallow })
   /** Hold mode's wait is over: the key has been down, alone, for holdMs. */
   const ripe = bare && cfg.mode === 'hold' && state.phase === 'arming' && evt.at - state.downAt >= holdMs
@@ -178,7 +219,7 @@ export function reduceKey(state: KeyState, evt: KeyEvt, cfg: KeyConfig): KeyResu
     return stay()
   }
 
-  const own = evt.code === cfg.hotkey.code
+  const own = bare ? isSoloKey(evt.code, cfg.hotkey) : evt.code === cfg.hotkey.code
 
   if (evt.type === 'up') {
     if (own && state.held) return release(state, evt.at, cfg.mode, bare)
@@ -191,7 +232,7 @@ export function reduceKey(state: KeyState, evt: KeyEvt, cfg: KeyConfig): KeyResu
   // ---- a key going down ----
 
   if (own && state.held) {
-    // Auto-repeat of the hotkey (or a down with the repeat flag lost): part of
+    // Auto-repeat of the hotkey (either key of a chord) (or a down with the repeat flag lost): part of
     // the same press. It never arms again, but it is an event like any other
     // and can carry the start if the host's tick is late.
     if (ripe) return { state: { ...state, phase: 'listening' }, action: 'start', swallow: true }
@@ -333,6 +374,11 @@ function keyName(code: string): string {
 
 /** 'Right Alt', 'Ctrl+Shift+D': what Settings shows for a binding. */
 export function formatHotkey(h: Hotkey): string {
+  // A chord of modifiers is its modifiers: 'Ctrl+Win', not 'Ctrl+Win+Left Win'.
+  if (isSolo(h) && !isBareModifier(h)) {
+    const set = chordSet(h)
+    return (['ctrl', 'alt', 'shift', 'meta'] as const).filter((f) => set.has(f)).map((f) => ({ ctrl: 'Ctrl', alt: 'Alt', shift: 'Shift', meta: 'Win' })[f]).join('+')
+  }
   const parts: string[] = []
   if (h.ctrl) parts.push('Ctrl')
   if (h.alt) parts.push('Alt')
@@ -361,7 +407,15 @@ export function parseHotkeyFromEvent(evt: KeyEvt | KeyChord | DomKeyLike): Hotke
   if ('ctrlKey' in evt) return parseHotkeyFromEvent(keyEvtFromDom('down', evt, 0))
   if (evt.type === 'tick' || evt.type === 'blur') return null
   if (!evt.code || evt.code === 'Unidentified' || evt.code === 'Escape') return null
-  if (evt.code in MODIFIER_FLAG) return { code: evt.code, ctrl: false, alt: false, shift: false, meta: false }
+  if (evt.code in MODIFIER_FLAG) {
+    // A modifier with OTHER modifiers held is a chord of them (Ctrl+Win), the
+    // key's own flag set; alone, or Right Alt with the Ctrl AltGr brings, it
+    // is that key bare.
+    const own = MODIFIER_FLAG[evt.code]
+    const others = FLAGS.filter((f) => f !== own && evt[f] && !(f === 'ctrl' && evt.code === 'AltRight'))
+    if (!others.length) return { code: evt.code, ctrl: false, alt: false, shift: false, meta: false }
+    return { code: evt.code, ctrl: evt.ctrl || own === 'ctrl', alt: evt.alt || own === 'alt', shift: evt.shift || own === 'shift', meta: evt.meta || own === 'meta' }
+  }
   return { code: evt.code, ctrl: evt.ctrl, alt: evt.alt, shift: evt.shift, meta: evt.meta }
 }
 
@@ -375,7 +429,8 @@ export function parseHotkeyFromEvent(evt: KeyEvt | KeyChord | DomKeyLike): Hotke
  * Alt or Win that the terminal does not already use.
  */
 export function usableHotkey(h: Hotkey): boolean {
-  if (isBareModifier(h)) return true
+  // Modifiers alone type nothing: a bare one, or a chord of two or more.
+  if (isSolo(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
diff --git a/core/renderer/lib/micCapture.test.ts b/core/renderer/lib/micCapture.test.ts
new file mode 100644
index 00000000..d993cf76
--- /dev/null
+++ b/core/renderer/lib/micCapture.test.ts
@@ -0,0 +1,47 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { startCapture } from './micCapture'
+
+/**
+ * THE CHOSEN MIC IS GONE, SO THE SYSTEM DEFAULT (owner, 2026-10-17: "it says
+ * now it cant find the mic, but mics connected and should be the system
+ * default"). A saved device id that no longer matches records from the
+ * default instead of failing.
+ */
+describe('startCapture', () => {
+  afterEach(() => vi.unstubAllGlobals())
+  const stub = (getUserMedia: (c: MediaStreamConstraints) => Promise<MediaStream>): void => {
+    vi.stubGlobal('MediaStreamTrackProcessor', class {})
+    vi.stubGlobal('navigator', { mediaDevices: { getUserMedia } })
+  }
+  // A stream with no audio track ends the open right after getUserMedia.
+  const empty = { getAudioTracks: () => [], getTracks: () => [] } as unknown as MediaStream
+  const gone = Object.assign(new Error('gone'), { name: 'OverconstrainedError' })
+
+  it('falls back to the default mic when the saved one is gone', async () => {
+    const calls: MediaStreamConstraints[] = []
+    stub(async (c) => {
+      calls.push(c)
+      if (calls.length === 1) throw gone
+      return empty
+    })
+    await expect(startCapture({ deviceId: 'stale' })).rejects.toBe('no-device')
+    expect(calls).toHaveLength(2)
+    expect((calls[0].audio as MediaTrackConstraints).deviceId).toEqual({ exact: 'stale' })
+    expect((calls[1].audio as MediaTrackConstraints).deviceId).toBeUndefined()
+  })
+
+  it('does not retry a refusal, nor when no mic was chosen', async () => {
+    const denied = vi.fn(async () => {
+      throw Object.assign(new Error('no'), { name: 'NotAllowedError' })
+    })
+    stub(denied)
+    await expect(startCapture({ deviceId: 'dji' })).rejects.toBe('denied')
+    expect(denied).toHaveBeenCalledTimes(1)
+    const none = vi.fn(async () => {
+      throw gone
+    })
+    stub(none)
+    await expect(startCapture({})).rejects.toBe('no-device')
+    expect(none).toHaveBeenCalledTimes(1)
+  })
+})
diff --git a/core/renderer/lib/micCapture.ts b/core/renderer/lib/micCapture.ts
index 610924ed..189162b6 100644
--- a/core/renderer/lib/micCapture.ts
+++ b/core/renderer/lib/micCapture.ts
@@ -52,11 +52,10 @@ export async function startCapture(opts: {
     .MediaStreamTrackProcessor
   if (!Processor || !navigator.mediaDevices?.getUserMedia) throw 'unsupported' satisfies CaptureFailure
 
-  let stream: MediaStream
-  try {
-    stream = await navigator.mediaDevices.getUserMedia({
+  const open = (deviceId?: string): Promise<MediaStream> =>
+    navigator.mediaDevices.getUserMedia({
       audio: {
-        ...(opts.deviceId ? { deviceId: { exact: opts.deviceId } } : {}),
+        ...(deviceId ? { deviceId: { exact: deviceId } } : {}),
         channelCount: 1,
         // Takes this page's own output (the start cue) out of the recording.
         echoCancellation: true,
@@ -66,8 +65,21 @@ export async function startCapture(opts: {
         autoGainControl: true
       }
     })
+  let stream: MediaStream
+  try {
+    stream = await open(opts.deviceId)
   } catch (err) {
-    throw captureFailure(err)
+    // THE CHOSEN MIC IS GONE, SO THE SYSTEM DEFAULT (owner, 2026-10-17: "it
+    // says now it cant find the mic, but mics connected and should be the
+    // system default"). A saved device id stops matching when the mic is
+    // replugged into another port or the profile is new; refusing to record
+    // then is worse than recording from the default.
+    if (!opts.deviceId || captureFailure(err) !== 'no-device') throw captureFailure(err)
+    try {
+      stream = await open()
+    } catch (err2) {
+      throw captureFailure(err2)
+    }
   }
 
   const track = stream.getAudioTracks()[0]
diff --git a/core/renderer/settings/sections/DictationPage.tsx b/core/renderer/settings/sections/DictationPage.tsx
index 0f48b825..cf716421 100644
--- a/core/renderer/settings/sections/DictationPage.tsx
+++ b/core/renderer/settings/sections/DictationPage.tsx
@@ -133,7 +133,9 @@ function ModelRow({
   )
 }
 
-export function DictationPage(): JSX.Element | null {
+/** `after`: a host's own rows at the foot of the page (Prism Terminal's
+ *  "Dictate from any app", 2026-10-16). */
+export function DictationPage({ after }: { after?: ReactNode } = {}): JSX.Element | null {
   const d = useDictationState()
   const [micProblem, setMicProblem] = useState<string | null>(null)
   if (!d.host || !d.api) return null
@@ -271,6 +273,7 @@ export function DictationPage(): JSX.Element | null {
           </div>
         </SettingsSection>
       )}
+      {after}
       {d.asking && (
         <ModelDownloadAsk
           text={LIMITED_LANGUAGES_TEXT}
diff --git a/core/shared/termVersion.ts b/core/shared/termVersion.ts
index 47dbab23..9a8da5a4 100644
--- a/core/shared/termVersion.ts
+++ b/core/shared/termVersion.ts
@@ -7,5 +7,5 @@
  * so a core release that bumps `core/package.json` (or xterm) without this
  * fails `npm test` (core/README.md, "Releasing the core").
  */
-export const TERM_CORE_VERSION = '0.42.0'
+export const TERM_CORE_VERSION = '0.43.0'
 export const XTERM_VERSION = '6.0.0'
diff --git a/docs/regression-rules.md b/docs/regression-rules.md
index 2073e050..2c3d1b30 100644
--- a/docs/regression-rules.md
+++ b/docs/regression-rules.md
@@ -187,6 +187,13 @@ one-liner in `CLAUDE.md` only if it is among the most important.
   Claude Code prompt (`src/main/orchestratorSend.ts`): only from the promoted tab, only into a tab whose Claude is
   running (never a bare shell, where it would run), never while that tab asks a question (it would answer it), as
   one sanitised bracketed paste and then Enter (rule 1). Held by `orchestratorSend.test.ts` and the e2e `catchUp`.
+  **The same exception carries dictation from any app** (owner, 2026-10-16: the widget lists the sessions and "you
+  essentially just click or pick the session", or with an active orchestrator it is sent there): the words go
+  through the same checked path (`sessionsWire` `sendInto`), into a running Claude only. Inside the app dictation
+  still only pastes at the cursor and never presses Enter. Held by `dictateAnywhere.test.ts` and the e2e
+  `dictateAnywhere`. Since 2026-10-17 the key reaches dictation in the app through the same hook, and a pick
+  can name another copy of the app's tab: that copy types it through its own checked path (`dictationLink`),
+  and words for a copy whose window was in front are still only pasted, never entered (e2e `dictateTwoCopies`).
 - <a id="same-command-line"></a>**EVERY SHELL OF A KIND STARTS WITH THE SAME COMMAND LINE, AND NO POWERSHELL IS
   `-EncodedCommand`** (#180; owner, 2026-10-11: "slow on startup and not responding until Claude sessions load").
   Windows Defender judges each NEW command line a process from `PrismTerminal.exe` starts, inside `CreateProcess`,
diff --git a/docs/superpowers/specs/2026-10-16-dictate-anywhere.md b/docs/superpowers/specs/2026-10-16-dictate-anywhere.md
new file mode 100644
index 00000000..85cca95a
--- /dev/null
+++ b/docs/superpowers/specs/2026-10-16-dictate-anywhere.md
@@ -0,0 +1,144 @@
+# Dictate from anywhere, and send it to a session (spec + plan)
+
+Owner, 2026-10-16: "you can start the dictation while not having the app in focus. And you should be
+able to set the key bind for the dictation ... when you start the dictation outside the app you
+should still see like a sort of widget ... on the screen in whatever window you're in just to know
+that you're like actually dictating ... if you don't have an orchestrator after you speak ... the
+widget will show like a list of sessions and you essentially just click or pick the session ...
+if you have the orchestrator the widget will just show something like completed with a check mark
+and sent ... that's only if the orchestrator is actually active not just that you have the setting
+turned on." Then: "there will just be one dictation key, but we'll change it from right Alt to
+Control plus the Windows key", the session list also takes number keys ("an excellent idea").
+
+Builds on PR #244 (the orchestrator: the ledger's live tabs, the app typing into a tab's Claude
+prompt with its checks). Stacked on its branch; it merges after #244. Voice wake phrase and the rest
+of #179 stay out.
+
+## What the owner gets
+
+- **One dictation key, Ctrl+Windows by default** (was right Alt, which is AltGr on the owner's
+  Norwegian keyboard). Still settable in Settings > Dictation, hold-to-talk or press-to-toggle as
+  today. A saved right Alt choice is kept for a user who set it; only the DEFAULT changes.
+- **With Prism Terminal in front**: exactly as today (the text is pasted at the cursor of the tab in
+  front, never Enter).
+- **With any other app in front**: the same key starts dictation, and a small widget appears on the
+  screen the pointer is on, above every window, never taking focus: a listening state with the
+  live words, then the outcome.
+- **When the speaking ends**:
+  - **Orchestrator ACTIVE** (a tab is promoted, Claude is running in it per Windows' process list,
+    and it is not waiting on a question): the text is sent to the orchestrator; the widget shows a
+    check mark, "Sent to <orchestrator tab>", and fades after 2 s.
+  - **Otherwise**: the widget lists the tabs where Claude is running, numbered 1 to 9 (label, folder
+    and state). A click or the number key sends the text there; the widget shows the check mark and
+    "Sent to <tab>". Esc, or 30 s with no pick, drops it ("Not sent"). A tab waiting on a question
+    is listed but disabled ("answer its question first").
+  - Nothing heard: "Nothing heard", no list.
+- Settings > Dictation gets **"Dictate from any app"** (on by default when dictation is on).
+
+## Design
+
+### 1. The key, everywhere (a global key listener)
+
+Windows' own global shortcuts (`RegisterHotKey`, Electron's `globalShortcut`) cannot see a chord made
+only of modifiers, nor a key being HELD and released, both of which hold-to-talk on Ctrl+Win needs.
+So a low-level keyboard hook (`WH_KEYBOARD_LL`) runs while the setting is on:
+
+- It reports ONLY the configured chord's down and up, and, while the picker is open, the digits
+  1 to 9 and Esc. Every other key passes untouched and is never read, logged or kept.
+- While the picker is open it SWALLOWS the digits and Esc (they must not also type into the app in
+  front), and nothing else, ever.
+- **The Start menu**: releasing Win after a Win chord can open Start. The hook masks it the way
+  AutoHotkey does: a harmless unassigned key event (VK 0xE8) just before Win's up.
+- When Prism Terminal is focused the hook stays silent: the page's own key handling (today's
+  `reduceKey`) keeps the in-app behaviour exactly.
+
+**Where the hook lives, decided by a measured spike (plan step 1)**:
+- (a) a long-lived Windows PowerShell helper with an `Add-Type` C# hook and a message loop, like the
+  existing DWM helper (`src/main/dwmHelper.ts`): no new dependency;
+- (b) `uiohook-napi`, an in-process native addon: a new runtime dependency and a native module.
+
+Measured for each: key-to-event latency (target under 30 ms), CPU at rest, whether Windows Defender
+flags or slows it (a PowerShell keyboard hook can look like a keylogger to antivirus; that would
+rule (a) out for a product for others), startup cost. The owner hears the result before step 2.
+
+### 2. The widget (an overlay window)
+
+A second BrowserWindow: frameless, transparent, `focusable: false`, `skipTaskbar`, always on top at
+the screen-saver level, shown inactive (`showInactive`) on the display under the pointer, bottom
+centre above the taskbar. Sandboxed like the main window (rule 4), its own small page, no node.
+Sized for the owner at 225% zoom: large type, high-contrast inks from the theme (rule 15's floor).
+States: listening (a level meter and the live words), working ("Transcribing"), picking (the
+numbered list), sent (check mark), not sent / nothing heard / error. A click on a list row works
+without the window taking focus. It closes itself after the outcome.
+
+### 3. Recording while the app is in the background
+
+The capture stays in the main window's page (it already runs with `backgroundThrottling: false`),
+started by main on the global key; the page streams level and live words to main, which forwards
+them to the widget. Measured in step 1 that capture starts within the same time as in front.
+Media pause (Sonara and the system media key) behaves as today.
+
+### 4. Sending
+
+The same path as the orchestrator's sends (`orchestratorSend.ts` checks, Windows' process check,
+decided again right before typing and before Enter), with the widget as the caller instead of the
+orchestrator tab's script. Recorded as part of the owner's exception to rule 2: dictated text goes
+only into a tab whose Claude is running, never a shell, never into an open question. Dictation never
+pressed Enter before; it does here, because the owner asked for "sent", and only in this route
+(outside the app). Inside the app nothing changes.
+
+The orchestrator is ACTIVE when: the Orchestrator switch is on, a tab is promoted, Windows says
+Claude runs under it, and it is not asking. Anything less falls back to the picker.
+
+## Measured (2026-10-16)
+
+- **The hook, option (a) won**: a Windows PowerShell helper with an `Add-Type` C# `WH_KEYBOARD_LL` hook
+  and a message loop. Key to hook: **0.3 to 1.2 ms** (QPC on both sides, 10 software taps of F24, a key
+  no app uses); ready in about 0.35 s; 0.03 s of CPU over 10 s at rest; **no Windows Defender
+  detection** (`Get-MpThreatDetection` before and after). Option (b), a native addon, was not needed.
+- **The Start menu mask** (VK 0xE8 before Win's up after Ctrl+Win) is built; it needs the real Win key,
+  so it is on the owner's hands-on list.
+
+## Decisions (mine, defaults; the owner can change them)
+
+- Default key Ctrl+Win, hold-to-talk (today's default mode).
+- "Dictate from any app" on by default whenever dictation is on.
+- The picker lists only tabs with a running Claude; the orchestrator tab is listed first when
+  present but not active.
+- The widget shows the transcribed text before it is sent, so a wrong pick can be seen.
+
+## Edge cases
+
+| Case | Behaviour |
+|---|---|
+| Win+L, Win+D, Ctrl+Win+arrows while held | The chord is Ctrl+Win alone: another key pressed with it cancels the dictation and passes through, so desktop switching still works. |
+| Start menu opening on release | Masked (VK 0xE8 before Win up); measured in step 1. |
+| Prism Terminal minimised or closed to tray | There is no tray (scope); minimised still works. App not running: nothing (no resident process, rule 7). |
+| Two monitors | The widget opens on the display under the pointer. |
+| Full-screen game or video | Above it at the screen-saver level; never takes focus. |
+| A tab closes between the list and the pick | The send is decided again at the pick: "Not sent: that tab has closed". |
+| The orchestrator is mid-question | Not active: the picker shows, its row disabled. |
+| No Claude running anywhere | "No Claude session to send to", the text kept in the widget for 10 s. |
+| Antivirus flags the hook | Measured in the spike; if Defender flags (a), (b) is used. |
+| Digits pressed while the picker is NOT open | Never swallowed. |
+| Elevated (admin) app in front | A low-level hook does not see keys sent to elevated windows unless the app is elevated: the key does nothing there. Said in Settings' tooltip. |
+| Privacy | Only the chord, digits and Esc while picking are read; nothing is written anywhere. PRIVACY.md says so. |
+
+## Plan
+
+1. **Spike, measured**: both hook options (latency, CPU, Defender, Start masking, startup); capture
+   started from the background. Report to the owner, pick one.
+2. **Core: the key**: `DEFAULT_HOTKEY` to Ctrl+Win (`MetaLeft` with ctrl), the settings key picker
+   records a modifier-only chord, a stored right Alt kept; `reduceKey` tests for the chord.
+3. **App: the hook** (the chosen option) behind a small module with a pure event reducer
+   (`globalDictKey.ts`: chord down/up, digits, Esc, cancel on another key), started and stopped by
+   the setting, never when the app is focused.
+4. **App: the widget** window and page (impeccable), its states, sizes for 225% zoom; IPC
+   main <-> widget <-> page.
+5. **The route**: orchestrator active? send : picker; the shared send path; the outcomes.
+6. **Settings + docs**: "Dictate from any app", the key's sub-text, PRIVACY.md, the rule 2
+   exception's entry, docs/two-apps.md (the key default is core, so Prism gets Ctrl+Win too).
+7. **Verify**: unit (reducer, route, picker), e2e (a simulated global key event through the
+   module's test seam: widget opens unfocused, picker numbers, sent), a real run on this PC with
+   Notepad in front, screenshots of every widget state, full e2e.
+8. Versions: core minor (the key default), app minor.
diff --git a/docs/superpowers/specs/2026-10-17-one-dictation.md b/docs/superpowers/specs/2026-10-17-one-dictation.md
new file mode 100644
index 00000000..c436b63d
--- /dev/null
+++ b/docs/superpowers/specs/2026-10-17-one-dictation.md
@@ -0,0 +1,78 @@
+# One dictation: the same in the app and outside, one engine for every copy (spec + plan)
+
+Owner, 2026-10-17, after trying PR #246 on Stable: "the dictation in the app and outside seem like two
+different things, and at least the one in the app is very unresponsive, they should be the same thing
+for the most part. also when you have two instances of pt open, there should be one dictation engine
+for both, not one engine choosing one of the instances. when you then dictate and it finishes, it
+should show all sessions open in one ui from both instances of pt". And: "It needs to be ready at all
+times. Look at for example, open whisper ... mainly the responsiveness and the stability of it".
+
+## What was measured (Stable diag log, 2026-10-17)
+
+- After a restart, the first presses did nothing: no dictation event at all until one finally started.
+- One recording stayed open for 100 s while the owner pressed and held the key to stop it.
+- Neither case left a trace, because the in-app key path logs only phase changes, never the key.
+- Today there are TWO key paths: the page reads the key while the app is in front (its own reducer,
+  its pill), and the keyboard hook reads it everywhere else (a second reducer in main, the widget).
+  They can disagree about what is held, and a press near a focus change lands in one, the other, or
+  both.
+
+## What the owner gets
+
+- **One key path.** The keyboard hook reads the dictation key everywhere, the app in front included.
+  One reducer decides start and stop. The page no longer reads the key in Prism Terminal (Prism, which
+  has no hook, keeps reading it in its own window as today).
+- **One widget.** The same widget shows in the app and outside: listening with the live words, then
+  the outcome. What happens to the words stays as today:
+  - a Prism Terminal window in front: pasted at the cursor of its front tab, no Enter;
+  - any other app in front: the active orchestrator, or the list of sessions to pick from.
+- **One engine for every copy.** The first copy started runs the dictation service: the key, the mic,
+  the speech engine and the widget. Every other copy connects to it and tells it its tabs. When the
+  service's copy closes, the next copy takes over within a second (the lock file from #246).
+- **One list.** The picker shows the Claude sessions of every copy, each row saying which copy (for
+  example "Stable") when more than one is open. Picking sends it through that copy's own checked path
+  (Windows' process check, decided again before typing and before Enter).
+- **Ready at all times.**
+  - The speech engine is started with the app and kept warm while dictation is on (no idle stand-down).
+  - The start sound plays the moment the key is recognised, before the mic is open, so a press is
+    always answered.
+  - The widget shows "Starting" until the mic is open, then "Listening". (Words spoken before the
+    mic is open can only be kept if the mic stays open: see the open question.)
+- **Every key decision is logged** (the binding's keys only, never other keys or typed text), so a
+  press that did nothing says why in the diag log.
+
+## Design
+
+1. **The service** lives in the main process of the copy that holds the lock. It runs the hook
+   helper, the one reducer (`globalDictKey` feed), and the widget window. Capture and transcription
+   stay in that copy's page, as today; main drives it.
+2. **The link between copies**: a named pipe owned by the service (`\\.\pipe\prism-terminal-dictation-<user>`).
+   A client copy sends its tab list (id, label, folder, agent state, orchestrator) on every change and
+   answers two requests: "paste this into your front tab" and "send this into tab X". Only copies of
+   Prism Terminal run by the same user can connect (the pipe's security is the user's own).
+3. **Which copy is in front**: the hook already says when a Prism Terminal window is in front; it will
+   also say WHICH (its process id), so the service sends an in-app paste to that copy.
+4. **Prism** is unchanged: it embeds the core, has no hook, and keeps its in-window dictation. The core
+   keeps `armDictation` for it; Prism Terminal stops calling it.
+
+## Plan
+
+1. Key logging first (main and page), installed to Stable, so the unresponsive presses are explained
+   before anything moves.
+2. Service and lock: the copy holding the lock starts the service; the others become clients.
+3. Pipe protocol: tab lists, paste, send; tests for each message and for a copy closing mid-pick.
+4. One key path: the in-app press goes through the hook; the page's own listener off in Prism
+   Terminal; the widget in the app too.
+5. Ready at all times: engine kept warm, the cue on recognition, "Starting" until the mic is open;
+   measure how long the mic takes to open (the DJI Mic Mini and the default).
+6. The picker across copies, with the copy's name on each row when more than one is open.
+7. Verify: unit tests, e2e with two copies (the second copy's tabs in the list, a pick sent to it, the
+   service handed over when the first closes), a real run on this PC, the full e2e.
+8. Docs: PRIVACY.md (the pipe, local only), regression rules, two-apps (Prism unchanged).
+   Versions: core minor if the core changes, app minor.
+
+## Owner decisions (2026-10-17)
+
+- The plan: "Yes, build it". On PR #246.
+- **The mic opens on each press** (owner chose it over keeping it open, which would have shown
+  Windows' microphone icon the whole time).
diff --git a/docs/two-apps.md b/docs/two-apps.md
index 848f496c..b2bfb9ab 100644
--- a/docs/two-apps.md
+++ b/docs/two-apps.md
@@ -542,6 +542,20 @@ so an update never silently changes what an existing user sees; the bridge to ma
   outline and rule; `orchestrator-tab.txt` names it for the role hook) and the Settings row. Prism
   passes no orchestrator folder, so nothing changes there until the owner wires it. A terminal
   plugin system (#118) may take it over later (owner: "we'll move it to a plug-in later perhaps").
+- <a id="dictate-anywhere"></a>**DICTATION'S KEY IS CTRL+WIN, AND PRISM TERMINAL DICTATES FROM ANY APP** (owner, 2026-10-16:
+  "one dictation key ... control plus the windows key"; spec `docs/superpowers/specs/2026-10-16-dictate-anywhere.md`).
+  In the core, so BOTH apps change: `DEFAULT_HOTKEY` is Ctrl+Win (right Alt is AltGr on a Norwegian keyboard), a
+  chord of modifiers follows the solo rules (either key first; Ctrl+Win+Left is no dictation), a saved key is kept;
+  `dictationOutside` / `setDictationRoute` let a host start a recording that belongs to no tab and take what was
+  heard; `DictationPage` takes `after` rows. In Prism Terminal's app code only: the keyboard hook helper
+  (`src/main/hook/appHelper.ps1`, the app's one helper since 2026-10-17, which also sets the DWM attributes; `globalDictKey.ts`), the widget window (`dictateAnywhere.ts`,
+  `src/renderer/overlay.html`), the routing and the Settings row. Prism keeps dictating in its own window only.
+  **ONE DICTATION** (owner, 2026-10-17: "they should be the same thing ... one dictation engine for both";
+  spec `docs/superpowers/specs/2026-10-17-one-dictation.md`): in Prism Terminal the hook reads the key with the app
+  in front too, and the copy holding the hook's lock runs the dictation for every copy (`src/main/dictationLink.ts`,
+  a local pipe). Core additions, all off unless a host asks, so Prism is unchanged: `setDictationPageKeys`,
+  `setDictationAutoWarm`, `keepDictationWarm`, `pasteIntoFront` (core `dictation.ts`) and `idleMs` on
+  `registerDictationIpc` (Prism Terminal passes Infinity: "It needs to be ready at all times").
 - <a id="page-looks-right"></a>**A PAGE THAT WORKS IS NOT A PAGE THAT LOOKS RIGHT** (#20, 2026-09-19). Moving the settings into
   `core/` dropped every Tailwind class used only there (`core/` is outside the scanned root; the fix
   is the `@source` line at the top of `index.css`, do not remove it). All 14 e2e scenarios passed over
diff --git a/electron-builder.yml b/electron-builder.yml
index a338ea10..128125d1 100644
--- a/electron-builder.yml
+++ b/electron-builder.yml
@@ -47,6 +47,13 @@ extraResources:
   # Settings > Agents > Orchestrator is on.
   - from: core/claude-plugin-orchestrator
     to: claude-plugin-orchestrator
+  # The app's one helper (2026-10-17): the DWM attributes and the dictation
+  # key's keyboard hook, in one PowerShell.
+  - from: src/main/hook
+    to: app-helper
+  # The resident Parakeet host (2026-10-17): the model kept loaded.
+  - from: core/dictation-host
+    to: dictation-host
 win:
   icon: build/icon.ico
   executableName: PrismTerminal
diff --git a/electron.vite.config.ts b/electron.vite.config.ts
index 682ca59f..a73e1126 100644
--- a/electron.vite.config.ts
+++ b/electron.vite.config.ts
@@ -12,7 +12,7 @@ export default defineConfig({
   preload: {
     plugins: [externalizeDepsPlugin()],
     resolve: { alias: { '@shared': resolve('src/shared'), '@core': resolve('core') } },
-    build: { rollupOptions: { input: { index: resolve(__dirname, 'src/preload/index.ts') } } }
+    build: { rollupOptions: { input: { index: resolve(__dirname, 'src/preload/index.ts'), overlay: resolve(__dirname, 'src/preload/overlay.ts') } } }
   },
   renderer: {
     root: 'src/renderer',
@@ -24,6 +24,6 @@ export default defineConfig({
       }
     },
     plugins: [react(), tailwindcss()],
-    build: { rollupOptions: { input: { index: resolve(__dirname, 'src/renderer/index.html') } } }
+    build: { rollupOptions: { input: { index: resolve(__dirname, 'src/renderer/index.html'), overlay: resolve(__dirname, 'src/renderer/overlay.html') } } }
   }
 })
diff --git a/package-lock.json b/package-lock.json
index e29f0f8d..1b3d9c45 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "prism-terminal",
-  "version": "0.56.0",
+  "version": "0.57.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "prism-terminal",
-      "version": "0.56.0",
+      "version": "0.57.0",
       "license": "MIT",
       "dependencies": {
         "@xterm/addon-fit": "^0.11.0",
diff --git a/package.json b/package.json
index c93ffe7d..6de117ee 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "prism-terminal",
   "productName": "Prism Terminal",
-  "version": "0.56.0",
+  "version": "0.57.0",
   "description": "A tabbed Windows terminal for AI CLIs.",
   "main": "./out/main/index.js",
   "author": "Max",
diff --git a/src/main/appHelper.test.ts b/src/main/appHelper.test.ts
new file mode 100644
index 00000000..86df8feb
--- /dev/null
+++ b/src/main/appHelper.test.ts
@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest'
+import { mkdtempSync, writeFileSync } from 'fs'
+import { tmpdir } from 'os'
+import { join } from 'path'
+import { appHelperSend, configureAppHelper, onAppHelperLine, stopAppHelper } from './appHelper'
+
+describe('appHelper', () => {
+  // MEASURED in both installed 0.58.0 copies (2026-10-17, owner: "The
+  // dictation only opens inside of Prism Terminal, not outside it"): the page
+  // says its dictation key before the window is shown, which is where the
+  // helper's path is set; `hook 1` went nowhere and was never sent again.
+  it('keeps a line sent before it is configured, and sends it once it is', async () => {
+    const dir = mkdtempSync(join(tmpdir(), 'pt-helper-'))
+    const script = join(dir, 'echo.ps1')
+    writeFileSync(script, 'while ($null -ne ($l = [Console]::In.ReadLine())) { if ($l -eq "quit") { break }; [Console]::Out.WriteLine("got " + $l); [Console]::Out.Flush() }\n')
+    const heard: string[] = []
+    const off = onAppHelperLine((l) => heard.push(l))
+    appHelperSend('hook 1')
+    configureAppHelper(script, null)
+    const until = Date.now() + 15000
+    while (!heard.includes('got hook 1') && Date.now() < until) await new Promise((r) => setTimeout(r, 50))
+    off()
+    stopAppHelper()
+    expect(heard).toContain('got hook 1')
+  }, 20000)
+})
diff --git a/src/main/appHelper.ts b/src/main/appHelper.ts
new file mode 100644
index 00000000..354a64de
--- /dev/null
+++ b/src/main/appHelper.ts
@@ -0,0 +1,119 @@
+import { spawn, type ChildProcess } from 'child_process'
+import { SYS } from '@core/main/sysTools'
+
+/**
+ * THE APP'S ONE HELPER PROCESS (2026-10-17, owner: merge the helpers, "it's
+ * mainly startup performance"). `hook/appHelper.ps1`, one Windows PowerShell
+ * started with the app: the window's DWM attributes (dwmHelper) and the
+ * dictation key's hook (globalDictKey) share it, where each used to start its
+ * own PowerShell (about 65 MB each, MEASURED). Lines in, lines out; whoever
+ * listens filters for its own. If it dies it is started again on the next
+ * line sent, and the ones listening hear that it went.
+ *
+ * -File, not -EncodedCommand (#180): Defender holds an encoded command inside
+ * CreateProcess on main's thread; a script file is the hook's MEASURED launch.
+ */
+
+let script: string | null = null
+let cache: string | null = null
+let proc: ChildProcess | null = null
+const lineListeners = new Set<(line: string) => void>()
+const exitListeners = new Set<() => void>()
+// Lines sent before the script's path is known. The page says its dictation
+// key before the window is shown, which is where the path is set; dropped,
+// `hook 1` was never sent again and the key worked only inside the app
+// (MEASURED in both installed 0.58.0 copies, 2026-10-17).
+const early: string[] = []
+
+/** Where the script is, and where it may cache its compiled code. */
+export function configureAppHelper(path: string, cacheDir: string | null): void {
+  script = path
+  cache = cacheDir
+  for (const line of early.splice(0)) appHelperSend(line)
+}
+
+/** Its command line: one per kind (#180), a script FILE, never -EncodedCommand. */
+export function appHelperArgs(path: string, cacheDir: string | null): string[] {
+  return ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', path, ...(cacheDir ? [cacheDir] : [])]
+}
+
+function ensure(): ChildProcess | null {
+  if (proc && proc.exitCode === null && !proc.killed) return proc
+  if (!script) return null
+  try {
+    const p = spawn(SYS.powershell, appHelperArgs(script, cache), { stdio: ['pipe', 'pipe', 'ignore'], windowsHide: true })
+    proc = p
+    let buf = ''
+    p.stdout?.setEncoding('utf8')
+    p.stdout?.on('data', (d: string) => {
+      buf += d
+      let i
+      while ((i = buf.indexOf('\n')) >= 0) {
+        const line = buf.slice(0, i).trim()
+        buf = buf.slice(i + 1)
+        if (line) for (const l of lineListeners) l(line)
+      }
+    })
+    const gone = (): void => {
+      if (proc !== p) return
+      proc = null
+      for (const l of exitListeners) l()
+    }
+    p.on('exit', gone)
+    p.on('error', gone)
+    // A write to a helper that has just died fails LATER, as an 'error' on
+    // stdin that no try round write() catches; unheard, it is an uncaught
+    // exception in main (code review 2026-09-24, #13).
+    p.stdin?.on('error', gone)
+    return p
+  } catch {
+    proc = null
+    return null
+  }
+}
+
+/** One line to the helper, starting it first if need be. */
+export function appHelperSend(line: string): void {
+  if (!script) {
+    if (early.length < 64) early.push(line)
+    return
+  }
+  const p = ensure()
+  try {
+    p?.stdin?.write(line + '\n')
+  } catch {
+    proc = null
+  }
+}
+
+export function onAppHelperLine(fn: (line: string) => void): () => void {
+  lineListeners.add(fn)
+  return () => lineListeners.delete(fn)
+}
+
+export function onAppHelperExit(fn: () => void): () => void {
+  exitListeners.add(fn)
+  return () => exitListeners.delete(fn)
+}
+
+/** Start it now, so the first call is not the start. */
+export function warmAppHelper(): void {
+  ensure()
+}
+
+export function stopAppHelper(): void {
+  const p = proc
+  proc = null
+  try {
+    p?.stdin?.end('quit\n')
+  } catch {
+    /* gone */
+  }
+  setTimeout(() => {
+    try {
+      p?.kill()
+    } catch {
+      /* gone */
+    }
+  }, 1000).unref()
+}
diff --git a/src/main/dictateAnywhere.test.ts b/src/main/dictateAnywhere.test.ts
new file mode 100644
index 00000000..982c1c2c
--- /dev/null
+++ b/src/main/dictateAnywhere.test.ts
@@ -0,0 +1,128 @@
+import { describe, expect, it, vi } from 'vitest'
+
+// A window whose every method is a no-op: enough for the widget to "show".
+vi.mock('electron', () => {
+  const noop = (): unknown => new Proxy(() => {}, { get: (_t, k) => (k === 'then' ? undefined : k === 'isLoading' || k === 'isVisible' || k === 'isDestroyed' ? () => false : noop()), apply: () => undefined })
+  class BrowserWindow {
+    constructor() {
+      return noop() as BrowserWindow
+    }
+  }
+  const area = { workArea: { x: 0, y: 0, width: 1920, height: 1080 } }
+  return { BrowserWindow, screen: { getCursorScreenPoint: () => ({ x: 0, y: 0 }), getDisplayNearestPoint: () => area } }
+})
+
+import { decideInto, dictationRoute, type SendTab } from './orchestratorSend'
+import { folderTail, mergeTabs, pickRows, startDictateAnywhere } from './dictateAnywhere'
+
+/**
+ * Where dictated words go from outside the app (owner, 2026-10-16): to the
+ * orchestrator "only if the orchestrator is actually active", else the
+ * numbered list of Claude sessions.
+ */
+
+const tab = (over: Partial<SendTab>): SendTab => ({
+  id: 'p1',
+  tab: 't1',
+  label: 'Wind',
+  cwd: 'C:\\src\\wind',
+  agent: 'claude',
+  state: null,
+  orchestrator: false,
+  session: 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa',
+  ...over
+})
+
+describe('dictationRoute', () => {
+  it('goes to the orchestrator when it is switched on, promoted and its Claude can take it', () => {
+    const lead = tab({ id: 'p0', label: 'Lead', orchestrator: true })
+    expect(dictationRoute([lead, tab({})], true)).toEqual({ lead })
+  })
+  it('lists the sessions when the orchestrator is not ACTIVE: switched off, asking, or no Claude in it', () => {
+    const lead = tab({ id: 'p0', label: 'Lead', orchestrator: true })
+    for (const [tabs, on] of [
+      [[lead, tab({})], false],
+      [[{ ...lead, state: 'question' }, tab({})], true],
+      [[{ ...lead, agent: null, session: null }, tab({})], true]
+    ] as Array<[SendTab[], boolean]>) {
+      const r = dictationRoute(tabs, on)
+      expect('pick' in r).toBe(true)
+    }
+  })
+  it('lists only tabs with a Claude, the orchestrator first, nine at most', () => {
+    const many = Array.from({ length: 12 }, (_, i) => tab({ id: `p${i}`, label: `t${i}` }))
+    const r = dictationRoute([tab({ id: 'sh', agent: null, session: null }), ...many, tab({ id: 'L', orchestrator: true, state: 'question' })], true)
+    expect('pick' in r && r.pick.map((t) => t.id)).toEqual(['L', 'p0', 'p1', 'p2', 'p3', 'p4', 'p5', 'p6', 'p7'])
+  })
+})
+
+describe('the key with a Prism Terminal in front', () => {
+  // MEASURED 2026-10-17: Stable and the installed app both took every press.
+  const started = () => {
+    const toPage = vi.fn()
+    const handlers: Record<string, (...a: unknown[]) => void> = {}
+    const a = startDictateAnywhere({
+      preload: '', loadPage: () => {}, mainWindow: () => null, sessions: () => null, toPage, selfPid: 1,
+      onIpc: (ch, fn) => {
+        handlers[ch] = fn
+      },
+      channels: { anywhere: 'a', live: 'l', routed: 'r', look: 'k' },
+      e2e: true
+    })
+    handlers['a']({ on: true, hotkey: { code: 'F8', ctrl: false, alt: false, shift: false, meta: false }, mode: 'toggle' })
+    return { a, toPage }
+  }
+  it('leaves it to that window when another copy of the app, not on the link, is in front', () => {
+    const { a, toPage } = started()
+    a.line({ kind: 'key', type: 'down', code: 'F8', front: 4242 })
+    a.line({ kind: 'key', type: 'up', code: 'F8' })
+    expect(toPage).not.toHaveBeenCalled()
+  })
+  // One key path (owner, 2026-10-17): the app's own window is read here too.
+  it('starts with this copy in front', () => {
+    const { a, toPage } = started()
+    a.line({ kind: 'key', type: 'down', code: 'F8', front: 1 })
+    a.line({ kind: 'key', type: 'up', code: 'F8' })
+    expect(toPage).toHaveBeenCalledWith('start')
+  })
+  it('starts with any other app in front', () => {
+    const { a, toPage } = started()
+    a.line({ kind: 'key', type: 'down', code: 'F8' })
+    a.line({ kind: 'key', type: 'up', code: 'F8' })
+    expect(toPage).toHaveBeenCalledWith('start')
+  })
+})
+
+describe('mergeTabs', () => {
+  it('lists every copy, naming the copy only when there is more than one', () => {
+    expect(mergeTabs([tab({})], [], 'Stable').map((t) => [t.id, t.copy])).toEqual([['p1', null]])
+    const two = mergeTabs([tab({})], [{ copy: { pid: 9, name: 'Prism Terminal' }, tabs: [tab({ id: 'q1' })] }], 'Stable')
+    expect(two.map((t) => [t.id, t.copy])).toEqual([
+      ['p1', 'Stable'],
+      ['9:q1', 'Prism Terminal']
+    ])
+  })
+})
+
+describe('pickRows', () => {
+  it('numbers the rows and disables a tab that is asking', () => {
+    const rows = pickRows([tab({ orchestrator: true }), tab({ id: 'p2', label: 'Web', cwd: 'C:\\a\\b\\web', state: 'question' })])
+    expect(rows.map((r) => [r.n, r.label, r.folder, !!r.disabled, r.lead])).toEqual([
+      [1, 'Wind', 'src\\wind', false, true],
+      [2, 'Web', 'b\\web', true, false]
+    ])
+  })
+  it('shows a folder by its last two parts', () => {
+    expect(folderTail('C:\\Users\\me\\code\\api')).toBe('code\\api')
+    expect(folderTail('/home/me/api/')).toBe('me\\api')
+  })
+})
+
+describe('decideInto', () => {
+  it('sends to the picked tab only while its Claude can take it', () => {
+    expect(decideInto('p1', [tab({})])).toMatchObject({ ok: true })
+    expect(decideInto('gone', [tab({})])).toEqual({ ok: false, reason: 'that tab has closed' })
+    expect(decideInto('p1', [tab({ state: 'question' })])).toMatchObject({ ok: false })
+    expect(decideInto('p1', [tab({ agent: null, session: null })])).toMatchObject({ ok: false })
+  })
+})
diff --git a/src/main/dictateAnywhere.ts b/src/main/dictateAnywhere.ts
new file mode 100644
index 00000000..c4bd87f2
--- /dev/null
+++ b/src/main/dictateAnywhere.ts
@@ -0,0 +1,401 @@
+import { BrowserWindow, screen } from 'electron'
+import type { Hotkey, DictMode } from '@core/renderer/lib/dictationKey'
+import { OVERLAY_CH, type OverlayLook, type OverlayRow, type OverlayState } from '@shared/dictOverlay'
+import { createKeyFeed, keysFor, masksStart, startKeyHelper, type HelperLine, type KeyHelper } from './globalDictKey'
+import type { Sessions } from './sessionsWire'
+import { dictationRoute, type SendDecision, type SendTab } from './orchestratorSend'
+import { startLinkClient, startLinkService, type LinkService } from './dictationLink'
+
+/**
+ * DICTATE FROM ANY APP (owner, 2026-10-16; spec:
+ * docs/superpowers/specs/2026-10-16-dictate-anywhere.md). With another app in
+ * front, the dictation key (globalDictKey) starts a recording in the page
+ * (core `dictationOutside`), the widget shows it, and what was heard goes to
+ * the orchestrator when it is ACTIVE, or to the session the owner picks from
+ * the widget (a click or its number). Sent through the same checked path as
+ * the orchestrator's sends (sessionsWire.sendInto).
+ *
+ * ONE DICTATION (owner, 2026-10-17; spec:
+ * docs/superpowers/specs/2026-10-17-one-dictation.md): the hook reads the key
+ * with the app in front too, so there is one key path and one widget. The
+ * copy whose helper holds the lock is the SERVICE: it records, and every
+ * other copy is a CLIENT on the link (dictationLink), its page not reading
+ * the key. The words go to the copy whose window was in front at the press
+ * (pasted at its front tab's cursor, no Enter, as dictation in the app always
+ * did), else to the active orchestrator or the list, which holds the tabs of
+ * every copy.
+ */
+
+/** service: this copy runs the dictation. client: another copy does, and this
+ *  one answers on the link. none: no other copy; the page reads its own key. */
+export type Role = 'none' | 'service' | 'client'
+
+export interface AnywhereConfig {
+  on: boolean
+  hotkey: Hotkey
+  mode: DictMode
+}
+
+export type RouteResult = { text: string } | { message: string }
+export interface LiveView {
+  phase: 'listening' | 'transcribing' | 'idle'
+  text: string
+  level: number
+  starting: boolean
+}
+
+export interface AnywhereDeps {
+  preload: string
+  loadPage: (w: BrowserWindow) => void
+  mainWindow: () => BrowserWindow | null
+  sessions: () => Sessions | null
+  /** Tell the page to start, stop or cancel the outside recording. */
+  toPage: (action: 'start' | 'stop' | 'cancel') => void
+  onIpc: (channel: string, fn: (...args: unknown[]) => void) => void
+  channels: { anywhere: string; live: string; routed: string; look: string }
+  /** This copy's main process id: what the hook names when its window is in front. */
+  selfPid?: number
+  /** The pipe every copy of the app meets on, the user's link key, and this
+   *  copy's name; null: this copy alone. */
+  link?: { pipe: string; key: Buffer; name: string } | null
+  /** The page's part: it reads the key itself only with no service in reach. */
+  pageRole?: (role: Role) => void
+  /** Paste into this copy's front tab (its window was in front at the press). */
+  pastePage?: (text: string) => void
+  /** A diag crumb (never a key but the binding's; never typed text). */
+  log?: (what: Record<string, unknown>) => void
+  /** Under --e2e: no real hook; `line` is the only way keys arrive. */
+  e2e?: boolean
+}
+
+const WIDTH = 480
+const PICK_MS = 30_000
+const SHOW_MS = 2200
+
+/** The last two folders of a path: enough to tell two `api` tabs apart. */
+export const folderTail = (p: string): string => p.split(/[\\/]+/).filter(Boolean).slice(-2).join('\\')
+
+/** A tab as the list holds it: `copy` names the copy of the app it is in,
+ *  when more than one is open. A tab of another copy has the id `<pid>:<id>`. */
+export type ListTab = SendTab & { copy?: string | null }
+
+/** The picker's rows: numbered 1 to 9, a tab that is asking disabled. */
+export function pickRows(tabs: readonly ListTab[]): OverlayRow[] {
+  return tabs.slice(0, 9).map((t, i) => ({
+    id: t.id,
+    n: i + 1,
+    label: t.label,
+    folder: folderTail(t.cwd),
+    state: t.state,
+    disabled: t.state === 'question' ? 'Waiting on a question: answer it there first' : null,
+    lead: t.orchestrator,
+    copy: t.copy ?? null
+  }))
+}
+
+/** This copy's tabs and every linked copy's, as one list. */
+export function mergeTabs(local: readonly SendTab[], remote: readonly { copy: { pid: number; name: string }; tabs: readonly SendTab[] }[], me: string): ListTab[] {
+  const many = remote.length > 0
+  return [
+    ...local.map((t) => ({ ...t, copy: many ? me : null })),
+    ...remote.flatMap((r) => r.tabs.map((t) => ({ ...t, id: `${r.copy.pid}:${t.id}`, copy: r.copy.name })))
+  ]
+}
+
+export function startDictateAnywhere(d: AnywhereDeps): {
+  stop(): void
+  line(l: HelperLine): void
+  /** What a recording heard, as if it began with copy `front`'s window in front (the e2e's seam). */
+  route(r: RouteResult, front: number | null): void
+} {
+  let cfg: AnywhereConfig | null = null
+  let helper: KeyHelper | null = null
+  let outside = false
+  let tick: ReturnType<typeof setTimeout> | null = null
+  let picking: { text: string; rows: OverlayRow[]; timer: ReturnType<typeof setTimeout> } | null = null
+  let hideTimer: ReturnType<typeof setTimeout> | null = null
+  let look: OverlayLook | null = null
+  let win: BrowserWindow | null = null
+  const selfPid = d.selfPid ?? process.pid
+  let role: Role = 'none'
+  let svc: LinkService | null = null
+  let client: { close(): void } | null = null
+  /** The copy whose window was in front at the last binding key down. */
+  let lastFront: number | null = null
+  /** ... and at the press that started the recording. */
+  let recFront: number | null = null
+
+  const feed = createKeyFeed(() => ({ hotkey: cfg!.hotkey, mode: cfg!.mode }))
+
+  /* ----- the widget ----- */
+  const ensure = (): BrowserWindow => {
+    if (win && !win.isDestroyed()) return win
+    win = new BrowserWindow({
+      width: WIDTH,
+      height: 200,
+      frame: false,
+      transparent: true,
+      resizable: false,
+      movable: false,
+      minimizable: false,
+      maximizable: false,
+      fullscreenable: false,
+      focusable: false,
+      skipTaskbar: true,
+      alwaysOnTop: true,
+      hasShadow: false,
+      show: false,
+      webPreferences: { preload: d.preload, sandbox: true, contextIsolation: true, nodeIntegration: false, backgroundThrottling: false }
+    })
+    // Above full-screen windows too, and on every virtual desktop.
+    win.setAlwaysOnTop(true, 'screen-saver')
+    win.setVisibleOnAllWorkspaces(true)
+    // Rule 4: it never navigates and never opens a window.
+    win.webContents.on('will-navigate', (e) => e.preventDefault())
+    win.webContents.setWindowOpenHandler(() => ({ action: 'deny' }))
+    win.on('closed', () => {
+      win = null
+    })
+    d.loadPage(win)
+    return win
+  }
+  const heightFor = (s: OverlayState): number => (s.phase === 'pick' ? 196 + s.rows.length * 48 : s.phase === 'listening' ? 196 : 104)
+  const show = (s: OverlayState): void => {
+    const w = ensure()
+    if (hideTimer) clearTimeout(hideTimer)
+    hideTimer = null
+    const h = heightFor(s)
+    // On the display the pointer is on, above its taskbar, centred.
+    const wa = screen.getDisplayNearestPoint(screen.getCursorScreenPoint()).workArea
+    w.setBounds({ x: Math.round(wa.x + (wa.width - WIDTH) / 2), y: Math.round(wa.y + wa.height - h - 16), width: WIDTH, height: h })
+    // Clicks pass through to the app behind, except while there is a list to pick from.
+    w.setIgnoreMouseEvents(s.phase !== 'pick')
+    const send = (): void => {
+      if (look) w.webContents.send(OVERLAY_CH.look, look)
+      w.webContents.send(OVERLAY_CH.state, s)
+    }
+    if (w.webContents.isLoading()) w.webContents.once('did-finish-load', send)
+    else send()
+    if (!w.isVisible()) w.showInactive()
+  }
+  const hideAfter = (ms: number): void => {
+    if (hideTimer) clearTimeout(hideTimer)
+    hideTimer = setTimeout(() => {
+      hideTimer = null
+      if (!picking) win?.hide()
+    }, ms)
+  }
+  const note = (message: string, tone: 'quiet' | 'warn' = 'quiet'): void => {
+    outside = false
+    show({ phase: 'note', message, tone })
+    hideAfter(SHOW_MS + 800)
+  }
+
+  /* ----- the copies of the app ----- */
+  const setRole = (r: Role): void => {
+    if (r === role) return
+    role = r
+    d.log?.({ role: r })
+    d.pageRole?.(r)
+  }
+  const becomeClient = (): void => {
+    svc?.close()
+    svc = null
+    if (!d.link) return setRole('none')
+    if (client) return
+    const link = d.link
+    client = startLinkClient(
+      link.pipe,
+      link.key,
+      { pid: selfPid, name: link.name },
+      {
+        tabs: () => d.sessions()?.published() ?? Promise.resolve([]),
+        send: (id, text) => d.sessions()?.sendInto(id, text) ?? Promise.resolve<SendDecision>({ ok: false, reason: 'the app is not ready' }),
+        paste: (t) => d.pastePage?.(t)
+      },
+      1000,
+      (on) => setRole(on ? 'client' : 'none')
+    )
+  }
+  const becomeService = (): void => {
+    client?.close()
+    client = null
+    if (d.link && !svc) svc = startLinkService(d.link.pipe, d.link.key, (e) => d.log?.({ link: String(e).slice(0, 120) }))
+    setRole('service')
+  }
+
+  /* ----- sending ----- */
+  const sendTo = async (id: string, label: string, text: string): Promise<void> => {
+    const s = d.sessions()
+    if (!s) return note('Not sent: the app is not ready', 'warn')
+    show({ phase: 'sending', to: label })
+    // Another copy's tab: that copy types it, through its own checks.
+    const other = /^([0-9]+):(.+)$/.exec(id)
+    const res = other ? (svc ? await svc.send(Number(other[1]), other[2], text) : { ok: false as const, reason: 'that copy of the app has closed' }) : await s.sendInto(id, text)
+    outside = false
+    if (res.ok) {
+      show({ phase: 'sent', to: res.target.label })
+      hideAfter(SHOW_MS)
+    } else note(`Not sent: ${res.reason}`, 'warn')
+  }
+  const endPick = (): void => {
+    if (!picking) return
+    clearTimeout(picking.timer)
+    picking = null
+    helper?.send('pick 0')
+  }
+  const choose = (id: string): void => {
+    const p = picking
+    if (!p) return
+    const row = p.rows.find((r) => r.id === id)
+    if (!row || row.disabled) return
+    endPick()
+    void sendTo(row.id, row.label, p.text)
+  }
+  const routed = async (r: RouteResult): Promise<void> => {
+    const front = recFront
+    recFront = null
+    if ('message' in r) return note(r.message, r.message === 'Cancelled' || r.message === 'Heard nothing' ? 'quiet' : 'warn')
+    // A Prism Terminal window was in front: the words go to its front tab, at
+    // the cursor, never Enter (dictation in the app as it always was).
+    if (front === selfPid && d.pastePage) {
+      d.pastePage(r.text)
+      return note('Typed into the tab in front')
+    }
+    if (front !== null && svc?.paste(front, r.text)) return note('Typed into the tab in front')
+    const s = d.sessions()
+    if (!s) return note('Not sent: the app is not ready', 'warn')
+    const all = mergeTabs(await s.published(), svc ? await svc.tabs() : [], d.link?.name ?? 'Prism Terminal')
+    const where = dictationRoute(all, true)
+    if ('lead' in where) return sendTo(where.lead.id, where.lead.label, r.text)
+    if (!where.pick.length) return note('No Claude session to send to', 'warn')
+    const rows = pickRows(where.pick)
+    endPick()
+    picking = { text: r.text, rows, timer: setTimeout(() => {
+      endPick()
+      note('Not sent')
+    }, PICK_MS) }
+    helper?.send('pick 1')
+    show({ phase: 'pick', text: r.text, rows })
+  }
+
+  /* ----- the key ----- */
+  const act = (a: 'start' | 'stop' | 'cancel' | null): void => {
+    if (!a) return
+    d.log?.({ key: a })
+    if (a === 'start') {
+      endPick()
+      outside = true
+      recFront = lastFront
+      show({ phase: 'listening', text: '', level: 0, starting: false })
+    }
+    d.toPage(a)
+  }
+  const onLine = (l: HelperLine): void => {
+    // A list on screen answers its digits and Esc whatever else changed.
+    if (l.kind === 'digit' || l.kind === 'esc') {
+      if (picking) {
+        if (l.kind === 'esc') {
+          endPick()
+          note('Not sent')
+        } else {
+          const row = picking.rows.find((r) => r.n === l.n)
+          if (row) choose(row.id)
+        }
+        return
+      }
+    }
+    if (l.kind === 'ready' || l.kind === 'failed' || l.kind === 'waiting') {
+      d.log?.({ hook: l.kind })
+      if (l.kind === 'ready') becomeService()
+      else becomeClient()
+      return
+    }
+    if (!cfg?.on) return
+    if (l.kind === 'key' && l.type === 'down') {
+      lastFront = l.front ?? null
+      // Another copy's window, and that copy is not on the link: it reads its
+      // own key, so this one stays out of it.
+      if (lastFront !== null && lastFront !== selfPid && !svc?.copies().some((c) => c.pid === lastFront) && !outside) {
+        feed.reset()
+        d.log?.({ key: 'left to that copy' })
+        return
+      }
+    }
+    const now = performance.now()
+    act(feed.feed(l, now))
+    if (tick) clearTimeout(tick)
+    tick = null
+    if (feed.arming()) tick = setTimeout(() => act(feed.tick(performance.now())), 210)
+  }
+  const apply = (next: AnywhereConfig): void => {
+    const keys = next.on ? keysFor(next.hotkey) : null
+    cfg = { ...next, on: !!keys }
+    feed.reset()
+    // The page says this as it loads: the part it may have missed, again.
+    d.pageRole?.(role)
+    if (!keys) {
+      helper?.stop()
+      helper = null
+      becomeClient()
+      return
+    }
+    if (d.e2e) return
+    helper ??= startKeyHelper(onLine)
+    helper.send(`keys ${keys.map((k) => k.toString(16).toUpperCase()).join(' ')}`)
+    helper.send(`mask ${masksStart(next.hotkey) ? 1 : 0}`)
+  }
+
+  /* ----- the page and the widget talk here ----- */
+  d.onIpc(d.channels.anywhere, (c: unknown) => {
+    const x = c as Partial<AnywhereConfig> | null
+    if (!x || typeof x.hotkey !== 'object' || !x.hotkey || typeof x.hotkey.code !== 'string') return
+    apply({ on: x.on === true, hotkey: x.hotkey as Hotkey, mode: x.mode === 'toggle' ? 'toggle' : 'hold' })
+  })
+  d.onIpc(d.channels.live, (v: unknown) => {
+    const x = v as Partial<LiveView> | null
+    if (!outside || !x) return
+    if (x.phase === 'listening')
+      show({ phase: 'listening', text: typeof x.text === 'string' ? x.text : '', level: Number(x.level) || 0, starting: x.starting === true })
+    else if (x.phase === 'transcribing') show({ phase: 'transcribing' })
+  })
+  d.onIpc(d.channels.routed, (r: unknown) => {
+    const x = r as Partial<{ text: string; message: string }> | null
+    if (!x) return
+    if (typeof x.text === 'string') void routed({ text: x.text.slice(0, 8000) })
+    else if (typeof x.message === 'string') void routed({ message: x.message.slice(0, 200) })
+  })
+  d.onIpc(d.channels.look, (l: unknown) => {
+    const x = l as Partial<OverlayLook> | null
+    const ok = (s: unknown): s is string => typeof s === 'string' && s.length < 64
+    if (x && ok(x.ground) && ok(x.text) && ok(x.dim) && ok(x.accent) && ok(x.edge)) look = x as OverlayLook
+  })
+  d.onIpc(OVERLAY_CH.pick, (id: unknown) => {
+    if (typeof id === 'string') choose(id)
+  })
+  d.onIpc(OVERLAY_CH.dismiss, () => {
+    endPick()
+    win?.hide()
+  })
+
+  // Every copy looks for a service from the start; holding the key makes it one.
+  becomeClient()
+
+  return {
+    line: onLine,
+    route: (r, front) => {
+      recFront = front
+      void routed(r)
+    },
+    stop: () => {
+      helper?.stop()
+      helper = null
+      svc?.close()
+      svc = null
+      client?.close()
+      client = null
+      endPick()
+      if (win && !win.isDestroyed()) win.destroy()
+    }
+  }
+}
diff --git a/src/main/dictationLink.test.ts b/src/main/dictationLink.test.ts
new file mode 100644
index 00000000..ac3c1014
--- /dev/null
+++ b/src/main/dictationLink.test.ts
@@ -0,0 +1,128 @@
+import { mkdtempSync, readFileSync } from 'fs'
+import { tmpdir } from 'os'
+import { join } from 'path'
+import { randomBytes } from 'crypto'
+import { describe, expect, it } from 'vitest'
+import { copyName, linkKey, linkPipe, parseToClient, parseToService, startLinkClient, startLinkService } from './dictationLink'
+import type { SendTab } from './orchestratorSend'
+
+/**
+ * One dictation for every copy of the app (owner, 2026-10-17): the service
+ * asks the other copies for their tabs, and sends or pastes into them. Both
+ * ends prove they hold the user's link key first (security review 2026-10-17).
+ */
+
+const tab = (over: Partial<SendTab> = {}): SendTab => ({
+  id: 'p1',
+  tab: 't1',
+  label: 'Wind',
+  cwd: 'C:\\src\\wind',
+  agent: 'claude',
+  state: null,
+  orchestrator: false,
+  session: 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa',
+  ...over
+})
+const N = 'a'.repeat(32)
+const MAC = 'b'.repeat(64)
+
+describe('the messages', () => {
+  it('reads what a client may say, and nothing else', () => {
+    expect(parseToService(JSON.stringify({ t: 'hello', pid: 42, name: 'Stable', n: N, mac: MAC }))).toEqual({ t: 'hello', pid: 42, name: 'Stable', n: N, mac: MAC })
+    expect(parseToService('{"t":"hello","pid":42,"name":"Stable"}')).toBeNull()
+    expect(parseToService(JSON.stringify({ t: 'tabs', rid: 3, tabs: [tab(), { id: 5 }] }))).toEqual({ t: 'tabs', rid: 3, tabs: [tab()] })
+    expect(parseToService(JSON.stringify({ t: 'sent', rid: 4, res: { ok: false, reason: 'asking' } }))).toEqual({ t: 'sent', rid: 4, res: { ok: false, reason: 'asking' } })
+    expect(parseToService('{"t":"paste","text":"x"}')).toBeNull()
+    expect(parseToService('not json')).toBeNull()
+  })
+  it('reads what the service may say, and caps the text', () => {
+    expect(parseToClient(JSON.stringify({ t: 'nonce', n: N }))).toEqual({ t: 'nonce', n: N })
+    expect(parseToClient(JSON.stringify({ t: 'proof', mac: MAC }))).toEqual({ t: 'proof', mac: MAC })
+    expect(parseToClient('{"t":"tabs?","rid":1}')).toEqual({ t: 'tabs?', rid: 1 })
+    expect(parseToClient('{"t":"paste","text":"hi"}')).toEqual({ t: 'paste', text: 'hi' })
+    expect(parseToClient(JSON.stringify({ t: 'send', rid: 2, id: 'p1', text: 'x'.repeat(9000) }))).toBeNull()
+  })
+  it('names a copy by its exe', () => {
+    expect(copyName('C:\\Users\\a\\AppData\\Local\\PrismTerminalStable\\PrismTerminalStable.exe')).toBe('Stable')
+    expect(copyName('C:\\x\\PrismTerminal.exe')).toBe('Prism Terminal')
+  })
+})
+
+describe('the link key', () => {
+  it('is made once and read back the same, and the pipe is named by its hash, never by it', () => {
+    const file = join(mkdtempSync(join(tmpdir(), 'pt-link-')), 'sub', 'link.key')
+    const a = linkKey(file)
+    expect(a?.length).toBe(32)
+    expect(linkKey(file)?.equals(a!)).toBe(true)
+    expect(readFileSync(file, 'utf8')).toMatch(/^[0-9a-f]{64}$/)
+    expect(linkPipe(a!)).toMatch(/^\\\\\.\\pipe\\prism-terminal-dictation-[0-9a-f]{24}$/)
+    expect(linkPipe(a!)).not.toContain(a!.toString('hex').slice(0, 24))
+  })
+})
+
+const until = async (f: () => boolean): Promise<void> => {
+  for (let i = 0; i < 150 && !f(); i++) await new Promise((r) => setTimeout(r, 20))
+}
+const pipeName = (): string => `\\\\.\\pipe\\pt-dict-test-${process.pid}-${randomBytes(4).toString('hex')}`
+const handlers = (pasted: string[], sent: string[]): Parameters<typeof startLinkClient>[3] => ({
+  tabs: async () => [tab({ id: 'r1', label: 'Sonara' })],
+  send: async (id, text) => {
+    sent.push(`${id}:${text}`)
+    return { ok: true, target: tab({ id, label: 'Sonara' }) }
+  },
+  paste: (t) => pasted.push(t)
+})
+
+describe('the pipe', () => {
+  it('asks a connected copy for its tabs, sends into one, and forgets it when it closes', async () => {
+    const pipe = pipeName()
+    const key = randomBytes(32)
+    const svc = startLinkService(pipe, key)
+    const pasted: string[] = []
+    const sent: string[] = []
+    let trusted = false
+    const client = startLinkClient(pipe, key, { pid: 777, name: 'Stable' }, handlers(pasted, sent), 50, (on) => (trusted = on))
+    await until(() => svc.copies().length === 1 && trusted)
+    expect(trusted).toBe(true)
+    expect(svc.copies()).toEqual([{ pid: 777, name: 'Stable' }])
+    expect(await svc.tabs()).toEqual([{ copy: { pid: 777, name: 'Stable' }, tabs: [tab({ id: 'r1', label: 'Sonara' })] }])
+    expect(await svc.send(777, 'r1', 'hello')).toEqual({ ok: true, target: tab({ id: 'r1', label: 'Sonara' }) })
+    expect(sent).toEqual(['r1:hello'])
+    expect(svc.paste(777, 'typed')).toBe(true)
+    await until(() => pasted.length === 1)
+    expect(pasted).toEqual(['typed'])
+    client.close()
+    await until(() => svc.copies().length === 0)
+    expect(await svc.send(777, 'r1', 'x')).toEqual({ ok: false, reason: 'that copy of the app has closed' })
+    svc.close()
+  })
+
+  it('drops a client that does not hold the key: it is never listed', async () => {
+    const pipe = pipeName()
+    const svc = startLinkService(pipe, randomBytes(32))
+    const client = startLinkClient(pipe, randomBytes(32), { pid: 9, name: 'Impostor' }, handlers([], []), 50)
+    await new Promise((r) => setTimeout(r, 400))
+    expect(svc.copies()).toEqual([])
+    client.close()
+    svc.close()
+  })
+
+  it('never answers, types or pastes for a service that does not hold the key', async () => {
+    const pipe = pipeName()
+    // The impostor: it took the pipe's name, and asks without the key.
+    const fake = startLinkService(pipe, randomBytes(32))
+    const pasted: string[] = []
+    const sent: string[] = []
+    let trusted = false
+    const client = startLinkClient(pipe, randomBytes(32), { pid: 5, name: 'Stable' }, handlers(pasted, sent), 50, (on) => (trusted = on))
+    await new Promise((r) => setTimeout(r, 400))
+    expect(trusted).toBe(false)
+    // Its client list holds nobody, so it cannot even ask; and a client that
+    // got a request before the proof hangs up on it (dictationLink).
+    expect(fake.copies()).toEqual([])
+    expect(sent).toEqual([])
+    expect(pasted).toEqual([])
+    client.close()
+    fake.close()
+  })
+})
diff --git a/src/main/dictationLink.ts b/src/main/dictationLink.ts
new file mode 100644
index 00000000..1076b66e
--- /dev/null
+++ b/src/main/dictationLink.ts
@@ -0,0 +1,333 @@
+import { createHash, createHmac, randomBytes, timingSafeEqual } from 'crypto'
+import { mkdirSync, openSync, readFileSync, writeSync, closeSync } from 'fs'
+import { createServer, connect, type Server, type Socket } from 'net'
+import { dirname } from 'path'
+import type { SendDecision, SendTab } from './orchestratorSend'
+
+/**
+ * ONE DICTATION FOR EVERY COPY OF THE APP (owner, 2026-10-17: "when you have
+ * two instances of pt open, there should be one dictation engine for both ...
+ * it should show all sessions open in one ui from both instances"; spec:
+ * docs/superpowers/specs/2026-10-17-one-dictation.md). The copy whose key
+ * helper holds the lock runs the dictation (the SERVICE); every other copy is
+ * a CLIENT on this pipe: it answers for its own tabs, and pastes or sends
+ * into them through its own checked path when the service asks.
+ *
+ * A local named pipe, one per Windows user; nothing leaves the PC. JSON, one
+ * message per line.
+ *
+ * BOTH ENDS PROVE THEY HOLD THE USER'S LINK KEY before anything else is said
+ * (security review 2026-10-17: a process that took the pipe's name first could
+ * otherwise pose as the service and have a copy type into its Claude). The key
+ * is 32 random bytes in a file under %LOCALAPPDATA% (`linkKey`), which only
+ * the user's own account can read; the pipe is named after its hash, never
+ * the key. Each side sends a fresh nonce and answers the other's with an HMAC:
+ *   service -> client  {t:'nonce', n}
+ *   client -> service  {t:'hello', pid, name, n, mac}     mac = HMAC(key, 'client|' + service n + '|' + n)
+ *   service -> client  {t:'proof', mac}                   mac = HMAC(key, 'service|' + client n + '|' + service n)
+ * A peer that fails is dropped. Then the service asks; a client only answers:
+ *   service -> client  {t:'tabs?', rid}            -> {t:'tabs', rid, tabs}
+ *   service -> client  {t:'send', rid, id, text}   -> {t:'sent', rid, res}
+ *   service -> client  {t:'paste', text}           (into its front tab, no Enter)
+ */
+
+export type ToClient =
+  | { t: 'nonce'; n: string }
+  | { t: 'proof'; mac: string }
+  | { t: 'tabs?'; rid: number }
+  | { t: 'send'; rid: number; id: string; text: string }
+  | { t: 'paste'; text: string }
+export type ToService =
+  | { t: 'hello'; pid: number; name: string; n: string; mac: string }
+  | { t: 'tabs'; rid: number; tabs: SendTab[] }
+  | { t: 'sent'; rid: number; res: SendDecision }
+
+const hex = (v: unknown, len: number): v is string => typeof v === 'string' && v.length === len && /^[0-9a-f]+$/.test(v)
+const NONCE_HEX = 32
+const MAC_HEX = 64
+export const nonce = (): string => randomBytes(NONCE_HEX / 2).toString('hex')
+export const macOf = (key: Buffer, what: string): string => createHmac('sha256', key).update(what).digest('hex')
+function sameMac(a: string, b: string): boolean {
+  const x = Buffer.from(a, 'hex')
+  const y = Buffer.from(b, 'hex')
+  return x.length === y.length && x.length > 0 && timingSafeEqual(x, y)
+}
+
+/**
+ * The user's link key: read, or made once (32 random bytes, hex) with the
+ * file created exclusively, so two copies starting together agree on one.
+ * Null when it can be neither read nor made: then there is no link.
+ */
+export function linkKey(file: string): Buffer | null {
+  const read = (): Buffer | null => {
+    try {
+      const t = readFileSync(file, 'utf8').trim()
+      return /^[0-9a-f]{64}$/.test(t) ? Buffer.from(t, 'hex') : null
+    } catch {
+      return null
+    }
+  }
+  const have = read()
+  if (have) return have
+  try {
+    mkdirSync(dirname(file), { recursive: true })
+    const fd = openSync(file, 'wx')
+    writeSync(fd, randomBytes(32).toString('hex'))
+    closeSync(fd)
+  } catch {
+    /* another copy made it first, or it cannot be made */
+  }
+  return read()
+}
+
+/** The pipe's name: the key's hash, never the key. */
+export function linkPipe(key: Buffer): string {
+  return `\\\\.\\pipe\\prism-terminal-dictation-${createHash('sha256').update(key).digest('hex').slice(0, 24)}`
+}
+
+const MAX_LINE = 64 * 1024
+const MAX_TEXT = 8000
+const str = (v: unknown, max: number): v is string => typeof v === 'string' && v.length <= max
+const int = (v: unknown): v is number => Number.isInteger(v) && (v as number) >= 0
+
+function tabOf(v: unknown): SendTab | null {
+  const t = v as Partial<SendTab> | null
+  if (!t || !str(t.id, 128) || !str(t.tab, 128) || !str(t.label, 256) || !str(t.cwd, 1024)) return null
+  const opt = (x: unknown): string | null => (str(x, 256) ? x : null)
+  return { id: t.id, tab: t.tab, label: t.label, cwd: t.cwd, agent: opt(t.agent), state: opt(t.state), orchestrator: t.orchestrator === true, session: opt(t.session) }
+}
+
+/** A line from a client, checked field by field; anything else is null. */
+export function parseToService(line: string): ToService | null {
+  if (line.length > MAX_LINE) return null
+  let m: Record<string, unknown>
+  try {
+    m = JSON.parse(line) as Record<string, unknown>
+  } catch {
+    return null
+  }
+  if (!m || typeof m !== 'object') return null
+  if (m.t === 'hello' && int(m.pid) && str(m.name, 64) && hex(m.n, NONCE_HEX) && hex(m.mac, MAC_HEX)) return { t: 'hello', pid: m.pid, name: m.name, n: m.n, mac: m.mac }
+  if (m.t === 'tabs' && int(m.rid) && Array.isArray(m.tabs)) return { t: 'tabs', rid: m.rid, tabs: m.tabs.slice(0, 64).map(tabOf).filter((x): x is SendTab => !!x) }
+  if (m.t === 'sent' && int(m.rid) && m.res && typeof m.res === 'object') {
+    const r = m.res as Record<string, unknown>
+    if (r.ok === true) {
+      const target = tabOf(r.target)
+      if (target) return { t: 'sent', rid: m.rid, res: { ok: true, target } }
+    } else if (str(r.reason, 200)) return { t: 'sent', rid: m.rid, res: { ok: false, reason: r.reason } }
+  }
+  return null
+}
+
+/** A line from the service, checked; anything else is null. */
+export function parseToClient(line: string): ToClient | null {
+  if (line.length > MAX_LINE) return null
+  let m: Record<string, unknown>
+  try {
+    m = JSON.parse(line) as Record<string, unknown>
+  } catch {
+    return null
+  }
+  if (!m || typeof m !== 'object') return null
+  if (m.t === 'nonce' && hex(m.n, NONCE_HEX)) return { t: 'nonce', n: m.n }
+  if (m.t === 'proof' && hex(m.mac, MAC_HEX)) return { t: 'proof', mac: m.mac }
+  if (m.t === 'tabs?' && int(m.rid)) return { t: 'tabs?', rid: m.rid }
+  if (m.t === 'send' && int(m.rid) && str(m.id, 128) && str(m.text, MAX_TEXT)) return { t: 'send', rid: m.rid, id: m.id, text: m.text }
+  if (m.t === 'paste' && str(m.text, MAX_TEXT)) return { t: 'paste', text: m.text }
+  return null
+}
+
+/** The copy's name in the list: "Stable" for the stable copy, else the app's. */
+export function copyName(execPath: string): string {
+  const base = (execPath.split(/[\\/]/).pop() ?? '').replace(/\.exe$/i, '')
+  if (/^PrismTerminalStable$/i.test(base)) return 'Stable'
+  if (/^PrismTerminal$/i.test(base)) return 'Prism Terminal'
+  return base || 'Prism Terminal'
+}
+
+function lines(sock: Socket, onLine: (l: string) => void): void {
+  let buf = ''
+  sock.setEncoding('utf8')
+  sock.on('data', (d: string) => {
+    buf += d
+    if (buf.length > MAX_LINE * 4) {
+      sock.destroy()
+      return
+    }
+    let i
+    while ((i = buf.indexOf('\n')) >= 0) {
+      const l = buf.slice(0, i)
+      buf = buf.slice(i + 1)
+      if (l.trim()) onLine(l)
+    }
+  })
+}
+const write = (sock: Socket, m: ToClient | ToService): void => {
+  try {
+    sock.write(JSON.stringify(m) + '\n')
+  } catch {
+    /* gone: its close says so */
+  }
+}
+
+export interface RemoteCopy {
+  pid: number
+  name: string
+}
+
+/** The service's end: the copies connected now, and asking them. */
+export interface LinkService {
+  copies(): RemoteCopy[]
+  /** Every copy's tabs; a copy that does not answer in time is left out. */
+  tabs(timeoutMs?: number): Promise<{ copy: RemoteCopy; tabs: SendTab[] }[]>
+  send(pid: number, id: string, text: string, timeoutMs?: number): Promise<SendDecision>
+  paste(pid: number, text: string): boolean
+  close(): void
+}
+
+export function startLinkService(pipe: string, key: Buffer, onError?: (e: unknown) => void): LinkService {
+  type Peer = { sock: Socket; copy: RemoteCopy | null; n: string }
+  const peers = new Set<Peer>()
+  const waits = new Map<number, (m: ToService) => void>()
+  let rid = 1
+  const server: Server = createServer((sock) => {
+    const p: Peer = { sock, copy: null, n: nonce() }
+    peers.add(p)
+    write(sock, { t: 'nonce', n: p.n })
+    // A peer that has not proved itself in a few seconds is not one.
+    const timer = setTimeout(() => {
+      if (!p.copy) sock.destroy()
+    }, 5000)
+    timer.unref()
+    lines(sock, (l) => {
+      const m = parseToService(l)
+      if (!m) return
+      if (m.t === 'hello') {
+        if (p.copy || !sameMac(m.mac, macOf(key, `client|${p.n}|${m.n}`))) return void sock.destroy()
+        p.copy = { pid: m.pid, name: m.name }
+        write(sock, { t: 'proof', mac: macOf(key, `service|${m.n}|${p.n}`) })
+      } else if (p.copy) waits.get(m.rid)?.(m)
+    })
+    sock.on('close', () => peers.delete(p))
+    sock.on('error', () => peers.delete(p))
+  })
+  server.on('error', (e) => onError?.(e))
+  server.listen(pipe)
+  const ask = <T>(p: Peer, m: ToClient & { rid: number }, pick: (r: ToService) => T | null, timeoutMs: number, fallback: T): Promise<T> =>
+    new Promise((resolve) => {
+      const done = (v: T): void => {
+        clearTimeout(timer)
+        waits.delete(m.rid)
+        resolve(v)
+      }
+      const timer = setTimeout(() => done(fallback), timeoutMs)
+      waits.set(m.rid, (r) => {
+        const v = pick(r)
+        if (v !== null) done(v)
+      })
+      write(p.sock, m)
+    })
+  const named = (): Peer[] => [...peers].filter((p) => p.copy)
+  return {
+    copies: () => named().map((p) => p.copy!),
+    tabs: (timeoutMs = 800) =>
+      Promise.all(
+        named().map(async (p) => ({
+          copy: p.copy!,
+          tabs: await ask(p, { t: 'tabs?', rid: rid++ }, (r) => (r.t === 'tabs' ? r.tabs : null), timeoutMs, [] as SendTab[])
+        }))
+      ),
+    send: (pid, id, text, timeoutMs = 15000) => {
+      const p = named().find((x) => x.copy!.pid === pid)
+      if (!p) return Promise.resolve({ ok: false, reason: 'that copy of the app has closed' })
+      return ask<SendDecision>(p, { t: 'send', rid: rid++, id, text }, (r) => (r.t === 'sent' ? r.res : null), timeoutMs, {
+        ok: false,
+        reason: 'that copy of the app did not answer'
+      })
+    },
+    paste: (pid, text) => {
+      const p = named().find((x) => x.copy!.pid === pid)
+      if (!p) return false
+      write(p.sock, { t: 'paste', text })
+      return true
+    },
+    close: () => {
+      for (const p of peers) p.sock.destroy()
+      peers.clear()
+      server.close()
+    }
+  }
+}
+
+export interface ClientHandlers {
+  tabs(): Promise<SendTab[]>
+  send(id: string, text: string): Promise<SendDecision>
+  paste(text: string): void
+}
+
+/** A client's end: connects, and keeps trying while it is not the service.
+ *  `onState` hears when it is connected to a service and when it is not. */
+export function startLinkClient(
+  pipe: string,
+  key: Buffer,
+  me: RemoteCopy,
+  h: ClientHandlers,
+  retryMs = 1000,
+  onState?: (connected: boolean) => void
+): { close(): void } {
+  let sock: Socket | null = null
+  let closed = false
+  let timer: ReturnType<typeof setTimeout> | null = null
+  let up = false
+  const state = (on: boolean): void => {
+    if (on === up) return
+    up = on
+    onState?.(on)
+  }
+  const again = (): void => {
+    sock = null
+    if (!closed) state(false)
+    if (!closed && !timer) timer = setTimeout(go, retryMs)
+  }
+  const go = (): void => {
+    timer = null
+    if (closed) return
+    const s = connect(pipe)
+    sock = s
+    const mine = nonce()
+    let theirs: string | null = null
+    let trusted = false
+    lines(s, (l) => {
+      const m = parseToClient(l)
+      if (!m) return
+      if (m.t === 'nonce') {
+        if (theirs) return void s.destroy()
+        theirs = m.n
+        write(s, { t: 'hello', pid: me.pid, name: me.name, n: mine, mac: macOf(key, `client|${m.n}|${mine}`) })
+        return
+      }
+      if (m.t === 'proof') {
+        // The service holds the key too, or it is not the service.
+        if (!theirs || trusted || !sameMac(m.mac, macOf(key, `service|${mine}|${theirs}`))) return void s.destroy()
+        trusted = true
+        state(true)
+        return
+      }
+      // Nothing is answered, typed or pasted for a peer that has not proved itself.
+      if (!trusted) return void s.destroy()
+      if (m.t === 'tabs?') void h.tabs().then((tabs) => write(s, { t: 'tabs', rid: m.rid, tabs }), () => write(s, { t: 'tabs', rid: m.rid, tabs: [] }))
+      else if (m.t === 'send') void h.send(m.id, m.text).then((res) => write(s, { t: 'sent', rid: m.rid, res }), () => write(s, { t: 'sent', rid: m.rid, res: { ok: false, reason: 'it failed' } }))
+      else h.paste(m.text)
+    })
+    s.on('error', () => {})
+    s.on('close', again)
+  }
+  go()
+  return {
+    close: () => {
+      closed = true
+      if (timer) clearTimeout(timer)
+      sock?.destroy()
+    }
+  }
+}
diff --git a/src/main/dwmHelper.test.ts b/src/main/dwmHelper.test.ts
index 02cfcaa8..06472568 100644
--- a/src/main/dwmHelper.test.ts
+++ b/src/main/dwmHelper.test.ts
@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest'
-import { colorrefOf, DWM_HELPER_SCRIPT, dwmHelperArgs, hwndOf } from './dwmHelper'
+import { colorrefOf, hwndOf } from './dwmHelper'
+import { appHelperArgs } from './appHelper'
 
 describe('the DWM helper arithmetic', () => {
   it('turns a hex colour into a COLORREF with red in the low byte', () => {
@@ -19,20 +20,13 @@ describe('the DWM helper arithmetic', () => {
   })
 })
 
-describe('the DWM helper launch', () => {
-  it('passes its script as plain -Command, never -EncodedCommand (#180)', () => {
+describe('the app helper launch (it sets the DWM attributes since 2026-10-17)', () => {
+  it('runs a script file, never -EncodedCommand (#180)', () => {
     // MEASURED from the packaged app (2026-10-11): Windows Defender held the
     // spawn() of an -EncodedCommand PowerShell for 1.4 s, on main's thread, at
-    // every launch; the same script as plain -Command took 10 ms.
-    expect(dwmHelperArgs()).toEqual(['-NoProfile', '-NonInteractive', '-Command', DWM_HELPER_SCRIPT])
-    expect(dwmHelperArgs().join(' ')).not.toMatch(/-Enc/i)
-  })
-
-  it('carries a script that survives being ONE argument', () => {
-    // Node escapes a double quote for CreateProcess and -Command reads the
-    // result a second time: no double quote and no newline is safe from both.
-    expect(DWM_HELPER_SCRIPT).not.toMatch(/["\r\n]/)
-    expect(DWM_HELPER_SCRIPT.endsWith('\\')).toBe(false)
-    expect(DWM_HELPER_SCRIPT).toContain('DwmSetWindowAttribute')
+    // every launch.
+    const args = appHelperArgs('C:\\app\\resources\\app-helper\\appHelper.ps1', 'C:\\cache')
+    expect(args).toEqual(['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', 'C:\\app\\resources\\app-helper\\appHelper.ps1', 'C:\\cache'])
+    expect(args.join(' ')).not.toMatch(/-Enc/i)
   })
 })
diff --git a/src/main/dwmHelper.ts b/src/main/dwmHelper.ts
index ca2d9990..7e6ec058 100644
--- a/src/main/dwmHelper.ts
+++ b/src/main/dwmHelper.ts
@@ -19,45 +19,13 @@
  * the window and every IPC call standing still; the same script as plain
  * -Command, 10 ms. So the script is ONE line with no double quote in it (the
  * mediaPause rule): the C# string's quotes are made inside PowerShell.
+ *
+ * SINCE 2026-10-17 THE APP'S ONE HELPER (`appHelper.ts`, `hook/appHelper.ps1`)
+ * does it, beside the dictation key's hook: one PowerShell started with the
+ * app instead of two (owner: merge the helpers, for the startup). A line
+ * "dwm <hwnd> <attribute> <value>".
  */
-import { SYS } from '@core/main/sysTools'
-import { spawn, type ChildProcess } from 'child_process'
-
-export const DWM_HELPER_SCRIPT =
-  `$q = [char]34; Add-Type ('using System;using System.Runtime.InteropServices;public class DW{[DllImport(' + $q + 'dwmapi.dll' + $q + ')]public static extern int DwmSetWindowAttribute(IntPtr h,int a,ref int v,int s);}'); ` +
-  `while ($true) { $line = [Console]::In.ReadLine(); if ($null -eq $line) { break }; $p = $line.Split(' '); ` +
-  `if ($p.Length -ge 3) { try { $h = [IntPtr]::new([int64]$p[0]); $a = [int]$p[1]; $v = [int]$p[2]; ` +
-  `[DW]::DwmSetWindowAttribute($h, $a, [ref]$v, 4) | Out-Null } catch {} } }`
-
-export function dwmHelperArgs(): string[] {
-  return ['-NoProfile', '-NonInteractive', '-Command', DWM_HELPER_SCRIPT]
-}
-
-let proc: ChildProcess | null = null
-
-function helper(): ChildProcess | null {
-  if (proc && proc.exitCode === null && !proc.killed) return proc
-  try {
-    proc = spawn(SYS.powershell, dwmHelperArgs(), { stdio: ['pipe', 'ignore', 'ignore'], windowsHide: true })
-    proc.on('exit', () => {
-      proc = null
-    })
-    proc.on('error', () => {
-      proc = null
-    })
-    // A write to a helper that has just died fails LATER, as an 'error' event
-    // on stdin that the try round write() cannot catch; unheard, it is an
-    // uncaught exception in main (code review 2026-09-24, #13). mediaPause
-    // guards the same case.
-    proc.stdin?.on('error', () => {
-      proc = null
-    })
-    return proc
-  } catch {
-    proc = null
-    return null
-  }
-}
+import { appHelperSend, stopAppHelper, warmAppHelper } from './appHelper'
 
 /** The HWND as a decimal string, from Electron's native handle buffer. */
 export function hwndOf(buf: Buffer): string {
@@ -65,12 +33,7 @@ export function hwndOf(buf: Buffer): string {
 }
 
 function send(hwnd: string, attribute: number, value: number): void {
-  const p = helper()
-  try {
-    p?.stdin?.write(`${hwnd} ${attribute} ${value}\n`)
-  } catch {
-    proc = null
-  }
+  appHelperSend(`dwm ${hwnd} ${attribute} ${value}`)
 }
 
 /** Square or default corners while the window is up. */
@@ -100,15 +63,9 @@ export function colorrefOf(hex: string): number {
 
 /** Warm the helper at startup so the first change is not the compile. */
 export function warmDwmHelper(): void {
-  helper()
+  warmAppHelper()
 }
 
 export function stopDwmHelper(): void {
-  try {
-    proc?.stdin?.end()
-    proc?.kill()
-  } catch {
-    /* gone */
-  }
-  proc = null
+  stopAppHelper()
 }
diff --git a/src/main/globalDictKey.test.ts b/src/main/globalDictKey.test.ts
new file mode 100644
index 00000000..bb02c03c
--- /dev/null
+++ b/src/main/globalDictKey.test.ts
@@ -0,0 +1,109 @@
+import { execFileSync } from 'child_process'
+import { join } from 'path'
+import { afterAll, describe, expect, it } from 'vitest'
+import { DEFAULT_HOTKEY, type Hotkey } from '@core/renderer/lib/dictationKey'
+import { createKeyFeed, keysFor, masksStart, parseHelperLine, startKeyHelper, type HelperLine, type KeyHelper } from './globalDictKey'
+import { appHelperSend, configureAppHelper, stopAppHelper } from './appHelper'
+
+/**
+ * The dictation key from any app (owner, 2026-10-16): the helper's lines turned
+ * into the reducer's events, so Ctrl+Win behaves as it does in the app.
+ */
+
+const F9: Hotkey = { code: 'F9', ctrl: false, alt: false, shift: false, meta: false }
+
+describe('keysFor', () => {
+  it('watches both sides of each modifier of Ctrl+Win, and masks Start for it', () => {
+    expect(keysFor(DEFAULT_HOTKEY)).toEqual([0x5b, 0x5c, 0xa2, 0xa3])
+    expect(masksStart(DEFAULT_HOTKEY)).toBe(true)
+  })
+  it('watches a plain key alone, and a chord with its modifiers', () => {
+    expect(keysFor(F9)).toEqual([0x78])
+    expect(masksStart(F9)).toBe(false)
+    expect(keysFor({ code: 'KeyD', ctrl: true, alt: false, shift: true, meta: false })).toEqual([0x44, 0xa0, 0xa1, 0xa2, 0xa3])
+    expect(keysFor({ code: 'AltRight', ctrl: false, alt: false, shift: false, meta: false })).toEqual([0xa5])
+  })
+})
+
+describe('parseHelperLine', () => {
+  it('reads keys, another key, digits and Esc, and nothing else', () => {
+    expect(parseHelperLine('d 5B')).toEqual({ kind: 'key', type: 'down', code: 'MetaLeft' })
+    expect(parseHelperLine('u A2\r')).toEqual({ kind: 'key', type: 'up', code: 'ControlLeft' })
+    expect(parseHelperLine('o')).toEqual({ kind: 'other' })
+    expect(parseHelperLine('p 3')).toEqual({ kind: 'digit', n: 3 })
+    expect(parseHelperLine('x')).toEqual({ kind: 'esc' })
+    expect(parseHelperLine('p 0')).toBeNull()
+    expect(parseHelperLine('d ZZ')).toBeNull()
+    expect(parseHelperLine('d 5B f 4242')).toEqual({ kind: 'key', type: 'down', code: 'MetaLeft', front: 4242 })
+    expect(parseHelperLine('d 5B f')).toBeNull()
+    expect(parseHelperLine('waiting')).toEqual({ kind: 'waiting' })
+    expect(parseHelperLine('hello')).toBeNull()
+  })
+})
+
+describe('createKeyFeed', () => {
+  const key = (type: 'down' | 'up', code: string): HelperLine => ({ kind: 'key', type, code })
+  it('starts a hold of Ctrl+Win after the solo wait and stops on release', () => {
+    const f = createKeyFeed(() => ({ hotkey: DEFAULT_HOTKEY, mode: 'hold' }))
+    expect(f.feed(key('down', 'ControlLeft'), 0)).toBeNull()
+    expect(f.feed(key('down', 'MetaLeft'), 10)).toBeNull()
+    expect(f.arming()).toBe(true)
+    expect(f.tick(220)).toBe('start')
+    expect(f.feed(key('up', 'MetaLeft'), 900)).toBe('stop')
+  })
+  it('lets Ctrl+Win+Left switch desktops: another key while it decides is no dictation', () => {
+    const f = createKeyFeed(() => ({ hotkey: DEFAULT_HOTKEY, mode: 'hold' }))
+    f.feed(key('down', 'ControlLeft'), 0)
+    f.feed(key('down', 'MetaLeft'), 10)
+    expect(f.feed({ kind: 'other' }, 50)).toBeNull()
+    expect(f.tick(220)).toBeNull()
+  })
+  it('cancels a recording on Esc', () => {
+    const f = createKeyFeed(() => ({ hotkey: F9, mode: 'toggle' }))
+    expect(f.feed(key('down', 'F9'), 0)).toBe('start')
+    f.feed(key('up', 'F9'), 50)
+    expect(f.feed({ kind: 'esc' }, 400)).toBe('cancel')
+  })
+})
+
+// The real helper, on a key no application uses (F24): what it reports, how
+// fast. Nothing is typed anywhere. Since 2026-10-17 it is the app's one helper
+// (it sets the DWM attributes too), and the hook is turned on and off in it.
+describe.runIf(process.platform === 'win32')('the hook helper', () => {
+  afterAll(() => stopAppHelper())
+  const started = (lines: HelperLine[]): Promise<KeyHelper> =>
+    new Promise((res) => {
+      const h: KeyHelper = startKeyHelper((l) => {
+        lines.push(l)
+        if (l.kind === 'ready') res(h)
+      })
+    })
+  it('reports the binding key down and up, and stops when told', async () => {
+    configureAppHelper(join(__dirname, 'hook', 'appHelper.ps1'), null)
+    const lines: HelperLine[] = []
+    const h = await started(lines)
+    // A DWM line on a window that does not exist: answered, nothing breaks.
+    appHelperSend('dwm 0 34 -1')
+    h.send('keys 87')
+    await new Promise((r) => setTimeout(r, 200))
+    execFileSync('powershell.exe', ['-NoProfile', '-Command', TAP_F24], { windowsHide: true })
+    await new Promise((r) => setTimeout(r, 400))
+    h.stop()
+    // `front` says whether a Prism Terminal window is in front, which depends on
+    // where the suite runs from: not this test's business.
+    expect(lines.filter((l) => l.kind !== 'ready').map((l) => (l.kind === 'key' ? { kind: l.kind, type: l.type, code: l.code } : l))).toEqual([
+      { kind: 'key', type: 'down', code: 'F24' },
+      { kind: 'key', type: 'up', code: 'F24' }
+    ])
+  }, 30_000)
+
+  it('hooks again in the same helper after it was turned off (the lock was let go)', async () => {
+    const lines: HelperLine[] = []
+    const h = await started(lines)
+    expect(lines).toEqual([{ kind: 'ready' }])
+    h.stop()
+  }, 30_000)
+})
+
+const TAP_F24 =
+  "Add-Type -TypeDefinition 'using System;using System.Runtime.InteropServices;public static class T{[StructLayout(LayoutKind.Sequential)]struct K{public ushort v;public ushort s;public uint f;public uint t;public IntPtr e;}[StructLayout(LayoutKind.Explicit,Size=40)]struct I{[FieldOffset(0)]public uint y;[FieldOffset(8)]public K k;}[DllImport(\"user32.dll\")]static extern uint SendInput(uint n,I[] i,int s);public static void Tap(){var a=new I[2];a[0].y=1;a[0].k.v=0x87;a[1].y=1;a[1].k.v=0x87;a[1].k.f=2;SendInput(2,a,Marshal.SizeOf(typeof(I)));}}'; [T]::Tap()"
diff --git a/src/main/globalDictKey.ts b/src/main/globalDictKey.ts
new file mode 100644
index 00000000..8fb4f148
--- /dev/null
+++ b/src/main/globalDictKey.ts
@@ -0,0 +1,172 @@
+import { initialKeyState, reduceKey, type DictMode, type Hotkey, type KeyAction, type KeyEvt, type KeyState } from '@core/renderer/lib/dictationKey'
+import { appHelperSend, onAppHelperExit, onAppHelperLine } from './appHelper'
+
+/**
+ * THE DICTATION KEY FROM ANY APP (owner, 2026-10-16; spec:
+ * docs/superpowers/specs/2026-10-16-dictate-anywhere.md). The hook
+ * (`hook/appHelper.ps1`) reports the binding's keys; this turns them into
+ * the same key events the page's reducer reads (`reduceKey`, core), so the
+ * key behaves exactly as it does in the app: hold or toggle, the solo rules
+ * that keep Ctrl+Win+Left a desktop switch. Pure parts first, tested.
+ */
+
+/** A key code (KeyboardEvent.code) and its Windows virtual key. */
+const VK: Record<string, number> = {
+  ControlLeft: 0xa2, ControlRight: 0xa3, AltLeft: 0xa4, AltRight: 0xa5,
+  ShiftLeft: 0xa0, ShiftRight: 0xa1, MetaLeft: 0x5b, MetaRight: 0x5c,
+  Pause: 0x13, ScrollLock: 0x91, Space: 0x20, Backquote: 0xc0
+}
+for (let i = 1; i <= 24; i++) VK[`F${i}`] = 0x6f + i
+for (let c = 0; c < 26; c++) VK[`Key${String.fromCharCode(65 + c)}`] = 65 + c
+for (let d = 0; d < 10; d++) VK[`Digit${d}`] = 0x30 + d
+const CODE_OF: Record<number, string> = Object.fromEntries(Object.entries(VK).map(([c, v]) => [v, c]))
+
+const MOD_KEYS = {
+  ctrl: ['ControlLeft', 'ControlRight'],
+  alt: ['AltLeft', 'AltRight'],
+  shift: ['ShiftLeft', 'ShiftRight'],
+  meta: ['MetaLeft', 'MetaRight']
+} as const
+const FLAG_OF: Record<string, keyof typeof MOD_KEYS> = {
+  ControlLeft: 'ctrl', ControlRight: 'ctrl', AltLeft: 'alt', AltRight: 'alt',
+  ShiftLeft: 'shift', ShiftRight: 'shift', MetaLeft: 'meta', MetaRight: 'meta'
+}
+
+/** The virtual keys the helper must watch for a binding: its key, and both
+ *  sides of every modifier it names (and of its own key's, for a chord of
+ *  modifiers). Null when the key has no Windows equivalent here. */
+export function keysFor(h: Hotkey): number[] | null {
+  const main = VK[h.code]
+  if (main === undefined) return null
+  const out = new Set<number>([main])
+  const own = FLAG_OF[h.code]
+  for (const f of ['ctrl', 'alt', 'shift', 'meta'] as const)
+    if (h[f] || (own === f && (h.ctrl || h.alt || h.shift || h.meta))) for (const c of MOD_KEYS[f]) out.add(VK[c])
+  return [...out].sort((a, b) => a - b)
+}
+
+/** The Start menu needs masking only when the binding holds Win with Ctrl. */
+export const masksStart = (h: Hotkey): boolean => (h.meta || FLAG_OF[h.code] === 'meta') && (h.ctrl || FLAG_OF[h.code] === 'ctrl')
+
+/** `front`: the main process of the Prism Terminal copy (this one or another)
+ *  whose window was in front at a down. */
+export type HelperLine =
+  | { kind: 'key'; type: 'down' | 'up'; code: string; front?: number }
+  | { kind: 'other' }
+  | { kind: 'digit'; n: number }
+  | { kind: 'esc' }
+  | { kind: 'ready' }
+  | { kind: 'failed' }
+  | { kind: 'waiting' }
+
+/** One line of the helper's output, or null for anything else. */
+export function parseHelperLine(line: string): HelperLine | null {
+  const t = line.trim()
+  if (t === 'ready') return { kind: 'ready' }
+  if (t === 'failed') return { kind: 'failed' }
+  if (t === 'waiting') return { kind: 'waiting' }
+  if (t === 'o') return { kind: 'other' }
+  if (t === 'x') return { kind: 'esc' }
+  let m = /^([du]) ([0-9A-F]{2})(?: f ([0-9]{1,10}))?$/.exec(t)
+  if (m) {
+    const code = CODE_OF[parseInt(m[2], 16)]
+    if (!code) return null
+    const type = m[1] === 'd' ? 'down' : 'up'
+    return m[3] && type === 'down' ? { kind: 'key', type, code, front: Number(m[3]) } : { kind: 'key', type, code }
+  }
+  m = /^p ([1-9])$/.exec(t)
+  if (m) return { kind: 'digit', n: Number(m[1]) }
+  return null
+}
+
+/**
+ * The binding's key events as the reducer reads them: the modifier flags are
+ * kept here from the downs and ups seen (the helper reports only the
+ * binding's keys), and "another key" is a key named `Other` with them.
+ */
+export function createKeyFeed(cfg: () => { hotkey: Hotkey; mode: DictMode }): {
+  feed(l: HelperLine, at: number): KeyAction
+  tick(at: number): KeyAction
+  arming(): boolean
+  reset(): void
+} {
+  let state: KeyState = initialKeyState()
+  const held = new Set<string>()
+  const flags = (): Pick<Extract<KeyEvt, { type: 'down' | 'up' }>, 'ctrl' | 'alt' | 'shift' | 'meta'> => {
+    const has = (f: keyof typeof MOD_KEYS): boolean => MOD_KEYS[f].some((c) => held.has(c))
+    return { ctrl: has('ctrl'), alt: has('alt'), shift: has('shift'), meta: has('meta') }
+  }
+  const run = (evt: KeyEvt): KeyAction => {
+    const c = cfg()
+    const out = reduceKey(state, evt, { hotkey: c.hotkey, mode: c.mode })
+    state = out.state
+    return out.action
+  }
+  return {
+    feed(l, at) {
+      if (l.kind === 'other') return run({ type: 'down', code: 'Other', ...flags(), at })
+      if (l.kind === 'esc') return run({ type: 'down', code: 'Escape', ...flags(), at })
+      if (l.kind !== 'key') return null
+      const repeat = l.type === 'down' && held.has(l.code)
+      if (l.type === 'down') held.add(l.code)
+      const evt: KeyEvt = { type: l.type, code: l.code, ...flags(), repeat, at }
+      if (l.type === 'up') held.delete(l.code)
+      return run(evt)
+    },
+    tick: (at) => run({ type: 'tick', at }),
+    arming: () => state.phase === 'arming',
+    reset() {
+      state = initialKeyState()
+      held.clear()
+    }
+  }
+}
+
+/** The hook, in the app's one helper (`appHelper.ts`): turned on and off there. */
+export interface KeyHelper {
+  send(line: string): void
+  stop(): void
+}
+
+/**
+ * The dictation key's hook, in the app's one helper (2026-10-17; it had its
+ * own PowerShell). `hook 1` installs it; what was sent for it (the keys, the
+ * mask) is kept, so a helper that died and came back is armed the same again.
+ */
+export function startKeyHelper(onLine: (l: HelperLine) => void): KeyHelper {
+  let stopped = false
+  const sent = new Map<string, string>()
+  const offLine = onAppHelperLine((raw) => {
+    const l = parseHelperLine(raw)
+    if (l && !stopped) onLine(l)
+  })
+  const arm = (): void => {
+    appHelperSend('hook 1')
+    for (const line of sent.values()) appHelperSend(line)
+  }
+  const offExit = onAppHelperExit(() => {
+    if (stopped) return
+    // Gone without being told: whatever it held (the key, the service) it no
+    // longer does. Started and armed again a moment later.
+    onLine({ kind: 'failed' })
+    setTimeout(() => {
+      if (!stopped) arm()
+    }, 1000).unref()
+  })
+  arm()
+  return {
+    send: (line) => {
+      const verb = line.split(' ')[0]
+      if (verb === 'keys' || verb === 'mask') sent.set(verb, line)
+      appHelperSend(line)
+    },
+    stop: () => {
+      if (stopped) return
+      stopped = true
+      offLine()
+      offExit()
+      appHelperSend('pick 0')
+      appHelperSend('hook 0')
+    }
+  }
+}
diff --git a/src/main/hook/appHelper.ps1 b/src/main/hook/appHelper.ps1
new file mode 100644
index 00000000..e655a272
--- /dev/null
+++ b/src/main/hook/appHelper.ps1
@@ -0,0 +1,223 @@
+# THE APP'S ONE HELPER (2026-10-17, owner: merge the helpers, "it's mainly
+# startup performance"): the window's DWM attributes (what dwmHelper's own
+# PowerShell did) and the dictation key's hook, in ONE Windows PowerShell
+# started with the app. It answers `dwm` at once; the hook runs on its own
+# thread only between `hook 1` and `hook 0`. Its compiled C# is cached by hash
+# in the folder named by the first argument, so a start pays no compiler.
+#
+# THE DICTATION KEY FROM ANY APP (Prism Terminal, 2026-10-16; owner: "you can
+# start the dictation while not having the app in focus"). A low-level keyboard
+# hook (WH_KEYBOARD_LL) in a long-lived Windows PowerShell, like the DWM helper:
+# Windows' own global shortcuts cannot see a chord of modifiers alone (Ctrl+Win),
+# nor a key held and released. MEASURED (spike, 2026-10-16): 0.3 to 1.2 ms from
+# a key to its line here, no CPU at rest, no Defender detection.
+#
+# PRIVACY: it reads only the keys main names (the dictation binding), says only
+# "another key" (never which) while one of them is down, and, only while the
+# session picker is open, the digits 1-9 and Esc. Nothing is written anywhere.
+#
+# stdin (from main):  dwm <hwnd> <attribute> <value>   DwmSetWindowAttribute (33 corners, 34 border)
+#                     hook 1|0            install / remove the dictation key's hook
+#                     keys <hex vk> ...   the binding's keys (either side of a modifier)
+#                     mask 1|0            mask the Start menu on a Win up after Ctrl+Win
+#                     pick 1|0            report and SWALLOW 1-9 and Esc (the picker is open)
+#                     quit
+# ONE HOOK FOR EVERY COPY OF THE APP (owner, 2026-10-17: "very buggy and
+# unresponsive ... i have to press multiple times"). MEASURED: with Stable and
+# the installed app both running, both hooks took every press; the second
+# copy, with no mic set up, failed in 8 ms and its widget covered the first's.
+# So a helper hooks only while it holds a lock file (%TEMP%, opened with no
+# sharing; Windows closes it when the helper ends): the first copy started owns
+# the key, a later one waits ("waiting") and takes over when the first exits.
+# MEASURED: a named Mutex hung the waiting helper for good once the owner
+# exited (WaitOne on PowerShell's STA thread); the lock file hands over within
+# the 500 ms poll. A down says " f <pid>" when a Prism Terminal window is in
+# front, naming the copy (its main process) whose window it is: the words go there.
+#
+# stdout (to main):   ready / failed / waiting  hooked / could not / another copy owns the key
+#                     d <hex vk> [f <pid>] / u <hex vk>   a binding key down (f: a Prism Terminal in front) / up
+#                     o                          another key went down while one is held
+#                     p <1-9> / x                a digit / Esc, while picking
+param([string]$cache = '')
+$src = @'
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Threading;
+public static class PTHelper {
+  delegate IntPtr Proc(int n, IntPtr w, IntPtr l);
+  [DllImport("user32.dll")] static extern IntPtr SetWindowsHookEx(int id, Proc fn, IntPtr mod, uint tid);
+  [DllImport("user32.dll")] static extern IntPtr CallNextHookEx(IntPtr h, int n, IntPtr w, IntPtr l);
+  [DllImport("user32.dll")] static extern bool UnhookWindowsHookEx(IntPtr h);
+  [DllImport("dwmapi.dll")] static extern int DwmSetWindowAttribute(IntPtr h, int a, ref int v, int s);
+  [DllImport("user32.dll")] static extern int GetMessage(out MSG m, IntPtr h, uint a, uint b);
+  [DllImport("user32.dll")] static extern bool PostThreadMessage(uint tid, uint msg, IntPtr w, IntPtr l);
+  [DllImport("kernel32.dll")] static extern uint GetCurrentThreadId();
+  [DllImport("kernel32.dll")] static extern IntPtr GetModuleHandle(string n);
+  [DllImport("user32.dll")] static extern uint SendInput(uint n, INPUT[] i, int size);
+  [DllImport("user32.dll")] static extern IntPtr GetForegroundWindow();
+  [DllImport("user32.dll")] static extern uint GetWindowThreadProcessId(IntPtr h, out uint pid);
+  [DllImport("kernel32.dll")] static extern IntPtr OpenProcess(uint access, bool inherit, uint pid);
+  [DllImport("kernel32.dll", CharSet = CharSet.Unicode)] static extern bool QueryFullProcessImageName(IntPtr h, uint flags, System.Text.StringBuilder s, ref uint n);
+  [DllImport("kernel32.dll")] static extern bool CloseHandle(IntPtr h);
+  [StructLayout(LayoutKind.Sequential)] public struct MSG { public IntPtr h; public uint m; public IntPtr w; public IntPtr l; public uint t; public int x; public int y; }
+  [StructLayout(LayoutKind.Sequential)] struct KBD { public ushort vk; public ushort scan; public uint flags; public uint time; public IntPtr extra; }
+  [StructLayout(LayoutKind.Explicit, Size = 40)] struct INPUT { [FieldOffset(0)] public uint type; [FieldOffset(8)] public KBD k; }
+  static Proc keep; static IntPtr hook;
+  static Thread hookThread; static volatile uint hookTid; static volatile bool hookWanted;
+  static volatile HashSet<int> keys = new HashSet<int>();
+  static volatile bool mask, pick;
+  static readonly HashSet<int> down = new HashSet<int>();
+  static bool winDown, ctrlWithWin;
+  const int MASK_VK = 0xE8; // unassigned: what AutoHotkey sends to keep Start shut
+  static void Say(string s) { Console.Out.WriteLine(s); Console.Out.Flush(); }
+  static IntPtr lastFront; static bool lastWasPT; static uint lastPid;
+  // Is the window in front one of Prism Terminal's (any copy: PrismTerminal,
+  // PrismTerminalStable)? Kept per window: the hook must answer fast.
+  static bool FrontIsPT() {
+    IntPtr f = GetForegroundWindow();
+    if (f == lastFront) return lastWasPT;
+    lastFront = f; lastWasPT = false;
+    uint pid; GetWindowThreadProcessId(f, out pid);
+    lastPid = pid;
+    IntPtr h = OpenProcess(0x1000, false, pid);
+    if (h == IntPtr.Zero) return false;
+    var sb = new System.Text.StringBuilder(1024); uint n = 1024;
+    if (QueryFullProcessImageName(h, 0, sb, ref n)) {
+      string name = System.IO.Path.GetFileNameWithoutExtension(sb.ToString());
+      lastWasPT = name.StartsWith("PrismTerminal", StringComparison.OrdinalIgnoreCase) && name.IndexOf("Setup", StringComparison.OrdinalIgnoreCase) < 0;
+    }
+    CloseHandle(h);
+    return lastWasPT;
+  }
+  static bool IsCtrl(int vk) { return vk == 0xA2 || vk == 0xA3 || vk == 0x11; }
+  static bool IsWin(int vk) { return vk == 0x5B || vk == 0x5C; }
+  static void Mask() {
+    var a = new INPUT[2];
+    a[0].type = 1; a[0].k.vk = MASK_VK;
+    a[1].type = 1; a[1].k.vk = MASK_VK; a[1].k.flags = 2;
+    SendInput(2, a, Marshal.SizeOf(typeof(INPUT)));
+  }
+  static IntPtr Cb(int n, IntPtr w, IntPtr l) {
+    if (n >= 0) {
+      int vk = Marshal.ReadInt32(l);
+      int msg = (int)w;
+      bool isDown = msg == 0x100 || msg == 0x104;
+      if (vk != MASK_VK) {
+        if (IsWin(vk)) {
+          if (isDown && !winDown) { winDown = true; ctrlWithWin = down.Contains(0xA2) || down.Contains(0xA3); }
+          else if (!isDown) {
+            bool used = ctrlWithWin || down.Contains(0xA2) || down.Contains(0xA3);
+            winDown = false;
+            if (mask && used) Mask();
+          }
+        } else if (IsCtrl(vk) && isDown && winDown) ctrlWithWin = true;
+        if (keys.Contains(vk)) {
+          if (isDown) { if (down.Add(vk)) Say("d " + vk.ToString("X2") + (FrontIsPT() ? " f " + lastPid : "")); }
+          else { down.Remove(vk); Say("u " + vk.ToString("X2")); }
+        } else if (isDown) {
+          if (pick && ((vk >= 0x31 && vk <= 0x39) || (vk >= 0x61 && vk <= 0x69))) {
+            Say("p " + (vk >= 0x61 ? vk - 0x60 : vk - 0x30));
+            return (IntPtr)1;
+          }
+          if (pick && vk == 0x1B) { Say("x"); return (IntPtr)1; }
+          if (down.Count > 0) Say("o");
+        } else if (pick && ((vk >= 0x31 && vk <= 0x39) || (vk >= 0x61 && vk <= 0x69) || vk == 0x1B)) {
+          return (IntPtr)1;
+        }
+      }
+    }
+    return CallNextHookEx(hook, n, w, l);
+  }
+  static void Read() {
+    string line;
+    while ((line = Console.In.ReadLine()) != null) {
+      var p = line.Trim().Split(' ');
+      if (p[0] == "dwm" && p.Length >= 4) {
+        try {
+          IntPtr h = new IntPtr(long.Parse(p[1])); int a = int.Parse(p[2]); int v = int.Parse(p[3]);
+          DwmSetWindowAttribute(h, a, ref v, 4);
+        } catch { }
+      } else if (p[0] == "hook") {
+        if (p.Length > 1 && p[1] == "1") HookOn(); else HookOff();
+      } else if (p[0] == "keys") {
+        var k = new HashSet<int>();
+        for (int i = 1; i < p.Length; i++) { int v; if (int.TryParse(p[i], System.Globalization.NumberStyles.HexNumber, null, out v)) k.Add(v); }
+        keys = k;
+      } else if (p[0] == "mask") mask = p.Length > 1 && p[1] == "1";
+      else if (p[0] == "pick") pick = p.Length > 1 && p[1] == "1";
+      else if (p[0] == "quit") break;
+    }
+    // stdin closed or quit: the app is gone, and so is the hook (and the
+    // lock, which the next copy's helper is waiting on).
+    HookOff();
+    Environment.Exit(0);
+  }
+  static void HookOn() {
+    if (hookThread != null) return;
+    hookWanted = true;
+    hookThread = new Thread(HookLoop); hookThread.IsBackground = true; hookThread.Start();
+  }
+  static void HookOff() {
+    hookWanted = false;
+    var t = hookThread;
+    if (t == null) return;
+    // Its queue may not exist yet the first moment: asked again until it ends.
+    for (int i = 0; i < 40 && t.IsAlive; i++) {
+      uint tid = hookTid;
+      if (tid != 0) PostThreadMessage(tid, 0x12, IntPtr.Zero, IntPtr.Zero);
+      t.Join(50);
+    }
+    hookThread = null;
+  }
+  static void Release() {
+    var o = owner; owner = null;
+    if (o != null) o.Dispose();
+  }
+  static void HookLoop() {
+    hookTid = GetCurrentThreadId();
+    if (!Take()) { Say("waiting"); while (hookWanted && !Take()) Thread.Sleep(500); }
+    if (!hookWanted) { Release(); hookTid = 0; return; }
+    keep = Cb;
+    hook = SetWindowsHookEx(13, keep, GetModuleHandle(null), 0);
+    Say(hook != IntPtr.Zero ? "ready" : "failed");
+    MSG m; while (GetMessage(out m, IntPtr.Zero, 0, 0) > 0) { }
+    if (hook != IntPtr.Zero) UnhookWindowsHookEx(hook);
+    hook = IntPtr.Zero;
+    down.Clear(); winDown = false;
+    Release();
+    hookTid = 0;
+  }
+  static System.IO.FileStream owner;
+  static bool Take() {
+    try {
+      owner = new System.IO.FileStream(System.IO.Path.Combine(System.IO.Path.GetTempPath(), "PrismTerminal-dictation-key.lock"),
+        System.IO.FileMode.OpenOrCreate, System.IO.FileAccess.ReadWrite, System.IO.FileShare.None);
+      return true;
+    } catch (System.IO.IOException) { return false; }
+  }
+  public static void Run() {
+    Say("up");
+    Read();
+  }
+}
+'@
+$loaded = $false
+if ($cache) {
+  try {
+    $sha = [Security.Cryptography.SHA256]::Create()
+    $hash = ([BitConverter]::ToString($sha.ComputeHash([Text.Encoding]::UTF8.GetBytes($src))) -replace '-', '').Substring(0, 16)
+    $dll = Join-Path $cache "pt-app-helper-$hash.dll"
+    if (-not (Test-Path -LiteralPath $dll)) {
+      New-Item -ItemType Directory -Force -Path $cache | Out-Null
+      $tmp = Join-Path $cache "pt-app-helper-$hash-$PID.dll"
+      Add-Type -TypeDefinition $src -OutputAssembly $tmp -OutputType Library
+      Move-Item -LiteralPath $tmp -Destination $dll -Force -ErrorAction SilentlyContinue
+      if (Test-Path -LiteralPath $tmp) { Remove-Item -LiteralPath $tmp -Force -ErrorAction SilentlyContinue }
+    }
+    Add-Type -LiteralPath $dll
+    $loaded = $true
+  } catch { $loaded = $false }
+}
+if (-not $loaded) { Add-Type -TypeDefinition $src }
+[PTHelper]::Run()
diff --git a/src/main/index.ts b/src/main/index.ts
index 22578469..bc68c9a8 100644
--- a/src/main/index.ts
+++ b/src/main/index.ts
@@ -11,16 +11,22 @@ import { openFolderDefault } from '@core/main/termPathOpen'
 import { registerDictationIpc } from '@core/main/dictationIpc'
 import { startDiagnostics, type Diagnostics } from '@core/main/diagnostics'
 import { withStackPolicy } from '@core/main/diagIpc'
+import { diagMain } from '@core/main/diagLog'
+import { copyName } from './dictationLink'
 import { planRestore } from './planRestore'
 import { foldersFromArgv } from './argv'
 import { acrylicOk, createMaterial } from './material'
 import { stopDwmHelper, warmDwmHelper } from './dwmHelper'
+import { configureAppHelper } from './appHelper'
+import { linkKey, linkPipe } from './dictationLink'
 import { createWindowEdge } from './windowEdge'
 import { createEdgeWatch } from './edgeWatch'
 import { DEFAULT_WINDOW_EDGES, validWindowEdges, type WindowEdges } from '@shared/windowEdges'
 import { detectShells } from '@core/main/shells'
 import { createTabsStore } from './tabsStore'
-import { startSessions } from './sessionsWire'
+import { startSessions, type Sessions } from './sessionsWire'
+import { startDictateAnywhere } from './dictateAnywhere'
+import { parseHelperLine } from './globalDictKey'
 import { killAll, shellsDying, shellsGone } from '@core/main/terminal'
 import { installUpdate, updateCalls, watchForUpdates } from './update'
 import { previewUpdate, runPreviewInstall, wantsPreview } from '@core/main/updatePreview'
@@ -80,6 +86,22 @@ if (E2E) Object.assign(globalThis, { __e2eOpenedLinks: e2eOpenedLinks })
 // run never reads or replaces what the owner copied. On the global so a
 // scenario can see it is the stand-in.
 if (E2E) Object.assign(globalThis, { __e2eClipboard: stubClipboard(clipboard, () => nativeImage.createEmpty()) })
+/**
+ * The pipe every copy of the app meets on for the one dictation, and the
+ * user's link key both ends prove they hold (dictationLink). The key lives
+ * beside the speech models, under the user's own profile. Under --e2e only a
+ * scenario's own pipe and key: it must never reach the owner's copies.
+ */
+function dictationLinkConfig(): { pipe: string; key: Buffer; name: string } | null {
+  const name = copyName(process.execPath)
+  if (E2E) {
+    const pipe = process.env.PT_E2E_DICT_PIPE
+    const key = Buffer.from(process.env.PT_E2E_DICT_KEY ?? '', 'hex')
+    return pipe && key.length === 32 ? { pipe, key, name } : null
+  }
+  const key = linkKey(join(process.env.PT_DICTATION_ROOT ?? join(localAppData(), 'PrismDictation'), 'link.key'))
+  return key ? { pipe: linkPipe(key), key, name } : null
+}
 function openLink(url: string): void {
   if (E2E) {
     e2eOpenedLinks.push(url)
@@ -256,7 +278,7 @@ let pendingFolders: string[] = []
 const tabs = createTabsStore(join(app.getPath('userData'), 'tabs.json'))
 /** The catch-up report's ledger (2026-10-16): which Claude session is in which
  *  tab and when the owner really looked, written to sessions.json. */
-let sessions: { flush(): void } | null = null
+let sessions: Sessions | null = null
 
 /** The newest update offer, remembered so a page that loads after it was made
  *  still hears about it (`update:announce`), and so `update:install` can tell a
@@ -362,6 +384,12 @@ function createWindow(): void {
     material.settled() // a window made after the prefs were said still wears them
     // The helper compiles its one P/Invoke now, so the first edge change is a
     // pipe write and not a two-second wait.
+    // The app's one helper (DWM attributes, the dictation key's hook), its
+    // compiled code cached in the profile so a start pays no compiler.
+    configureAppHelper(
+      app.isPackaged ? join(process.resourcesPath, 'app-helper', 'appHelper.ps1') : join(__dirname, '../../src/main/hook/appHelper.ps1'),
+      join(app.getPath('userData'), 'helper-cache')
+    )
     if (!E2E) warmDwmHelper()
     edge.apply()
   })
@@ -479,6 +507,39 @@ function wireIpc(): void {
     }
   })
 
+  /* ----- dictating from any app (2026-10-16) ----- */
+
+  // The key from any app, the widget, and where the words go. Under --e2e the
+  // real keyboard hook never runs (it would read the owner's keys and mask
+  // their Start menu); the suite feeds helper lines through a seam instead.
+  const anywhere = startDictateAnywhere({
+    preload: join(__dirname, '../preload/overlay.js'),
+    loadPage: (w) => {
+      const devUrl = process.env['ELECTRON_RENDERER_URL']
+      if (devUrl) void w.loadURL(`${devUrl}/overlay.html`)
+      else void w.loadFile(join(__dirname, '../renderer/overlay.html'))
+    },
+    mainWindow: () => mainWindow,
+    sessions: () => sessions,
+    toPage: (action) => send(APP_CH.dictOutside, action),
+    selfPid: process.pid,
+    link: dictationLinkConfig(),
+    pageRole: (role) => send(APP_CH.dictRole, role),
+    pastePage: (text) => send(APP_CH.dictPaste, text),
+    channels: { anywhere: APP_CH.dictAnywhere, live: APP_CH.dictLive, routed: APP_CH.dictRouted, look: APP_CH.dictLook },
+    onIpc: (ch, fn) => ipcMain.on(ch, (_e, ...args: unknown[]) => fn(...args)),
+    log: (what) => diagMain().write('main', 'crumb', { a: 'dictate-anywhere', ...what }),
+    e2e: E2E
+  })
+  app.on('will-quit', () => anywhere.stop())
+  if (E2E)
+    (globalThis as { __e2eDictRoute?: (text: string, front: number | null) => void }).__e2eDictRoute = (text, front) =>
+      anywhere.route({ text }, front)
+  if (E2E) (globalThis as { __e2eDictLine?: (l: string) => void }).__e2eDictLine = (l: string) => {
+    const parsed = parseHelperLine(l)
+    if (parsed) anywhere.line(parsed)
+  }
+
   /* ----- tabs ----- */
 
   // What the strip comes back as. The FIRST answer of the process also carries
@@ -583,6 +644,18 @@ function wireIpc(): void {
     sharedRoot:
       process.env.PT_DICTATION_ROOT ??
       join(localAppData(), 'PrismDictation'),
+    // Ready at all times (owner, 2026-10-17): the engine never stands down
+    // on its own. Only the copy running the dictation warms one.
+    idleMs: Infinity,
+    // Parakeet kept loaded (owner, 2026-10-17): 24 to 170 ms a pass against
+    // parakeet-cli's 0.72 to 0.86 s, MEASURED. Its compiled code is cached
+    // beside the models, so a start pays no compiler.
+    parakeetHost: () => ({
+      script: app.isPackaged
+        ? join(process.resourcesPath, 'dictation-host', 'parakeetHost.ps1')
+        : join(app.getAppPath(), 'core', 'dictation-host', 'parakeetHost.ps1'),
+      cache: join(process.env.PT_DICTATION_ROOT ?? join(localAppData(), 'PrismDictation'), 'host-cache')
+    }),
     hasNvidia: async () => {
       if (process.env.PT_E2E_NVIDIA) return process.env.PT_E2E_NVIDIA === '1'
       const info = (await app.getGPUInfo('basic')) as { gpuDevice?: Array<{ vendorId?: number }> }
diff --git a/src/main/orchestratorSend.ts b/src/main/orchestratorSend.ts
index 099cfbf5..5c20a4ce 100644
--- a/src/main/orchestratorSend.ts
+++ b/src/main/orchestratorSend.ts
@@ -62,7 +62,12 @@ export function decideSend(req: SendRequest, tabs: readonly SendTab[], enabled:
   const hits = ids.length ? ids : exact.length ? exact : loose
   if (hits.length === 0) return { ok: false, reason: `no tab matches "${to}"` }
   if (hits.length > 1) return { ok: false, reason: `"${to}" matches ${hits.map((t) => t.label).join(', ')}: name one` }
-  const target = hits[0]
+  return typeable(hits[0])
+}
+
+/** Whether the app may type into this tab at all (the rule 2 exception's
+ *  limits, shared by the orchestrator and dictation). */
+export function typeable(target: SendTab): SendDecision {
   // Only into a Claude Code prompt: never into a shell, where the text would
   // run as a command.
   if (target.agent !== 'claude' || !target.session) return { ok: false, reason: `${target.label} has no Claude session running` }
@@ -71,6 +76,30 @@ export function decideSend(req: SendRequest, tabs: readonly SendTab[], enabled:
   return { ok: true, target }
 }
 
+/**
+ * DICTATION FROM OUTSIDE THE APP (owner, 2026-10-16): the tab the owner picked
+ * by its pty id, with the same limits.
+ */
+export function decideInto(id: string, tabs: readonly SendTab[]): SendDecision {
+  const target = tabs.find((t) => t.id === id)
+  if (!target) return { ok: false, reason: 'that tab has closed' }
+  return typeable(target)
+}
+
+/**
+ * Where dictated text goes (owner: with the orchestrator "only if the
+ * orchestrator is actually active not just that you have the setting turned
+ * on"): the promoted tab when the switch is on and its Claude can take it;
+ * else the tabs a Claude can take it in, to pick from, the orchestrator first.
+ * Windows' process check confirms the lead before anything is typed.
+ */
+export function dictationRoute(tabs: readonly SendTab[], enabled: boolean): { lead: SendTab } | { pick: SendTab[] } {
+  const lead = enabled ? tabs.find((t) => t.orchestrator) : undefined
+  if (lead && typeable(lead).ok) return { lead }
+  const pick = tabs.filter((t) => t.agent === 'claude' && t.session)
+  return { pick: [...pick.filter((t) => t.orchestrator), ...pick.filter((t) => !t.orchestrator)].slice(0, 9) }
+}
+
 /**
  * What is typed: the message as ONE bracketed paste (MEASURED, Claude Code
  * 2.1.301: a multi-line paste is one prompt), every escape and control but
diff --git a/src/main/sessionsWire.ts b/src/main/sessionsWire.ts
index 7c9d71f8..034b3ac7 100644
--- a/src/main/sessionsWire.ts
+++ b/src/main/sessionsWire.ts
@@ -5,7 +5,7 @@ import { createAtomicWriter } from '@core/main/atomicWrite'
 import { setSessionsFile, tabToken, writeTerm } from '@core/main/terminal'
 import { agentUnder } from '@core/main/agentPoll'
 import { createLedger, type LedgerTab, type Presence } from './sessionLedger'
-import { decideSend, pasteOf, SEND_ENTER_MS } from './orchestratorSend'
+import { decideInto, decideSend, pasteOf, SEND_ENTER_MS, type SendDecision, type SendTab } from './orchestratorSend'
 
 /**
  * The catch-up report's ledger, wired to the window, the power monitor and the
@@ -48,7 +48,9 @@ const REQUEST = /^[0-9a-f]{32}\.json$/
 const STATES = new Set(['working', 'question', 'done', 'failed'])
 const str = (v: unknown, max: number): string | null => (typeof v === 'string' && v.length <= max ? v : null)
 
-export function startSessions(d: SessionsDeps): { flush(): void; stop(): void } {
+export type Sessions = ReturnType<typeof startSessions>
+
+export function startSessions(d: SessionsDeps) {
   const now = d.now ?? Date.now
   let saved: unknown
   try {
@@ -211,30 +213,7 @@ export function startSessions(d: SessionsDeps): { flush(): void; stop(): void }
           to: typeof req.to === 'string' ? req.to : '',
           text: typeof req.text === 'string' ? req.text : ''
         }
-        let said = decideSend(asked, ledger.live(), enabled)
-        // The tab's Claude mark is only what the tab's own output said; a
-        // program printing the same signal would earn it. So the process tree
-        // is asked (security review, 2026-10-16).
-        if (said.ok && (await agentUnder(said.target.id)) !== 'claude')
-          said = { ok: false, reason: `no Claude is running in ${said.target.label} (checked with Windows)` }
-        // That question takes about a second, in which the switch, the tab or
-        // its state can change: decide again, synchronously, right before
-        // typing, and the same tab must win (security review, 2026-10-16).
-        if (said.ok) {
-          const was = said.target
-          const now = decideSend(asked, ledger.live(), enabled)
-          said = now.ok && now.target.id === was.id && now.target.session === was.session ? now : { ok: false, reason: `${was.label} changed while it was checked: send again` }
-        }
-        if (said.ok) {
-          const id = said.target.id
-          writeTerm(id, pasteOf(asked.text))
-          // And once more before Enter: a question that opened in between
-          // would take the Enter as its answer. The text then waits, unsent.
-          setTimeout(() => {
-            const still = decideSend(asked, ledger.live(), enabled)
-            if (still.ok && still.target.id === id) writeTerm(id, '\r')
-          }, SEND_ENTER_MS)
-        }
+        const said = await typeChecked(() => decideSend(asked, ledger.live(), enabled), asked.text)
         const out = join(outbox, name.replace(/\.json$/, '.result.json'))
         const answer = said.ok ? { ok: true, to: said.target.label } : { ok: false, reason: said.reason }
         await writeFile(`${out}.tmp`, JSON.stringify(answer)).catch(() => {})
@@ -244,6 +223,39 @@ export function startSessions(d: SessionsDeps): { flush(): void; stop(): void }
       draining = false
     }
   }
+  /**
+   * TYPE INTO A TAB, CHECKED (the rule 2 exception, shared by the
+   * orchestrator's sends and dictation from outside the app). `decide` names
+   * the tab and its limits (orchestratorSend); then:
+   * - the tab's Claude mark is only what the tab's own output said, which a
+   *   program printing the same signal would earn, so Windows' process tree
+   *   is asked (security review, 2026-10-16);
+   * - that takes about a second, in which the switch, the tab or its state
+   *   can change: decided again, synchronously, right before typing, and the
+   *   same tab and session must win;
+   * - and once more before Enter: a question that opened in between would
+   *   take the Enter as its answer. The text then waits, unsent.
+   */
+  const typeChecked = async (decide: () => SendDecision, text: string): Promise<SendDecision> => {
+    let said = decide()
+    if (said.ok && (await agentUnder(said.target.id)) !== 'claude')
+      said = { ok: false, reason: `no Claude is running in ${said.target.label} (checked with Windows)` }
+    if (said.ok) {
+      const was = said.target
+      const now = decide()
+      said = now.ok && now.target.id === was.id && now.target.session === was.session ? now : { ok: false, reason: `${was.label} changed while it was checked: send again` }
+    }
+    if (said.ok) {
+      const id = said.target.id
+      writeTerm(id, pasteOf(text))
+      setTimeout(() => {
+        const still = decide()
+        if (still.ok && still.target.id === id) writeTerm(id, '\r')
+      }, SEND_ENTER_MS)
+    }
+    return said
+  }
+
   d.on(d.channels.front, (id: unknown) => {
     // The front tab first, then a fresh reading: a switch made while present
     // starts the new tab's look at once.
@@ -264,6 +276,16 @@ export function startSessions(d: SessionsDeps): { flush(): void; stop(): void }
   })
 
   return {
+    /** This copy's tabs for dictated text, the orchestrator marked only when it
+     *  is ACTIVE: switched on, and its Claude really running per Windows. */
+    published: async (): Promise<SendTab[]> => {
+      const live = ledger.live()
+      const lead = enabled ? live.find((t) => t.orchestrator) : undefined
+      const active = !!lead && (await agentUnder(lead.id)) === 'claude'
+      return live.map((t) => ({ ...t, orchestrator: active && t.id === lead!.id }))
+    },
+    /** Type dictated text into tab `id` and press Enter, checked. */
+    sendInto: (id: string, text: string): Promise<SendDecision> => typeChecked(() => decideInto(id, ledger.live()), text),
     // The close, the quit and a Windows shutdown: written now (rule 7).
     flush: () => {
       if (!enabled) return
diff --git a/src/preload/index.ts b/src/preload/index.ts
index a6ed98a7..9710638e 100644
--- a/src/preload/index.ts
+++ b/src/preload/index.ts
@@ -51,6 +51,23 @@ const api = {
    *  there, whatever else is open. Only ever arrives after a restore answered. */
   onOpenFolder: (cb: (cwd: string) => void): (() => void) => on(APP_CH.openFolder, cb),
 
+  /* ----- dictating from any app (2026-10-16) ----- */
+
+  /** The key, the mode, and whether it works from any app. */
+  dictAnywhere: (cfg: { on: boolean; hotkey: unknown; mode: string }): void => ipcRenderer.send(APP_CH.dictAnywhere, cfg),
+  /** The outside recording's live state, for the widget. */
+  dictLive: (v: { phase: string; text: string; level: number; starting: boolean }): void => ipcRenderer.send(APP_CH.dictLive, v),
+  /** What the outside recording heard, or why it heard nothing. */
+  dictRouted: (r: { text: string } | { message: string }): void => ipcRenderer.send(APP_CH.dictRouted, r),
+  /** The theme's inks, for the widget. */
+  dictLook: (l: { ground: string; text: string; dim: string; accent: string; edge: string }): void => ipcRenderer.send(APP_CH.dictLook, l),
+  /** Main's global key: start, stop or cancel the outside recording. */
+  onDictOutside: (cb: (action: 'start' | 'stop' | 'cancel') => void): (() => void) => on(APP_CH.dictOutside, cb),
+  /** This copy's part in the one dictation: service, client, or alone. */
+  onDictRole: (cb: (role: 'service' | 'client' | 'none') => void): (() => void) => on(APP_CH.dictRole, cb),
+  /** Dictated words for the tab in front: pasted at its cursor, never Enter. */
+  onDictPaste: (cb: (text: string) => void): (() => void) => on(APP_CH.dictPaste, cb),
+
   /* ----- the catch-up report's ledger (2026-10-16) ----- */
 
   /** The tabs as the report names them: label, folder, agent and its state. */
diff --git a/src/preload/overlay.ts b/src/preload/overlay.ts
new file mode 100644
index 00000000..eaf8ea31
--- /dev/null
+++ b/src/preload/overlay.ts
@@ -0,0 +1,15 @@
+import { contextBridge, ipcRenderer } from 'electron'
+import { OVERLAY_CH, type OverlayLook, type OverlayState } from '@shared/dictOverlay'
+
+// The dictation widget's whole view of the app (2026-10-16): states in, a pick
+// or a dismissal out. Sandboxed like the main window (rule 4).
+contextBridge.exposeInMainWorld('overlay', {
+  onState: (cb: (s: OverlayState) => void): void => {
+    ipcRenderer.on(OVERLAY_CH.state, (_e, s: OverlayState) => cb(s))
+  },
+  onLook: (cb: (l: OverlayLook) => void): void => {
+    ipcRenderer.on(OVERLAY_CH.look, (_e, l: OverlayLook) => cb(l))
+  },
+  pick: (id: string): void => ipcRenderer.send(OVERLAY_CH.pick, id),
+  dismiss: (): void => ipcRenderer.send(OVERLAY_CH.dismiss)
+})
diff --git a/src/renderer/overlay.html b/src/renderer/overlay.html
new file mode 100644
index 00000000..948a2b7d
--- /dev/null
+++ b/src/renderer/overlay.html
@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta http-equiv="Content-Security-Policy" content="default-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:" />
+    <title>Dictation</title>
+  </head>
+  <body>
+    <div id="card" data-phase="idle" role="status" aria-live="polite"></div>
+    <script type="module" src="./overlay/overlay.ts"></script>
+  </body>
+</html>
diff --git a/src/renderer/overlay/overlay.css b/src/renderer/overlay/overlay.css
new file mode 100644
index 00000000..d3bca452
--- /dev/null
+++ b/src/renderer/overlay/overlay.css
@@ -0,0 +1,238 @@
+/* THE DICTATION WIDGET (2026-10-16). The app's own inks, handed over by main
+   from the theme in front (rule 15); these are only the first frame's. Sized
+   for the owner at 225% zoom: 17 px words, 44 px rows. */
+:root {
+  --ground: #16161a;
+  --text: #f2f2f4;
+  --dim: #b4b4bd;
+  --accent: #e8925c;
+  --edge: #3a3a44;
+  color-scheme: dark;
+}
+* {
+  box-sizing: border-box;
+}
+html,
+body {
+  margin: 0;
+  height: 100%;
+  background: transparent;
+  overflow: hidden;
+  font: 15px/1.4 'Segoe UI Variable Text', 'Segoe UI', system-ui, sans-serif;
+  color: var(--text);
+  user-select: none;
+  -webkit-font-smoothing: antialiased;
+}
+body {
+  display: flex;
+  align-items: flex-end;
+  justify-content: center;
+  padding: 10px 14px 14px;
+}
+#card {
+  width: 100%;
+  border-radius: 14px;
+  background: color-mix(in srgb, var(--ground) 96%, transparent);
+  border: 1px solid color-mix(in srgb, var(--edge) 80%, var(--text) 20%);
+  box-shadow: 0 10px 28px -6px rgb(0 0 0 / 0.55), 0 2px 6px rgb(0 0 0 / 0.35);
+  padding: 14px 16px 12px;
+  animation: rise 160ms cubic-bezier(0.16, 1, 0.3, 1);
+}
+#card[data-phase='idle'] {
+  display: none;
+}
+@keyframes rise {
+  from {
+    transform: translateY(10px);
+    opacity: 0;
+  }
+}
+.head {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+}
+.badge {
+  position: relative;
+  display: grid;
+  place-items: center;
+  width: 34px;
+  height: 34px;
+  flex: none;
+  border-radius: 50%;
+  background: color-mix(in srgb, var(--accent) 22%, transparent);
+  color: var(--accent);
+}
+.badge.ring::after {
+  content: '';
+  position: absolute;
+  inset: -4px;
+  border-radius: 50%;
+  border: 2px solid var(--accent);
+  opacity: 0.55;
+  animation: breathe 1.4s ease-in-out infinite;
+}
+@keyframes breathe {
+  50% {
+    transform: scale(1.12);
+    opacity: 0.15;
+  }
+}
+.icon {
+  width: 19px;
+  height: 19px;
+  fill: none;
+  stroke: currentColor;
+  stroke-width: 1.9;
+  stroke-linecap: round;
+  stroke-linejoin: round;
+}
+.icon.check {
+  stroke-width: 2.6;
+}
+.icon.warn {
+  color: #f0b45a;
+}
+.title {
+  font-size: 17px;
+  font-weight: 600;
+  letter-spacing: -0.005em;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.meter {
+  height: 4px;
+  margin: 12px 0 10px;
+  border-radius: 2px;
+  background: color-mix(in srgb, var(--text) 10%, transparent);
+  overflow: hidden;
+}
+.level {
+  height: 100%;
+  width: 100%;
+  transform-origin: left center;
+  transform: scaleX(0.04);
+  background: var(--accent);
+  border-radius: 2px;
+  transition: transform 90ms linear;
+}
+.live,
+.said {
+  font-size: 17px;
+  line-height: 1.45;
+  color: var(--text);
+  display: -webkit-box;
+  -webkit-line-clamp: 3;
+  -webkit-box-orient: vertical;
+  overflow: hidden;
+  overflow-wrap: anywhere;
+}
+.said {
+  margin: 10px 0 10px;
+  padding-left: 12px;
+  border-left: 1px solid color-mix(in srgb, var(--accent) 70%, transparent);
+  color: var(--dim);
+  -webkit-line-clamp: 2;
+}
+.hint {
+  margin-top: 8px;
+  font-size: 13px;
+  color: var(--dim);
+}
+.dots {
+  margin: 12px 0 4px 46px;
+  width: 42px;
+  height: 6px;
+  background: radial-gradient(circle, var(--accent) 3px, transparent 3.5px) 0 0 / 14px 6px repeat-x;
+  animation: dots 900ms steps(3) infinite;
+}
+@keyframes dots {
+  to {
+    background-position: 42px 0;
+  }
+}
+.rows {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  max-height: 340px;
+  overflow: auto;
+}
+.row {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  min-height: 44px;
+  padding: 6px 10px;
+  border: 1px solid transparent;
+  border-radius: 9px;
+  background: color-mix(in srgb, var(--text) 5%, transparent);
+  color: var(--text);
+  font: inherit;
+  text-align: left;
+  cursor: pointer;
+}
+.row:hover {
+  background: color-mix(in srgb, var(--accent) 16%, transparent);
+  border-color: color-mix(in srgb, var(--accent) 45%, transparent);
+}
+.row:disabled {
+  cursor: default;
+  opacity: 0.55;
+}
+.row:disabled:hover {
+  background: color-mix(in srgb, var(--text) 5%, transparent);
+  border-color: transparent;
+}
+.num {
+  display: grid;
+  place-items: center;
+  width: 26px;
+  height: 26px;
+  flex: none;
+  border-radius: 7px;
+  background: color-mix(in srgb, var(--accent) 24%, transparent);
+  color: var(--text);
+  font-weight: 700;
+  font-variant-numeric: tabular-nums;
+}
+.name {
+  display: flex;
+  flex-direction: column;
+  min-width: 0;
+  flex: 1;
+}
+.label {
+  font-weight: 600;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.folder {
+  font-size: 12.5px;
+  color: var(--dim);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.chip {
+  flex: none;
+  font-size: 12px;
+  padding: 2px 8px;
+  border-radius: 999px;
+  color: var(--dim);
+  border: 1px solid color-mix(in srgb, var(--text) 18%, transparent);
+}
+.chip.orchestrator {
+  color: var(--accent);
+  border-color: color-mix(in srgb, var(--accent) 55%, transparent);
+}
+@media (prefers-reduced-motion: reduce) {
+  #card,
+  .badge.ring::after,
+  .dots {
+    animation: none;
+  }
+}
diff --git a/src/renderer/overlay/overlay.ts b/src/renderer/overlay/overlay.ts
new file mode 100644
index 00000000..af48371e
--- /dev/null
+++ b/src/renderer/overlay/overlay.ts
@@ -0,0 +1,119 @@
+import './overlay.css'
+import type { OverlayLook, OverlayRow, OverlayState } from '../../shared/dictOverlay'
+
+/**
+ * THE DICTATION WIDGET (owner, 2026-10-16): above every window, never taking
+ * focus, sized for 225% zoom. Listening (the level and the live words), then
+ * the outcome: sent with a check mark, or the numbered sessions to pick from.
+ * Plain DOM: it opens on a key press and must draw at once.
+ */
+
+declare global {
+  interface Window {
+    overlay: {
+      onState(cb: (s: OverlayState) => void): void
+      onLook(cb: (l: OverlayLook) => void): void
+      pick(id: string): void
+      dismiss(): void
+    }
+  }
+}
+
+const card = document.getElementById('card') as HTMLDivElement
+
+const el = <K extends keyof HTMLElementTagNameMap>(tag: K, cls?: string, text?: string): HTMLElementTagNameMap[K] => {
+  const e = document.createElement(tag)
+  if (cls) e.className = cls
+  if (text !== undefined) e.textContent = text
+  return e
+}
+
+const svg = (paths: string, cls: string): SVGSVGElement => {
+  const ns = 'http://www.w3.org/2000/svg'
+  const s = document.createElementNS(ns, 'svg')
+  s.setAttribute('viewBox', '0 0 24 24')
+  s.setAttribute('class', cls)
+  s.setAttribute('aria-hidden', 'true')
+  for (const d of paths.split('|')) {
+    const p = document.createElementNS(ns, 'path')
+    p.setAttribute('d', d)
+    s.appendChild(p)
+  }
+  return s
+}
+const MIC = 'M12 3.5a3 3 0 0 0-3 3v5a3 3 0 0 0 6 0v-5a3 3 0 0 0-3-3z|M6 11.5a6 6 0 0 0 12 0|M12 17.5v3'
+const CHECK = 'M6 12.5l4 4 8-9'
+const WARN = 'M12 4l9 16H3z|M12 10v4|M12 17.2v.1'
+
+function head(icon: SVGSVGElement, title: string, ring = false): HTMLDivElement {
+  const h = el('div', 'head')
+  const badge = el('div', ring ? 'badge ring' : 'badge')
+  badge.appendChild(icon)
+  h.append(badge, el('div', 'title', title))
+  return h
+}
+
+function rowEl(r: OverlayRow): HTMLButtonElement {
+  const b = el('button', 'row')
+  b.type = 'button'
+  b.dataset.pick = r.id
+  if (r.disabled) {
+    b.disabled = true
+    b.title = r.disabled
+  }
+  b.append(el('span', 'num', String(r.n)))
+  const name = el('span', 'name')
+  name.append(el('span', 'label', r.label), el('span', 'folder', r.copy ? `${r.copy} \u00b7 ${r.folder}` : r.folder))
+  b.append(name)
+  const chip = r.lead ? 'orchestrator' : r.disabled ? 'asking' : r.state === 'working' ? 'working' : null
+  if (chip) b.append(el('span', `chip ${chip}`, chip))
+  b.addEventListener('click', () => window.overlay.pick(r.id))
+  return b
+}
+
+let levelBar: HTMLDivElement | null = null
+
+function draw(s: OverlayState): void {
+  card.dataset.phase = s.phase
+  if (s.phase === 'listening' && levelBar && card.querySelector('.live')) {
+    // A level or words update: no rebuild, so nothing flickers.
+    levelBar.style.transform = `scaleX(${Math.max(0.04, Math.min(1, s.level * 3))})`
+    ;(card.querySelector('.live') as HTMLElement).textContent = s.text || (s.starting ? 'Starting the speech engine' : 'Speak now')
+    return
+  }
+  card.replaceChildren()
+  levelBar = null
+  if (s.phase === 'listening') {
+    card.append(head(svg(MIC, 'icon'), 'Listening', true))
+    const meter = el('div', 'meter')
+    levelBar = el('div', 'level')
+    meter.append(levelBar)
+    card.append(meter, el('div', 'live', s.text || (s.starting ? 'Starting the speech engine' : 'Speak now')))
+    card.append(el('div', 'hint', 'Let go to finish. Esc cancels.'))
+  } else if (s.phase === 'transcribing') {
+    card.append(head(svg(MIC, 'icon'), 'Transcribing'))
+    card.append(el('div', 'dots'))
+  } else if (s.phase === 'pick') {
+    card.append(head(svg(MIC, 'icon'), 'Send to'))
+    card.append(el('div', 'said', s.text))
+    const list = el('div', 'rows')
+    s.rows.forEach((r) => list.append(rowEl(r)))
+    card.append(list, el('div', 'hint', 'Press a number or click. Esc keeps it unsent.'))
+  } else if (s.phase === 'sending') {
+    card.append(head(svg(MIC, 'icon'), `Sending to ${s.to}`))
+  } else if (s.phase === 'sent') {
+    card.append(head(svg(CHECK, 'icon check'), `Sent to ${s.to}`))
+  } else if (s.phase === 'note') {
+    card.append(head(svg(s.tone === 'warn' ? WARN : MIC, s.tone === 'warn' ? 'icon warn' : 'icon'), s.message))
+  }
+}
+
+window.overlay.onState(draw)
+window.overlay.onLook((l) => {
+  const r = document.documentElement.style
+  r.setProperty('--ground', l.ground)
+  r.setProperty('--text', l.text)
+  r.setProperty('--dim', l.dim)
+  r.setProperty('--accent', l.accent)
+  r.setProperty('--edge', l.edge)
+})
diff --git a/src/renderer/src/App.tsx b/src/renderer/src/App.tsx
index 347a1263..e9d06d5c 100644
--- a/src/renderer/src/App.tsx
+++ b/src/renderer/src/App.tsx
@@ -88,6 +88,7 @@ import {
   holdsWindowClose
 } from '@core/renderer/lib/agentClose'
 import { pluginChoice, termFontStack, useOrchestratorOn } from '@core/renderer/lib/termLook'
+import { useDictateAnywhereBridge } from './lib/dictateAnywhere'
 import { claudeResume, ledgerState, useLedgerReport } from './lib/ledgerReport'
 import { useTaskbarBadge } from './lib/taskbarBadge'
 import { usePaintedChrome } from './lib/paintChrome'
@@ -559,6 +560,8 @@ export default function App(): JSX.Element {
   useTaskbarBadge({ doneIds, questionIds, workingIds, failedIds })
 
   const orchestrating = useOrchestratorOn()
+  // DICTATE FROM ANY APP (2026-10-16, lib/dictateAnywhere).
+  useDictateAnywhereBridge()
   // THE CATCH-UP REPORT'S LEDGER (2026-10-16, lib/ledgerReport): main keeps
   // which Claude session is in which tab and when the owner really looked.
   const allLabels = tabLabels(state.tabs)
diff --git a/src/renderer/src/components/settings/DictateAnywherePage.tsx b/src/renderer/src/components/settings/DictateAnywherePage.tsx
new file mode 100644
index 00000000..6ff26f3b
--- /dev/null
+++ b/src/renderer/src/components/settings/DictateAnywherePage.tsx
@@ -0,0 +1,30 @@
+import type { JSX } from 'react'
+import { Switch } from '@core/renderer/settings/fields'
+import { SettingRow } from '@core/renderer/settings/layout/SettingRow'
+import { SettingsSection } from '@core/renderer/settings/layout/SettingsSection'
+import { useDictationEnabled } from '@core/renderer/lib/dictationPrefs'
+import { setDictateAnywhere, useDictateAnywhere } from '../../lib/dictateAnywhere'
+import { APP_SECTIONS, appOpt } from './appOptions'
+
+/**
+ * DICTATE FROM ANY APP (owner, 2026-10-16), this app's own row at the foot of
+ * the Dictation page: the key with another app in front, the widget, and the
+ * words sent to the orchestrator or to the session picked from the widget.
+ */
+export function DictateAnywhereRow(): JSX.Element {
+  const o = appOpt('dictation-anywhere')
+  const on = useDictateAnywhere()
+  const enabled = useDictationEnabled()
+  return (
+    <SettingsSection id="anywhere" title={APP_SECTIONS.anywhere}>
+      <span
+        title="Press the dictation key with any app in front. A widget shows what you say, then sends it to the orchestrator tab, or lets you pick a Claude session with a click or its number. Not in windows run as administrator."
+        className="contents"
+      >
+        <SettingRow id="dictation-anywhere" icon={o.icon} label={o.label} sub={o.sub} tap>
+          <Switch on={on} onChange={setDictateAnywhere} label={o.label} disabled={!enabled} />
+        </SettingRow>
+      </span>
+    </SettingsSection>
+  )
+}
diff --git a/src/renderer/src/components/settings/Settings.tsx b/src/renderer/src/components/settings/Settings.tsx
index c36e395f..5c76c347 100644
--- a/src/renderer/src/components/settings/Settings.tsx
+++ b/src/renderer/src/components/settings/Settings.tsx
@@ -2,6 +2,7 @@ import { useEffect, useMemo, useState, type JSX } from 'react'
 import { dictationHost } from '@core/renderer/host'
 import { SettingsFrame } from '@core/renderer/settings/layout/SettingsFrame'
 import { DiagnosticsPage } from '@core/renderer/settings/sections/DiagnosticsPage'
+import { DictateAnywhereRow } from './DictateAnywherePage'
 import { DictationPage } from '@core/renderer/settings/sections/DictationPage'
 import { AboutPage } from './AboutPage'
 import { AgentsPage } from './AgentsPage'
@@ -63,7 +64,7 @@ export default function Settings({
       ) : page === 'agents' ? (
         <AgentsPage />
       ) : page === 'dictation' ? (
-        <DictationPage />
+        <DictationPage after={<DictateAnywhereRow />} />
       ) : page === 'diagnostics' ? (
         <DiagnosticsPage api={window.prism} />
       ) : (
diff --git a/src/renderer/src/components/settings/appOptions.test.ts b/src/renderer/src/components/settings/appOptions.test.ts
index 2e954e0a..2428244e 100644
--- a/src/renderer/src/components/settings/appOptions.test.ts
+++ b/src/renderer/src/components/settings/appOptions.test.ts
@@ -43,6 +43,7 @@ describe("this app's own settings rows", () => {
         "newtab-mode=prism.newtab.mode+prism.newtab.folder",
         "explorer-verb=registry",
         "orchestrator=prism.term.orchestrator",
+        "dictation-anywhere=prism.dictation.anywhere",
         "taskbar-badge=prism.window.taskbarBadge",
         "app-version=null",
       ]
diff --git a/src/renderer/src/components/settings/appOptions.ts b/src/renderer/src/components/settings/appOptions.ts
index fe7edaa0..1280e3f2 100644
--- a/src/renderer/src/components/settings/appOptions.ts
+++ b/src/renderer/src/components/settings/appOptions.ts
@@ -18,7 +18,7 @@ export interface AppOption {
   id: string
   label: string
   sub: string
-  section: 'window' | 'opening' | 'keys' | 'theme' | 'marks' | 'orchestrator' | 'about'
+  section: 'window' | 'opening' | 'keys' | 'theme' | 'marks' | 'orchestrator' | 'anywhere' | 'about'
   page: AppPageId
   icon: string
   keywords?: string
@@ -37,12 +37,13 @@ export const APP_OPTIONS: readonly AppOption[] = [
   { id: 'newtab-mode', label: 'Folder for new tabs', sub: 'Opens in your user folder.', section: 'opening', page: 'terminal', icon: 'newtab', keywords: 'folder home directory start new tab ask', store: ['prism.newtab.mode', 'prism.newtab.folder'] },
   { id: 'explorer-verb', label: 'Add to the Explorer menu', sub: 'Open terminal here, on every folder.', section: 'opening', page: 'terminal', icon: 'menu', keywords: 'context menu right click open here', store: 'registry' },
   { id: 'orchestrator', label: 'Orchestrator', sub: 'Reports on other tabs, and a lead tab.', section: 'orchestrator', page: 'agents', icon: 'lead', keywords: 'orchestrator lead catch up report summary summarise away sessions tabs claude skill plugin promote', store: ['prism.term.orchestrator'] },
+  { id: 'dictation-anywhere', label: 'Dictate from any app', sub: 'The key works with another app in front.', section: 'anywhere', page: 'dictation', icon: 'mic', keywords: 'global anywhere outside background other app widget overlay send session orchestrator hotkey ctrl win', store: ['prism.dictation.anywhere'] },
   { id: 'taskbar-badge', label: 'Count marked tabs on the taskbar', sub: 'A number on the taskbar button.', section: 'marks', page: 'agents', icon: 'taskbar', keywords: 'count number badge overlay', store: ['prism.window.taskbarBadge'] },
   { id: 'app-version', label: 'Version', sub: 'The version you are running.', section: 'about', page: 'about', icon: 'version', keywords: 'update release number', store: null }
 ]
 
 /** This app's own section headings (the About section has none). */
-export const APP_SECTIONS = { window: 'Window', opening: 'Opening terminals', keys: 'Keys', orchestrator: 'Orchestrator (beta)', about: '' } as const
+export const APP_SECTIONS = { window: 'Window', opening: 'Opening terminals', keys: 'Keys', orchestrator: 'Orchestrator (beta)', anywhere: 'From any app', about: '' } as const
 
 /** One of this app's rows by id. Throws on a typo, which the tests find. */
 export function appOpt(id: string): AppOption {
diff --git a/src/renderer/src/components/settings/settingsIndex.ts b/src/renderer/src/components/settings/settingsIndex.ts
index b241c8cd..635840e1 100644
--- a/src/renderer/src/components/settings/settingsIndex.ts
+++ b/src/renderer/src/components/settings/settingsIndex.ts
@@ -43,7 +43,7 @@ export const ROW_ORDER = [
   'agent-indicator', 'agent-done-on', 'agent-rainbow', 'agent-question-on', 'agent-failed-on', 'taskbar-badge', 'agent-hooks', 'orchestrator',
   'agent-color', 'agent-done-color', 'agent-question-color',
   'dictation-enabled', 'dictation-mode', 'dictation-hotkey', 'dictation-mic', 'dictation-language',
-  'dictation-pause-media', 'dictation-sounds', 'dictation-model', 'dictation-gpu',
+  'dictation-pause-media', 'dictation-sounds', 'dictation-model', 'dictation-gpu', 'dictation-anywhere',
   'diag-verbose', 'diag-folder', 'diag-mark',
   'app-version'
 ] as const
diff --git a/src/renderer/src/lib/dictateAnywhere.ts b/src/renderer/src/lib/dictateAnywhere.ts
new file mode 100644
index 00000000..00ad78c1
--- /dev/null
+++ b/src/renderer/src/lib/dictateAnywhere.ts
@@ -0,0 +1,104 @@
+import { useEffect } from 'react'
+import { boolPref } from '@core/renderer/lib/prefStore'
+import {
+  dictationOutside,
+  dictationView,
+  keepDictationWarm,
+  onDictationLevel,
+  onDictationView,
+  OUTSIDE,
+  pasteIntoFront,
+  setDictationAutoWarm,
+  setDictationPageKeys,
+  setDictationRoute
+} from '@core/renderer/lib/dictation'
+import { dictationEnabled, useDictationEnabled, useDictationHotkey, useDictationMode } from '@core/renderer/lib/dictationPrefs'
+
+/**
+ * DICTATE FROM ANY APP (owner, 2026-10-16; spec:
+ * docs/superpowers/specs/2026-10-16-dictate-anywhere.md). THIS APP'S OWN
+ * setting, on by default (whenever dictation is on): main runs the key from
+ * any app (globalDictKey); the page records (core dictation, `OUTSIDE`) and
+ * hands what it heard to main, which routes it (the orchestrator, or a pick).
+ */
+const pref = boolPref('prism.dictation.anywhere', true)
+export const dictateAnywhere = pref.get
+export const setDictateAnywhere = pref.set
+export const useDictateAnywhere = pref.use
+
+/** The theme's inks as the page wears them, for the widget (rule 15). */
+function look(): { ground: string; text: string; dim: string; accent: string; edge: string } {
+  const cs = getComputedStyle(document.documentElement)
+  const v = (name: string, fallback: string): string => cs.getPropertyValue(name).trim() || fallback
+  return {
+    ground: v('--p-tabs', '#16161a'),
+    text: v('--p-text', '#f2f2f4'),
+    dim: v('--p-dim', '#b4b4bd'),
+    accent: v('--p-accent-hi', '#e8925c'),
+    edge: v('--p-divider', '#3a3a44')
+  }
+}
+
+const LEVEL_EVERY_MS = 66
+
+export function useDictateAnywhereBridge(): void {
+  const enabled = useDictationEnabled()
+  const anywhere = useDictateAnywhere()
+  const hotkey = useDictationHotkey()
+  const mode = useDictationMode()
+  // Main runs the key only while both are on.
+  useEffect(() => {
+    window.prism.dictAnywhere({ on: enabled && anywhere, hotkey, mode })
+  }, [enabled, anywhere, hotkey, mode])
+
+  useEffect(() => {
+    // What the outside recording heard goes to main, never into a tab here.
+    setDictationRoute((r) => window.prism.dictRouted(r))
+    let level = 0
+    let lastSent = 0
+    const live = (): void => {
+      const v = dictationView()
+      if (v.sessionId !== OUTSIDE) return
+      window.prism.dictLive({
+        phase: v.phase === 'idle' ? 'idle' : v.phase,
+        text: v.liveText,
+        level,
+        starting: v.starting
+      })
+    }
+    const offView = onDictationView(live)
+    const offLevel = onDictationLevel((l) => {
+      level = l
+      const now = performance.now()
+      if (now - lastSent < LEVEL_EVERY_MS) return
+      lastSent = now
+      if (dictationView().sessionId === OUTSIDE) live()
+    })
+    const offKey = window.prism.onDictOutside((action) => {
+      if (action === 'start') window.prism.dictLook(look())
+      dictationOutside(action)
+    })
+    // ONE DICTATION (owner, 2026-10-17): with a service in reach (this copy or
+    // another) the hook reads the key, so this window does not; only the
+    // service's copy keeps an engine warm.
+    const offRole = window.prism.onDictRole((role) => {
+      setDictationPageKeys(role === 'none')
+      setDictationAutoWarm(role !== 'client')
+      if (role === 'client') window.prism.dictationStop()
+      else if (role === 'service' && dictationEnabled()) keepDictationWarm()
+    })
+    const offPaste = window.prism.onDictPaste((text) => {
+      pasteIntoFront(text)
+    })
+    return () => {
+      setDictationRoute(null)
+      setDictationPageKeys(true)
+      setDictationAutoWarm(true)
+      offView()
+      offLevel()
+      offKey()
+      offRole()
+      offPaste()
+    }
+  }, [])
+}
diff --git a/src/shared/channels.ts b/src/shared/channels.ts
index 01f72892..40825817 100644
--- a/src/shared/channels.ts
+++ b/src/shared/channels.ts
@@ -16,6 +16,13 @@ export const APP_CH = {
   closeRequest: 'close:request',
   openFolder: 'open:folder',
   dialogPickFolder: 'dialog:pick-folder',
+  dictAnywhere: 'dict:anywhere',
+  dictLive: 'dict:live',
+  dictLook: 'dict:look',
+  dictOutside: 'dict:outside',
+  dictPaste: 'dict:paste',
+  dictRole: 'dict:role',
+  dictRouted: 'dict:routed',
   ledgerEnable: 'ledger:enable',
   ledgerEngage: 'ledger:engage',
   ledgerFront: 'ledger:front',
diff --git a/src/shared/dictOverlay.ts b/src/shared/dictOverlay.ts
new file mode 100644
index 00000000..96a50f59
--- /dev/null
+++ b/src/shared/dictOverlay.ts
@@ -0,0 +1,32 @@
+/**
+ * THE DICTATION WIDGET'S STATES (owner, 2026-10-16: "when you start the
+ * dictation outside the app you should still see like a sort of widget ... in
+ * whatever window you're in"). Main sends one of these to the widget's page;
+ * the page draws it and says back only a pick or a dismissal.
+ */
+/** `copy`: which copy of the app the tab is in ("Stable"), when more than one is open. */
+export type OverlayRow = { id: string; n: number; label: string; folder: string; state: string | null; disabled: string | null; lead: boolean; copy: string | null }
+
+export type OverlayState =
+  | { phase: 'listening'; text: string; level: number; starting: boolean }
+  | { phase: 'transcribing' }
+  | { phase: 'pick'; text: string; rows: OverlayRow[] }
+  | { phase: 'sending'; to: string }
+  | { phase: 'sent'; to: string }
+  | { phase: 'note'; message: string; tone: 'quiet' | 'warn' }
+
+/** The app's look, so the widget wears the theme (rule 15's inks). */
+export interface OverlayLook {
+  ground: string
+  text: string
+  dim: string
+  accent: string
+  edge: string
+}
+
+export const OVERLAY_CH = {
+  state: 'overlay:state',
+  look: 'overlay:look',
+  pick: 'overlay:pick',
+  dismiss: 'overlay:dismiss'
+} as const
diff --git a/tools/e2e/run.mjs b/tools/e2e/run.mjs
index 6e08735d..7342bb2f 100644
--- a/tools/e2e/run.mjs
+++ b/tools/e2e/run.mjs
@@ -15,7 +15,7 @@
 // that "closed" its window has left a process holding the single-instance lock.
 import { _electron as electron } from 'playwright-core'
 import { execFileSync, spawn } from 'child_process'
-import { createHash } from 'crypto'
+import { createHash, randomBytes } from 'crypto'
 import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, truncateSync, writeFileSync } from 'fs'
 import { tmpdir } from 'os'
 import { createServer } from 'http'
@@ -172,7 +172,7 @@ const PREF_PAGE = {
   'term-shell': 'terminal', 'newtab-mode': 'terminal', 'explorer-verb': 'terminal', 'term-font-family': 'terminal',
   'term-font': 'terminal', 'help-enabled': 'terminal',
   'agent-indicator': 'agents', 'agent-done-on': 'agents', 'agent-rainbow': 'agents', 'agent-question-on': 'agents', 'agent-failed-on': 'agents',
-  'taskbar-badge': 'agents', 'agent-hooks': 'agents', 'orchestrator': 'agents', 'agent-color': 'agents', 'agent-done-color': 'agents',
+  'taskbar-badge': 'agents', 'agent-hooks': 'agents', 'orchestrator': 'agents', 'dictation-anywhere': 'dictation', 'agent-color': 'agents', 'agent-done-color': 'agents',
   'agent-question-color': 'agents',
   'dictation-enabled': 'dictation', 'dictation-mode': 'dictation', 'dictation-hotkey': 'dictation', 'dictation-mic': 'dictation',
   'dictation-language': 'dictation', 'dictation-pause-media': 'dictation', 'dictation-sounds': 'dictation',
@@ -3158,6 +3158,174 @@ const scenarios = {
     ok(!!list()?.sessions?.[SID], 'the list written while it was on stays on disk')
   },
 
+  /**
+   * DICTATE FROM ANY APP (owner, 2026-10-16; spec:
+   * docs/superpowers/specs/2026-10-16-dictate-anywhere.md). The suite never
+   * runs the real keyboard hook: helper lines arrive through a seam, and what
+   * was heard is handed to main as the page would. A stand-in Claude (a copy of
+   * PowerShell named claude.exe, so Windows' process check passes) takes the
+   * words, and runs them, which proves they were typed and entered.
+   * - No orchestrator: the widget lists the sessions, numbered; "1" sends.
+   * - An ACTIVE orchestrator: it is sent there with no list.
+   * - The key with the app not in front opens the widget.
+   */
+  async dictateAnywhere(ok) {
+    const w = world()
+    const { app, page } = await launch(w, { args: [w.alpha] })
+    const SID = 'f1f2f3f4-a5a6-4b70-8c9d-0e1f2a3b4c5d'
+    const dir = await app.evaluate(({ app: a }) => a.getPath('userData'))
+    const shells = () => page.locator('[data-tab]').filter({ hasNotText: /^Settings$/ })
+    const shown = () =>
+      page.evaluate(() => [...document.querySelectorAll('.xterm')].filter((x) => x.offsetParent !== null).map((x) => x.querySelector('.xterm-rows')?.textContent ?? '').join('\n'))
+    const widget = async () => app.windows().find((p) => p.url().includes('overlay.html')) ?? null
+    const widgetText = async () => {
+      const p = await widget()
+      return p ? await p.evaluate(() => document.getElementById('card')?.textContent ?? '').catch(() => '') : ''
+    }
+    try {
+      await until(async () => (await tabLabels(page)).length === 1)
+      await polled(page)
+      // The stand-in Claude.
+      await page.locator('.xterm').first().click({ force: true })
+      await typeLine(page, hookSay('done', `;session=${SID}`))
+      const fake = dir + '\\stand-in\\claude.exe'
+      mkdirSync(dir + '\\stand-in', { recursive: true })
+      copyFileSync('C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe', fake)
+      await typeLine(page, `& '${fake}' -NoLogo -NoProfile`)
+      await sleep(2500)
+
+      // 1. No orchestrator: the list, then "1".
+      await page.evaluate(() => window.prism.dictRouted({ text: "Write-Output ('DICT-' + 'OK')" }))
+      ok(!!(await until(async () => (await widgetText()).includes('Send to'), 10000, 100)), 'with no orchestrator the widget lists the sessions')
+      const w1 = await widgetText()
+      ok(w1.includes('1') && w1.includes('alpha'), `numbered, by tab (${w1.slice(0, 120)})`)
+      const unfocusable = await app.evaluate(({ BrowserWindow }) => {
+        const o = BrowserWindow.getAllWindows().find((x) => x.webContents.getURL().includes('overlay.html'))
+        return o ? !o.isFocusable() && o.isAlwaysOnTop() : null
+      })
+      ok(unfocusable === true, 'the widget never takes focus and stays on top')
+      const wp = await widget()
+      await wp?.screenshot({ path: resolve(process.cwd(), '.e2e-shots/dictation-widget-pick.png') }).catch(() => {})
+      await app.evaluate(() => globalThis.__e2eDictLine('p 1'))
+      ok(!!(await until(async () => (await widgetText()).includes('Sent to alpha'), 15000, 100)), 'the number sends it, and the widget says sent')
+      await wp?.screenshot({ path: resolve(process.cwd(), '.e2e-shots/dictation-widget-sent.png') }).catch(() => {})
+      ok(!!(await until(async () => (await shown()).includes('DICT-OK'), 8000, 100)), 'and it was typed and entered in that session')
+
+      // 2. An active orchestrator: no list.
+      const sw = (await gotoPref(page, 'orchestrator')).locator('[role="switch"]')
+      await sw.click()
+      await page.keyboard.press('Control+w')
+      await until(async () => (await page.locator('[data-tab]').count()) === 1, 4000, 50)
+      await shells().nth(0).click({ button: 'right' })
+      await page.locator('[role="menu"] [role="menuitem"]', { hasText: 'Make orchestrator' }).click()
+      await sleep(800)
+      await page.evaluate(() => window.prism.dictRouted({ text: "Write-Output ('LEAD-' + 'OK')" }))
+      ok(!!(await until(async () => (await widgetText()).includes('Sent to alpha'), 15000, 100)), 'with an active orchestrator it is sent straight there')
+      ok(!(await widgetText()).includes('Send to'), 'with no list')
+      ok(!!(await until(async () => (await shown()).includes('LEAD-OK'), 8000, 100)), 'and it arrived')
+
+      // 3. The key, with the app not in front (the suite's window is parked
+      // and unfocused): Ctrl then Win, held past the solo wait.
+      await page.evaluate(() => localStorage.setItem('prism.dictation.enabled', '1'))
+      await gotoPref(page, 'dictation-anywhere')
+      await page.keyboard.press('Control+w')
+      await sleep(600)
+      await app.evaluate(() => {
+        globalThis.__e2eDictLine('d A2')
+        globalThis.__e2eDictLine('d 5B')
+      })
+      await sleep(500)
+      const keyed = await widgetText()
+      ok(/Listening|speech model|Speak now/.test(keyed), `Ctrl+Win from another app opens the widget (${keyed.slice(0, 80)})`)
+      await app.evaluate(() => {
+        globalThis.__e2eDictLine('u 5B')
+        globalThis.__e2eDictLine('u A2')
+      })
+    } finally {
+      await closeApp(app)
+    }
+  },
+
+  /**
+   * ONE DICTATION FOR EVERY COPY (owner, 2026-10-17: "there should be one
+   * dictation engine for both ... it should show all sessions open in one ui
+   * from both instances"; spec: docs/superpowers/specs/2026-10-17-one-dictation.md).
+   * Two copies on a pipe of the scenario's own; the first is made the service
+   * through the seam (the suite runs no real hook).
+   * - The service's list holds the OTHER copy's Claude, named by its copy, and
+   *   a pick is typed and entered there by that copy.
+   * - With that copy's window in front at the press, the words are pasted at
+   *   its front tab's cursor, no Enter.
+   * - The service closes: the other copy takes over and lists its own tab.
+   */
+  async dictateTwoCopies(ok) {
+    const pipe = `\\\\.\\pipe\\pt-e2e-dict-${process.pid}-${Date.now()}`
+    const wa = world()
+    const wb = world()
+    // The scenario's own link key: both copies prove they hold it (dictationLink).
+    const env = { PT_E2E_DICT_PIPE: pipe, PT_E2E_DICT_KEY: randomBytes(32).toString('hex') }
+    const A = await launch(wa, { args: [wa.alpha], env })
+    const B = await launch(wb, { args: [wb.beta], env })
+    const SID = 'b1b2b3b4-a5a6-4b70-8c9d-0e1f2a3b4c5d'
+    const shown = (page) =>
+      page.evaluate(() => [...document.querySelectorAll('.xterm')].filter((x) => x.offsetParent !== null).map((x) => x.querySelector('.xterm-rows')?.textContent ?? '').join('\n'))
+    const widgetText = async (app) => {
+      const p = app.windows().find((x) => x.url().includes('overlay.html'))
+      return p ? await p.evaluate(() => document.getElementById('card')?.textContent ?? '').catch(() => '') : ''
+    }
+    let aOpen = true
+    try {
+      await until(async () => (await tabLabels(B.page)).length === 1)
+      await polled(B.page)
+      // B's stand-in Claude (a copy of PowerShell named claude.exe).
+      const dir = await B.app.evaluate(({ app: a }) => a.getPath('userData'))
+      await B.page.locator('.xterm').first().click({ force: true })
+      await typeLine(B.page, hookSay('done', `;session=${SID}`))
+      const fake = dir + '\\stand-in\\claude.exe'
+      mkdirSync(dir + '\\stand-in', { recursive: true })
+      copyFileSync('C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe', fake)
+      await typeLine(B.page, `& '${fake}' -NoLogo -NoProfile`)
+      await sleep(2500)
+
+      // A takes the key: the service. B finds it on the pipe.
+      await A.app.evaluate(() => globalThis.__e2eDictLine('ready'))
+      await sleep(1800)
+
+      // 1. A's list holds B's Claude, named by its copy; "1" sends it there.
+      await A.app.evaluate(() => globalThis.__e2eDictRoute("Write-Output ('TWO-' + 'OK')", null))
+      ok(!!(await until(async () => (await widgetText(A.app)).includes('Send to'), 10000, 100)), 'the service lists the sessions')
+      const listed = await widgetText(A.app)
+      ok(listed.includes('beta') && listed.includes('\u00b7'), `the other copy's Claude is in the list, named by its copy (${listed.slice(0, 160)})`)
+      await A.app.evaluate(() => globalThis.__e2eDictLine('p 1'))
+      ok(!!(await until(async () => (await widgetText(A.app)).includes('Sent to beta'), 15000, 100)), 'the pick is sent to the other copy')
+      ok(!!(await until(async () => (await shown(B.page)).includes('TWO-OK'), 8000, 100)), 'and that copy typed and entered it')
+
+      // 2. B's window in front at the press: pasted at its cursor, no Enter.
+      const pidB = await B.app.evaluate(() => process.pid)
+      await A.app.evaluate((_e, pid) => globalThis.__e2eDictRoute('echo PASTEDB', pid), pidB)
+      ok(!!(await until(async () => (await shown(B.page)).includes('echo PASTEDB'), 8000, 100)), 'with that copy in front the words are typed at its cursor')
+      await sleep(800)
+      const after = await shown(B.page)
+      ok(!/^PASTEDB\s*$/m.test(after), 'and not entered')
+      ok((await widgetText(A.app)).includes('Typed into the tab in front'), 'the widget says where they went')
+      await B.page.keyboard.press('Control+c')
+
+      // 3. The service closes: B takes over and lists its own tab.
+      await closeApp(A.app)
+      aOpen = false
+      await sleep(1500)
+      await B.app.evaluate(() => globalThis.__e2eDictLine('ready'))
+      await B.app.evaluate(() => globalThis.__e2eDictRoute('Write-Output hi', null))
+      ok(!!(await until(async () => (await widgetText(B.app)).includes('Send to'), 10000, 100)), 'the other copy takes over the dictation')
+      const own = await widgetText(B.app)
+      ok(own.includes('beta') && !own.includes('\u00b7'), `with one copy left, no copy names (${own.slice(0, 120)})`)
+      await B.app.evaluate(() => globalThis.__e2eDictLine('x'))
+    } finally {
+      if (aOpen) await closeApp(A.app)
+      await closeApp(B.app)
+    }
+  },
+
   /**
    * NO WINDOWS SYSTEM MENU ON A RIGHT-CLICK (owner, 2026-10-13: "stop chromium
    * right click menus like this from appearing in the terminal"). Windows
@@ -3479,6 +3647,17 @@ const scenarios = {
       const early = await look()
       await page.screenshot({ path: resolve(process.cwd(), '.e2e-shots/launch-skeleton.png') }).catch(() => {})
       ok(early.skeleton, 'the tab in front wears the skeleton while its conversation comes back')
+      // Nothing of the terminal on top of it (owner, 2026-10-17: thin blue
+      // lines over the skeleton). They were the link decorations
+      // (termLinkPaint, xterm's z-index 6) of the paths Claude prints as it
+      // resumes, above the skeleton's z-index 1: the terminal's region must be
+      // a stacking context of its own, so no layer of xterm's leaves it.
+      const covered = await page.evaluate(() => {
+        const sk = document.querySelector('[data-resume-skeleton="shown"]')
+        const region = sk?.parentElement?.querySelector('[data-term-region]')
+        return region ? getComputedStyle(region).isolation : null
+      })
+      ok(covered === 'isolate', `no layer of the terminal can paint over the skeleton (isolation: ${covered})`)
       ok(early.rings === 3, `every tab shows the loading ring (${early.rings})`)
       ok(early.ringsAtEnd === 3, `each at the tab's end, where the Ring goes (${early.ringsAtEnd})`)
       let bare = false
@@ -7924,6 +8103,9 @@ const scenarios = {
     await page.evaluate(() => {
       localStorage.setItem('prism.dictation.model', 'tiny')
       localStorage.setItem('prism.dictation.sounds', '0')
+      // These scenarios hold Right Alt, the default until 2026-10-16 (now Ctrl+Win):
+      // they set it, so the AltGr-era rules keep their real-key proof.
+      localStorage.setItem('prism.dictation.hotkey', JSON.stringify({ code: 'AltRight', ctrl: false, alt: false, shift: false, meta: false }))
     })
     await page.locator('[data-title-settings]').click()
     await page.locator('[data-settings-tab="dictation"]').click()
@@ -8174,6 +8356,9 @@ const scenarios = {
     // so the English sentence must still come back in English.
     await page.evaluate(() => {
       localStorage.setItem('prism.dictation.model', 'parakeet-v3-q4')
+      // These scenarios hold Right Alt, the default until 2026-10-16 (now Ctrl+Win):
+      // they set it, so the AltGr-era rules keep their real-key proof.
+      localStorage.setItem('prism.dictation.hotkey', JSON.stringify({ code: 'AltRight', ctrl: false, alt: false, shift: false, meta: false }))
       localStorage.setItem('prism.dictation.language', 'no')
       localStorage.setItem('prism.dictation.sounds', '0')
     })
diff --git a/tools/install-stable.ps1 b/tools/install-stable.ps1
index 426a0276..384b9d4b 100644
--- a/tools/install-stable.ps1
+++ b/tools/install-stable.ps1
@@ -52,8 +52,14 @@ if ($running) {
   Write-Host 'Closing the stable copy to refresh it (its tabs come back when it starts).'
   $running | ForEach-Object { $_.CloseMainWindow() | Out-Null }
   if (-not (Wait-StableGone 20)) {
-    Get-Process PrismTerminalStable -ErrorAction SilentlyContinue | Stop-Process -Force
-    if (-not (Wait-StableGone 15)) { throw 'the stable copy did not close; nothing was changed' }
+    # Forced, AGAIN AND AGAIN (2026-10-17): a closing copy started a fresh
+    # network service child after the first force, which then outlived its
+    # parent for good, the wait ran out and nothing was refreshed.
+    for ($i = 0; $i -lt 10 -and (Get-Process PrismTerminalStable -ErrorAction SilentlyContinue); $i++) {
+      Get-Process PrismTerminalStable -ErrorAction SilentlyContinue | Stop-Process -Force -ErrorAction SilentlyContinue
+      [void](Wait-StableGone 3)
+    }
+    if (-not (Wait-StableGone 5)) { throw 'the stable copy did not close; nothing was changed' }
   }
 }