live: heartbeat sync 2026-10-19T01:00:41-07:00 (Refs #11)

Bare /say and /say menu open a ctx.ui.select settings surface: auto-speak
toggle, voice from the frank-tts roster, PipeWire output device
(pw-play --target / paplay --device=), player binary, spoken cap, and a
test phrase. Choices persist to ~/.omp/cache/dankvoice.json (env wins
over file); detectPlayer becomes availablePlayers + playerFor. Fixes
the silent-route failure mode where synthesized audio played into an
offline Bluetooth sink. 15/15 dankvoice bats, 51/51 suite, live pty
TUI smoke armed the footer and wrote the settings file.

agent/config.yml

@@ -1,6 +1,10 @@
 providers:
   openrouterVariant: online
   fetch: auto
+  maxInFlightRequests:
+    llamacpp (dankserver): 3
+    llamacpp (dankclaw): 2
+    llamacpp (dankclaw-3090): 3
 modelRoles:
   slow: llamacpp (dankclaw)/frank-dragoon:medium
   vision: llamacpp (dankclaw-3090)/frank-zealot:xhigh
@@ -145,17 +149,24 @@ display:
   subagentLivePreview: true
 task:
   showResolvedModelBadge: true
-  maxConcurrency: 3
+  maxConcurrency: 2
   agentModelOverrides:
     designer: llamacpp (dankclaw-3090)/frank-zealot
     librarian: llamacpp (dankclaw-3090)/frank-zealot
     reviewer: llamacpp (dankserver)/frank-archon
-    scout: llamacpp (dankserver)/frank-archon
+    scout: llamacpp (dankclaw-3090)/frank-zealot
     security-reviewer: llamacpp (dankclaw)/frank-dragoon
     sonic: llamacpp (dankclaw-3090)/frank-zealot
     task: llamacpp (dankserver)/frank-archon
   eager: default
   enableLsp: true
+  maxRuntimeMs: 1800000
+  softRequestBudget: 120
+  maxRecursionDepth: 1
+  disabledAgents: []
+  isolation:
+    enabled: true
+  completionProbe: false
 snapcompact:
   systemPrompt: none
   toolResults: false
@@ -203,7 +214,7 @@ vault:
 tts:
   localVoice: bm_george
 speech:
-  enabled: true
+  enabled: false
   mode: all
   enhanced: true
   voice: am_fenrir
@@ -232,6 +243,7 @@ followUpMode: one-at-a-time
 tools:
   approvalMode: yolo
   format: auto
+  maxTimeout: 600
 marketplace:
   autoUpdate: notify
 bash:

agent/extensions/dankvoice.ts

@@ -7,28 +7,35 @@
  * agent/models.yml) could only ever produce files. This extension adds the
  * missing path — the TUI speaks with the cloned voices:
  *
- *   /say <text>          speak once through the speakers
- *   /say on | off        auto-speak the assistant's final answer each turn
- *   /say voice <name>    choose a voice (empty = whatever the server defaults to)
- *   /say voices          list the voices frank-tts reports
- *   /say stop            cut off the current utterance
- *   /say status          voice, endpoint and player in use
+ *   /say                   open the options menu
+ *   /say <text>            speak once through the speakers
+ *   /say on | off          arm/disarm auto-speak of the assistant's final answer
+ *   /say menu              the options menu (voice, output device, player, cap)
+ *   /say voice <name>      choose a voice (empty = whatever the server defaults to)
+ *   /say voices            list the voices frank-tts reports
+ *   /say stop              cut off the current utterance
+ *   /say status            voice, endpoint, player and device in use
+ *   /say help              the command list
  *
  * The endpoint comes from agent/models.yml — the provider block carrying
  * `api: openai-speech`, i.e. the same row the speech role resolves — so this
- * file carries no host address and no secret. Environment overrides:
+ * file carries no host address and no secret. Menu choices persist to
+ * ~/.omp/cache/dankvoice.json (runtime state, never tracked). Environment
+ * overrides win over the file, which wins over defaults:
  *
  *   DANKVOICE_URL      speech base URL (…/v1) instead of models.yml
  *   DANKVOICE_MODEL    served model id (default: the id in that block)
- *   DANKVOICE_VOICE    default voice name
- *   DANKVOICE_AUTO=1   start with auto-speak armed
- *   DANKVOICE_MAX      spoken-character cap per utterance (default 700)
+ *   DANKVOICE_CONFIG   settings file (default ~/.omp/cache/dankvoice.json)
  *   DANKVOICE_PLAYER   player binary, skipping detection
- *   DANKVOICE_MODELS   path to models.yml (default ~/.omp/agent/models.yml)
+ *   DANKVOICE_VOICE    voice name ("" = server default)
+ *   DANKVOICE_MAX      spoken-character cap per utterance (default 700)
+ *   DANKVOICE_AUTO=1   start with auto-speak armed
  *
  * Utterances are synthesized to a temp WAV in $TMPDIR; the file is removed
  * when its player process exits. A new utterance interrupts the previous one
- * instead of queueing behind it.
+ * instead of queueing behind it. Output routing: a saved sink becomes
+ * `pw-play --target <sink>` or `paplay --device=<sink>` (ffplay has no device
+ * concept and ignores it); with no saved sink the player's own default applies.
  */
 
 import { spawn, spawnSync, type ChildProcess } from "node:child_process";
@@ -62,6 +69,7 @@ export interface Player {
 }
 
 export type SayAction =
+  | { kind: "menu" }
   | { kind: "help" }
   | { kind: "speak"; text: string }
   | { kind: "on" }
@@ -75,7 +83,8 @@ export type SayAction =
 export function parseSayArgs(raw: string): SayAction {
   const args = raw.trim();
   const lower = args.toLowerCase();
-  if (lower === "" || lower === "help") return { kind: "help" };
+  if (lower === "" || lower === "menu") return { kind: "menu" };
+  if (lower === "help") return { kind: "help" };
   if (lower === "on") return { kind: "on" };
   if (lower === "off") return { kind: "off" };
   if (lower === "stop") return { kind: "stop" };
@@ -162,17 +171,18 @@ export function parseVoices(payload: unknown): string[] {
   return names.filter((name) => name.length > 0);
 }
 
-/** Player preference: PipeWire first (this fleet runs WirePlumber), then Pulse, then ffmpeg. */
-export function detectPlayer(lookup: (command: string) => string | null): Player | null {
-  const candidates: Player[] = [
-    { command: "pw-play", args: [] },
-    { command: "paplay", args: [] },
-    { command: "ffplay", args: ["-nodisp", "-autoexit", "-loglevel", "quiet"] },
-  ];
-  for (const candidate of candidates) {
-    if (lookup(candidate.command)) return candidate;
-  }
-  return null;
+/** Known players, PipeWire first (the workstations run WirePlumber); first existing wins. */
+export function availablePlayers(lookup: (command: string) => string | null): string[] {
+  return ["pw-play", "paplay", "ffplay"].filter((command) => lookup(command) !== null);
+}
+
+/** One player invocation: the saved sink becomes each player's routing dialect. */
+export function playerFor(command: string, sink: string): Player {
+  const base = command.split("/").pop() ?? command;
+  if (base === "ffplay") return { command, args: ["-nodisp", "-autoexit", "-loglevel", "quiet"] };
+  if (!sink) return { command, args: [] };
+  if (base === "paplay") return { command, args: [`--device=${sink}`] };
+  return { command, args: ["--target", sink] };
 }
 
 /** What a speech engine should say: prose only, no fences, no markup, bounded. */
@@ -217,11 +227,62 @@ export function lastAssistantText(messages: readonly unknown[]): string {
   return "";
 }
 
+/** Menu choices, persisted between sessions; every field optional. */
+export interface Settings {
+  voice?: string;
+  player?: string;
+  sink?: string;
+  maxChars?: number;
+  auto?: boolean;
+}
+
+/** Where menu choices live: DANKVOICE_CONFIG, else ~/.omp/cache/dankvoice.json. */
+export function settingsPath(env: NodeJS.ProcessEnv): string {
+  return env.DANKVOICE_CONFIG?.trim() || join(env.HOME ?? "", ".omp", "cache", "dankvoice.json");
+}
+
+export function readSettings(path: string): Settings {
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    const raw = parsed as Record<string, unknown>;
+    const settings: Settings = {};
+    if (typeof raw.voice === "string") settings.voice = raw.voice;
+    if (typeof raw.player === "string") settings.player = raw.player;
+    if (typeof raw.sink === "string") settings.sink = raw.sink;
+    if (typeof raw.maxChars === "number" && Number.isFinite(raw.maxChars) && raw.maxChars > 0) settings.maxChars = Math.floor(raw.maxChars);
+    if (typeof raw.auto === "boolean") settings.auto = raw.auto;
+    return settings;
+  } catch {
+    return {};
+  }
+}
+
+/** A sink row from `wpctl list audio sinks`: `116<TAB>alsa_output…<TAB>audio/sink<TAB>*`. */
+export interface SinkRow {
+  id: string;
+  name: string;
+}
+
+export function parseSinkList(output: string): SinkRow[] {
+  const rows: SinkRow[] = [];
+  for (const line of output.split("\n")) {
+    const cols = line.split("\t").map((col) => col.trim());
+    if (cols.length < 3 || !cols[2]?.includes("audio/sink")) continue;
+    const id = cols[0] ?? "";
+    const name = cols[1] ?? "";
+    if (!id || !name) continue;
+    rows.push({ id, name });
+  }
+  return rows;
+}
+
 // ------------------------------------------------------------- live wiring
 
 interface Config {
   target?: SpeechTarget;
   player?: Player;
+  sink: string;
   maxChars: number;
   auto: boolean;
   voice: string;
@@ -242,8 +303,10 @@ function readModelsYml(): string {
 }
 
 function loadConfig(): Config {
-  const overrideUrl = process.env.DANKVOICE_URL?.trim().replace(/\/+$/, "");
-  const modelOverride = process.env.DANKVOICE_MODEL?.trim();
+  const env = process.env;
+  const settings = readSettings(settingsPath(env));
+  const overrideUrl = env.DANKVOICE_URL?.trim().replace(/\/+$/, "");
+  const modelOverride = env.DANKVOICE_MODEL?.trim();
   const fromYml = overrideUrl ? undefined : resolveSpeechEndpoint(readModelsYml());
   const target: SpeechTarget | undefined = overrideUrl
     ? {
@@ -255,17 +318,25 @@ function loadConfig(): Config {
     : fromYml
       ? { ...fromYml, model: modelOverride || fromYml.model }
       : undefined;
-  const playerOverride = process.env.DANKVOICE_PLAYER?.trim();
-  const maxChars = Number(process.env.DANKVOICE_MAX);
+  const playerCommand = env.DANKVOICE_PLAYER?.trim() || settings.player || availablePlayers(lookupOnPath)[0];
+  const sink = settings.sink ?? "";
+  const maxChars = Number(env.DANKVOICE_MAX);
   return {
     target,
-    player: playerOverride ? { command: playerOverride, args: [] } : (detectPlayer(lookupOnPath) ?? undefined),
-    maxChars: Number.isFinite(maxChars) && maxChars > 0 ? Math.floor(maxChars) : DEFAULT_MAX_CHARS,
-    auto: process.env.DANKVOICE_AUTO === "1",
-    voice: process.env.DANKVOICE_VOICE?.trim() ?? "",
+    player: playerCommand ? playerFor(playerCommand, sink) : undefined,
+    sink,
+    maxChars: Number.isFinite(maxChars) && maxChars > 0 ? Math.floor(maxChars) : (settings.maxChars ?? DEFAULT_MAX_CHARS),
+    auto: env.DANKVOICE_AUTO === "1" || (settings.auto ?? false),
+    voice: env.DANKVOICE_VOICE?.trim() ?? settings.voice ?? "",
   };
 }
 
+/** PipeWire sinks via wpctl; empty when wireplumber is unreachable. */
+function listSinks(): SinkRow[] {
+  const probe = spawnSync("wpctl", ["list", "audio", "sinks"], { encoding: "utf8" });
+  return probe.status === 0 ? parseSinkList(probe.stdout) : [];
+}
+
 /** Synthesize one utterance into a WAV inside `dir`; throws with the endpoint's own message. */
 async function synthesize(target: SpeechTarget, body: Record<string, string>, dir: string, timeoutMs: number): Promise<string> {
   const res = await fetch(target.speechUrl, {
@@ -351,6 +422,39 @@ export default function dankvoice(pi: ExtensionAPI) {
 
   const missingTarget = () => "dankvoice: no `api: openai-speech` provider in agent/models.yml (set DANKVOICE_URL)";
 
+  const persistSettings = (ctx: ExtensionContext) => {
+    const settings: Settings = {
+      voice: state.voice,
+      player: cfg.player?.command ?? "",
+      sink: cfg.sink,
+      maxChars: cfg.maxChars,
+      auto: state.auto,
+    };
+    try {
+      writeFileSync(settingsPath(process.env), `${JSON.stringify(settings, null, 2)}\n`);
+    } catch (error) {
+      ctx.ui.notify(`dankvoice: settings not saved: ${error instanceof Error ? error.message : String(error)}`, "warning");
+    }
+  };
+
+  const setVoice = (ctx: ExtensionContext, name: string) => {
+    state.voice = name;
+    reflectStatus();
+    ctx.ui.notify(name ? `dankvoice: voice = ${name}` : "dankvoice: voice = whatever frank-tts defaults to", "info");
+    persistSettings(ctx);
+  };
+
+  const setAuto = (ctx: ExtensionContext, on: boolean) => {
+    state.auto = on;
+    if (!on) stop();
+    reflectStatus();
+    ctx.ui.notify(
+      on ? `dankvoice: auto-speak armed (${voiceLabel()} @ ${cfg.target?.speechUrl ?? "no endpoint"})` : "dankvoice: auto-speak off",
+      "info",
+    );
+    persistSettings(ctx);
+  };
+
   async function speak(ctx: ExtensionContext, text: string) {
     const spoken = stripForSpeech(text, cfg.maxChars);
     if (!spoken) return;
@@ -378,40 +482,99 @@ export default function dankvoice(pi: ExtensionAPI) {
     }
   }
 
+  async function openMenu(ctx: ExtensionContext): Promise<void> {
+    const options = [
+      `Auto-speak: ${state.auto ? "on" : "off"} (toggle)`,
+      `Voice: ${voiceLabel()} (change)`,
+      `Output device: ${cfg.sink || "system default"} (change)`,
+      `Player: ${cfg.player?.command ?? "none"} (change)`,
+      `Spoken cap: ${cfg.maxChars} chars (change)`,
+      "Speak a test phrase",
+    ];
+    const choice = await ctx.ui.select("dankvoice — options", options);
+    if (!choice) return;
+    if (choice === options[0]) {
+      setAuto(ctx, !state.auto);
+      return;
+    }
+    if (choice === options[1]) {
+      if (!cfg.target) {
+        ctx.ui.notify(missingTarget(), "error");
+        return;
+      }
+      let voices: string[];
+      try {
+        voices = await fetchVoices(cfg.target);
+      } catch (error) {
+        ctx.ui.notify(`dankvoice: ${error instanceof Error ? error.message : String(error)}`, "error");
+        return;
+      }
+      const picked = await ctx.ui.select("dankvoice — voice", ["server default", ...voices]);
+      if (picked === undefined) return;
+      setVoice(ctx, picked === "server default" ? "" : picked);
+      return;
+    }
+    if (choice === options[2]) {
+      const picked = await ctx.ui.select("dankvoice — output device", ["system default", ...listSinks().map((sink) => sink.name)]);
+      if (picked === undefined) return;
+      cfg.sink = picked === "system default" ? "" : picked;
+      if (cfg.player) cfg.player = playerFor(cfg.player.command, cfg.sink);
+      ctx.ui.notify(`dankvoice: output device = ${cfg.sink || "system default"}`, "info");
+      persistSettings(ctx);
+      return;
+    }
+    if (choice === options[3]) {
+      const choices = [...new Set([cfg.player?.command, ...availablePlayers(lookupOnPath)].filter((c): c is string => Boolean(c)))];
+      if (choices.length === 0) {
+        ctx.ui.notify("dankvoice: no audio player found (pw-play, paplay or ffplay)", "error");
+        return;
+      }
+      const picked = await ctx.ui.select("dankvoice — player", choices);
+      if (picked === undefined) return;
+      cfg.player = playerFor(picked, cfg.sink);
+      ctx.ui.notify(`dankvoice: player = ${picked}`, "info");
+      persistSettings(ctx);
+      return;
+    }
+    if (choice === options[4]) {
+      const picked = await ctx.ui.select("dankvoice — spoken cap", ["300", "700", "1500", "3000"]);
+      const next = Number(picked);
+      if (!Number.isFinite(next) || next <= 0) return;
+      cfg.maxChars = next;
+      ctx.ui.notify(`dankvoice: cap = ${next} chars`, "info");
+      persistSettings(ctx);
+      return;
+    }
+    await speak(ctx, `dankvoice: ${voiceLabel()} through ${cfg.player?.command ?? "no player"}, checking.`);
+  }
+
   pi.registerCommand("say", {
     description:
-      "Speak with the fleet's cloned voices (frank-tts): /say <text> | on | off | voice <name> | voices | stop | status",
+      "Speak with the fleet's cloned voices (frank-tts): /say (menu) | <text> | on | off | menu | voice <name> | voices | stop | status",
     handler: async (args: string, ctx) => {
       state.lastCtx = ctx;
       const action = parseSayArgs(args);
       switch (action.kind) {
+        case "menu":
+          await openMenu(ctx);
+          return;
         case "help":
           ctx.ui.notify(
-            "dankvoice: /say <text> · /say on|off (auto-speak answers) · /say voice <name> · /say voices · /say stop · /say status",
+            "dankvoice: /say (menu) · /say <text> · /say on|off (auto-speak answers) · /say voice <name> · /say voices · /say stop · /say status",
             "info",
           );
           return;
         case "on":
-          state.auto = true;
-          reflectStatus();
-          ctx.ui.notify(`dankvoice: auto-speak armed (${voiceLabel()} @ ${cfg.target?.speechUrl ?? "no endpoint"})`, "info");
+          setAuto(ctx, true);
           return;
         case "off":
-          state.auto = false;
-          stop();
-          reflectStatus();
-          ctx.ui.notify("dankvoice: auto-speak off", "info");
+          setAuto(ctx, false);
           return;
         case "stop":
           stop();
           return;
         case "voice":
-          state.voice = action.name;
-          reflectStatus();
-          ctx.ui.notify(
-            action.name ? `dankvoice: voice = ${action.name}` : "dankvoice: voice = whatever frank-tts defaults to",
-            "info",
-          );
+          setVoice(ctx, action.name);
           return;
         case "voices": {
           if (!cfg.target) {
@@ -435,7 +598,7 @@ export default function dankvoice(pi: ExtensionAPI) {
         }
         case "status":
           ctx.ui.notify(
-            `dankvoice: voice ${voiceLabel()} · ${cfg.target?.speechUrl ?? "NO ENDPOINT"} · player ${cfg.player ? cfg.player.command : "NONE"} · auto-speak ${state.auto ? "on" : "off"} · cap ${cfg.maxChars} chars`,
+            `dankvoice: voice ${voiceLabel()} · ${cfg.target?.speechUrl ?? "NO ENDPOINT"} · player ${cfg.player ? cfg.player.command : "NONE"} · device ${cfg.sink || "system default"} · auto-speak ${state.auto ? "on" : "off"} · cap ${cfg.maxChars} chars`,
             "info",
           );
           return;

agent/managed-skills/bounding-subagent-runtime/SKILL.md

@@ -1,82 +1,32 @@
 ---
 name: bounding-subagent-runtime
-description: "Cap and diagnose runaway or hung omp subagents: task.maxRuntimeMs, softRequestBudget, agentIdleTtlMs, per-agent model overrides, the cfg save-approval quirk, and the finished-work-but-never-exits nested-fanout deadlock."
+description: "Cap and diagnose runaway or hung omp subagents: task.maxRuntimeMs, softRequestBudget, maxConcurrency, maxRecursionDepth (the 0-trap), per-provider in-flight ceilings."
 ---
 
-# Bounding subagent runtime (omp harness)
+## When
+Subagent runs long, fan out too wide, or you must (re)declare the fleet's subagent limit policy. Also when asked "what limits can subagents have".
 
-Use when a `task`/`eval` subagent runs absurdly long (tens of minutes on a small job),
-when it **finishes its deliverable and still never exits**, when you want a hard cap
-before spawning, or when you must tell a busy agent to stop.
+## Read first
+- Repo KB page `omp-docs/pi/subagent-limits.md` — the live policy of record (values + rationale + deliberately-not-set list). Do not re-derive; read it.
+- `cfg://task` and `cfg://providers/maxInFlightRequests` — effective values, not the stock defaults.
 
-## The knobs (`cfg://task/...`)
-
-| Key | Default | Meaning |
+## The knobs (cfg:// writes; `/save` suffix persists)
+| Knob | Effect | Gotcha |
 |---|---|---|
-| `maxRuntimeMs` | `0` (unlimited) | **Hard wall-clock limit per subagent (ms).** The only true time cap. |
-| `softRequestBudget` | `200` | Soft cap on assistant **requests** per run; force-stop at **1.5×**. |
-| `softRequestBudgetNotice` | `true` | Injects one "wrap up" steering message at the soft mark. |
-| `agentIdleTtlMs` | `420000` | Parks an **idle** agent after 7 min. Useless against a busy-but-slow agent. |
-| `completionProbe` | `true` | Asks a working subagent to self-report completeness at 2/5/10 requests. |
-| `maxConcurrency` | `32` (often lowered) | Concurrent subagents; sizes GPU/endpoint load. |
-| `agentModelOverrides` | `{}` | Per-agent model routing, e.g. `{"scout":"provider/model-id"}`. |
-| `tools.maxTimeout` | `0` | Caps the timeout the agent may set on a **tool**, not on the agent. |
+| `task.maxConcurrency` | session semaphore; excess queues | stock default 32 — "2" is not a default |
+| `task.maxRecursionDepth` | nesting cap | predicate is `depth < n`; **1 = children cannot spawn (correct for "no nesting"); 0 disables spawning for the MAIN session too — never reach for 0**; negative = unlimited |
+| `task.maxRuntimeMs` | hard wall clock, overrun = `aborted` | default 0 = off |
+| `task.softRequestBudget` | wrap-up notice at N, force-yield at 1.5N | scout/sonic may impose lower built-ins |
+| `task.agentIdleTtlMs` | park idle finished agents | `<= 0` disables parking |
+| `providers.maxInFlightRequests` | concurrent LLM requests per provider id | keys are the quoted block labels from `agent/models.yml` (e.g. `"llamacpp (dankclaw-3090)"`), flat map lookup; absent/≤0 = unlimited; scope = this machine's config root only — other workstations and non-omp clients are NOT counted; excess queues |
+| `tools.maxTimeout` | ceiling on any agent-requested tool timeout | kills `timeout: 0` runaways |
+| `task.isolation.enabled` | makes per-spawn `isolated` flag available | opt-in per spawn, not a blanket sandbox; needs git repo; off in plan mode |
+| `task.completionProbe` | periodic completeness side-requests | token sink on shared endpoints |
 
-Reasonable fleet defaults: `maxRuntimeMs = 900000` (15 min), leave the request budget
-alone unless the failure mode is a looping search agent (then lower it — request count,
-not the clock, is what bounds a 200-call research loop).
+## Verify semantics from the bundle, not the label
+Setting descriptions lie by omission. `~/.bun/install/global/node_modules/@oh-my-pi/pi-coding-agent/dist/cli.js`:
+- depth gate: `grep -o '.\{130\}xC\b.\{130\}'` finds `U_(n,s)`; `grep -o 'function U_(e,t){.\{0,60\}'` → `e<0||t<e` (n=cap, s=taskDepth).
+- in-flight lookup: `grep -o '.\{150\}axInFlightRequests.\{200\}'` → flat `[providerId]` lookup, non-number/≤0 = unlimited, clamp ≥1.
 
-**Verify the cap instead of assuming it.** `read cfg://task/maxRuntimeMs` at the start of
-any session that plans to rely on it. A session-only write is gone next session, and an
-unanswered `/save` approval means the value never persisted — so the fleet can run hours
-with the cap at `0` while everyone believes it is 15 minutes. Nothing else bounds a child.
-
-## Three failure modes, three different fixes
-
-- **Runaway loop** (hundreds of sequential tool calls): lower `softRequestBudget`; the
-  clock cap only truncates it late.
-- **Slow model, legitimate work** (dozens of calls on a low-t/s endpoint = an hour of wall
-  clock): fix routing, not the clock — check `cfg://task/agentModelOverrides` and move the
-  agent class onto a faster/shared endpoint. Watch the slot math: subagent endpoints share
-  KV slots with the interactive session, so `maxConcurrency + 1` sequences on an N-slot
-  endpoint degrades everyone's decode.
-- **Finished work, no exit (nested fan-out deadlock).** A subagent that spawned **its own**
-  children blocks on their barriers. If those children die out-of-band (killed, starved, or
-  waiting on an answer whose subject changed mid-flight), the parent waits forever with its
-  deliverable already written. No instruction text prevents this — not the repo AGENTS.md,
-  not the task prompt; only the clock cap or a kill ends it.
-
-  Signature: parent and children report **the same elapsed wall clock**, and the parent's
-  on-disk output is complete. Census (agent registry + `ps`): group by elapsed time, look
-  for identical `etimes` across a parent/child set, then judge the **artifacts** instead of
-  the process — balanced code fences, no truncated tables, trailing newline, front matter or
-  the page's H1+status convention intact. Complete artifacts + still "running" = deadlock,
-  not work.
-
-  Repair: kill the **subtree** and confirm the children leave (a killed parent does not
-  cancel children that came from a separate `tasks[]` batch). Then **flatten**: the
-  top-level session does the fan-out and children never spawn children. Re-run only the
-  slices whose artifacts are missing — integrate from what is already on disk.
-
-## cfg write mechanics (bit me once)
-
-- `write cfg://task/maxRuntimeMs 900000` → applies **session-only**, replies "NOT saved".
-- Persist = `write cfg://task/maxRuntimeMs/save` with the same content, and that write
-  needs its **own interactive approval**. If the approval prompt is not answered in time
-  the value stays session-only and the tool says *NEVER retry unless the user asks* —
-  report it in the reply instead.
-- Revert a session value by writing the old value back (e.g. `0`).
-
-## Order of operations when one is already running late
-
-1. `read proc://` → registry of running agents; `read proc://<id>` for status/output.
-2. `read agent://<id>` → live progress ("Latest assistant text") — often shows it is
-   mid-batch, not hung. If the latest text is already a wrap-up/summary, treat it as
-   **done** and collect its output instead of waiting for an exit event.
-3. `write agent://<id>` an explicit wrap-up order: stop searching, answer what is
-   sourced, mark the rest `NOT VERIFIED — needs <what>`, cap the report length.
-4. Only then `write proc://<id>/kill` — the cap does **not** retroactively bind agents
-   spawned before the change, so a long runner must be ordered or killed, never just
-   re-configured. After any kill, re-read the registry: unreaped children and orphaned
-   host-side processes (a scratch server holding GPU/RAM) are the expensive residue, and
-   `pkill -f` patterns that also match production services are forbidden — kill by pid.
+## Landing a policy change
+cfg `/save` writes persist immediately; `agent/config.yml` is machine-live tier (heartbeat commits it). Human-facing policy changes land as an `omp-docs` page update via branch → PR (docs tier), `git worktree add` from `origin/main` if the current checkout is branch-locked by workspace policy.

agent/memories/sharpshooter/omp-32c11n2wnglul/state.json

@@ -1,6 +1,6 @@
 {
 	"v": 1,
-	"lastConsolidatedAt": 1792381479415,
+	"lastConsolidatedAt": 1792395788647,
 	"lastResult": {
 		"at": 1791599865775,
 		"sessions": 1,

agent/memories/sharpshooter/tmp-1tpw73408x3e/state.json

@@ -1,4 +1,4 @@
 {
 	"v": 1,
-	"lastConsolidatedAt": 1792392829703
+	"lastConsolidatedAt": 1792396789735
 }

agent/memories/sharpshooter/wt-20261017-181502-6d1fc1f-1oq2osmoyw03k/architecture.md

@@ -1,3 +1,20 @@
+## Subagent routing (harness law, 2026-10-18)
+
+**No subagent class may route to `frank-archon`** — the operator session lives there and
+the endpoint runs 3 sequences (`--max-num-seqs 3`), so `task.maxConcurrency + 1` children
+eat the parent's own KV slots. Violation cost: three doc children + parent = 4 sequences
+on 3 slots, children ran 2 h 27 m / 2 h 45 m, the interactive session starved.
+Routing and bounds live in `~/.omp/agent/config.yml` (`task:` block — the owner; verified
+with `read cfg://task/agentModelOverrides`): heavy writers (`task`, `scout`) → frank-dragoon
+(2 slots, idle, slow card ⇒ slice work smaller), bursty readers (`reviewer`, `sonic`,
+`designer`, `librarian`) → frank-zealot (2 slots, also the compaction hub and every
+tiny/smol/plan/commit/memory role). Caps: `maxConcurrency: 2`, `maxRuntimeMs: 1800000`,
+`softRequestBudget: 120`, `maxRecursionDepth: 1` (children never spawn children).
+`cfg://.../save` approvals auto-deny after a hardcoded 10 s dialog — after Frank has
+approved a change, edit `config.yml` directly and validate the YAML; a running session
+picks global-config edits up at once. Full procedure: managed skill
+`bounding-subagent-runtime`.
+
 ## Documentation law (2026-10-18)
 
 **One fact, one owner.** The `serverAppConfigs` repo owns every fleet fact;
@@ -18,8 +35,8 @@ Swap the model, don't instrument the swap: edit the trio
 probe → done. **No benchmarks, A/Bs, ladders, or acceptance tables unless
 Frank explicitly asks for data.** If a payload misbehaves, revert the commit and
 redeploy. When a bench IS ordered, the GPU-safety procedure (stop + mask, no
-scratch ports, never `systemctl disable`) is `AGENTS.md` → *Model swaps* and
-*Deployment completeness*.
+scratch ports, never `systemctl disable`) is `AGENTS.md` → *Model swaps*
+and *Deployment completeness*. 
 
 ## Where facts live
 

agent/memories/sharpshooter/wt-20261017-181502-6d1fc1f-1oq2osmoyw03k/product.md

@@ -3,25 +3,22 @@
 - Custom voice source material must exclude the first 10 seconds of any audio sample file used to generate voices; this is a project-wide invariant across all source files, not a per-file exception.
 - Voice selector valid options: af_heart, af_alloy, af_aoede, af_bella, af_jessica, af_kore, af_nicole, af_nova, af_river, af_sarah, af_sky, am_adam, am_echo, am_eric, am_fenrir, am_liam, am_michael, am_onyx, am_puck, am_santa, bf_emma, bf_isabella, bm_george, bm_lewis, bf_alice, bf_lily, bm_daniel, bm_fable.
 
-## Podcast
-
-- Podcast functionality is sourced from open-notebook; this is a project decision established before this document was created.
-
-## Audio Input Policy
-
-- There is no audio input anywhere in the fleet: that capability left with the FLM NPU endpoint on 2026-09-11, returned 2026-09-17 with the Gemma4 projector's audio encoder, and left again with the Gemma4 retirement on 2026-10-01.
-- This policy mirrors the architecture-level decision documented in `architecture.md` regarding the fleet's input capabilities.
-
 ## Input Capabilities
 
 All endpoints accept text input with optional image input: `frank-dragoon` returned to vision with the flash-server v2 swap, while `frank-archon` takes them natively and `frank-zealot` through its BF16 mmproj.
 
 There is no audio input anywhere in the fleet: that capability left with the FLM NPU endpoint on 2026-09-11, returned 2026-09-17 with the Gemma4 projector's audio encoder, and left again with the Gemma4 retirement on 2026-10-01.
 
-This rule exists because the Gemma4 projector was retired in 2026-10-01, removing the audio input channel from the fleet. The 2026-09-11 to 2026-10-01 period contained the Gemma4 projector which enabled audio, but that endpoint is now retired.
-
 ## Voice Usage Notes
 
 - Voice generator output does not affect token counting or inference costs — all voices are rendered post-inference.
 - Voice quality varies by source sample: exclude the first 10 seconds of any audio sample file used to generate voices; this is a project-wide invariant across all source files, not a per-file exception.
-- Voice selection is client-side only; the server does not generate or return audio data.`, 
+- Voice selection is client-side only; the server does not generate or return audio data.
+
+## Load Management
+
+- Subagent settings must prevent frank-archon from being overwhelmed; concurrent request handling prioritizes endpoint stability over throughput.
+
+## Podcast
+
+- Podcast functionality is sourced from open-notebook; this is a project decision established before this document was created.

agent/memories/sharpshooter/wt-20261017-181502-6d1fc1f-1oq2osmoyw03k/state.json

@@ -1,8 +1,8 @@
 {
 	"v": 1,
-	"lastConsolidatedAt": 1792392891753,
+	"lastConsolidatedAt": 1792396748497,
 	"lastResult": {
-		"at": 1792379504653,
+		"at": 1792393886960,
 		"sessions": 1,
 		"deltas": 1,
 		"model": "frank-zealot"

agent/memories/sharpshooter/wt-20261018-204442-7c8a99d-2u1dm4kttza8t/product.md

@@ -0,0 +1,3 @@
+# Output behavior
+
+Output must not be shaken off during presentation. Output remains anchored until explicitly confirmed.

agent/memories/sharpshooter/wt-20261018-204442-7c8a99d-2u1dm4kttza8t/state.json

@@ -1,4 +1,10 @@
 {
 	"v": 1,
-	"lastConsolidatedAt": 1792392882348
+	"lastConsolidatedAt": 1792396722373,
+	"lastResult": {
+		"at": 1792396071933,
+		"sessions": 1,
+		"deltas": 1,
+		"model": "frank-zealot"
+	}
 }

agent/memories/sharpshooter/wt-20261018-204501-6d1fc1f-3fct0wvty8jvu/state.json

@@ -1,6 +1,6 @@
 {
 	"v": 1,
-	"lastConsolidatedAt": 1792392961865,
+	"lastConsolidatedAt": 1792393561866,
 	"lastResult": {
 		"at": 1792381870670,
 		"sessions": 1,

agent/memories/sharpshooter/wt-20261019-001426-7c8a99d-3m7k3cagiow5n/queue/01a15302-f12d-77d8-9a33-be31a1a05528/00mvexe0pf-6ozb.json

@@ -0,0 +1 @@
+{"v":1,"kind":"product_decision","statement":"Limit on zealot set to 3, dragoon set to 2, archon set to 3","source":"explicit_user","evidence":"make the limit on zealot 3, dragoon 2, archon 3","friction":{"corrective":false,"regression":false,"subtle":false},"sessionId":"01a15302-f12d-77d8-9a33-be31a1a05528","ts":1792394470419}

agent/memories/sharpshooter/wt-20261019-001426-7c8a99d-3m7k3cagiow5n/state.json

@@ -0,0 +1,4 @@
+{
+	"v": 1,
+	"lastConsolidatedAt": 1792394427081
+}

agent/memories/sharpshooter/wt-20261019-004309-7c8a99d-u0xusjwyvzai/state.json

@@ -0,0 +1,4 @@
+{
+	"v": 1,
+	"lastConsolidatedAt": 1792396749853
+}

dotfiles/noctalia/.local/state/noctalia/settings.toml

@@ -275,13 +275,13 @@ transition = [ "fade" ]
     interval_seconds = 1200
 
     [wallpaper.default]
-    path = "/home/blank/.local/share/noctalia/wallpapers/wallhaven_4x17w3.jpg"
+    path = "/home/blank/.local/share/noctalia/wallpapers/wallhaven_nzz3gy.jpg"
 
     [wallpaper.last]
-    path = "/home/blank/.local/share/noctalia/wallpapers/wallhaven_4x17w3.jpg"
+    path = "/home/blank/.local/share/noctalia/wallpapers/wallhaven_nzz3gy.jpg"
 
     [wallpaper.monitors.DP-1]
-    path = "/home/blank/.local/share/noctalia/wallpapers/wallhaven_4x17w3.jpg"
+    path = "/home/blank/.local/share/noctalia/wallpapers/wallhaven_nzz3gy.jpg"
 
     [wallpaper.monitors.DP-2]
     path = "/home/blank/.local/share/noctalia/wallpapers/wallhaven_oxex69.jpg"
@@ -290,7 +290,7 @@ transition = [ "fade" ]
     path = "/home/blank/.local/share/noctalia/wallpapers/wallhaven_v9e2w3.jpg"
 
     [wallpaper.monitors.eDP-1]
-    path = "/home/blank/.local/share/noctalia/wallpapers/wallhaven_4x17w3.jpg"
+    path = "/home/blank/.local/share/noctalia/wallpapers/wallhaven_nzz3gy.jpg"
 
 [weather]
 unit = "imperial"

omp-docs/core/dankvoice.md

@@ -16,10 +16,10 @@ timestamp: 2026-10-18
 # dankvoice
 
 `agent/extensions/dankvoice.ts` adds cloned-voice speech to the interactive
-harness: `/say <text>` speaks through the speakers and `/say on` narrates the
-assistant's final answer after every turn, both served by
-**frank-tts** (Dankclaw :7772, the `speech` model role in
-[agent/models.yml](/core/index.md)).
+harness: `/say` opens the options menu, `/say <text>` speaks through the
+speakers and `/say on` narrates the assistant's final answer after every
+turn, all served by **frank-tts** (Dankclaw :7772, the `speech` model role
+in [agent/models.yml](/core/index.md)).
 
 ## Why it exists
 
@@ -39,12 +39,19 @@ local speech and the cloned voices carry the real narration.
 
 | Command | Effect |
 |---|---|
+| `/say` \| `/say menu` | options menu (`ctx.ui.select`): auto-speak toggle, voice, output device, player, spoken cap, test phrase |
 | `/say <text>` | synthesize once and play; interrupts whatever is playing |
 | `/say on` \| `/say off` | arm/disarm auto-speak of the assistant's final text at `agent_end`; the footer shows `🔊 <voice>` while armed |
 | `/say voice <name>` | pick a voice; an empty name defers to the server's own default |
 | `/say voices` | list what frank-tts reports |
 | `/say stop` | cut the current utterance |
-| `/say status` \| `/say help` | endpoint, voice, player, cap |
+| `/say status` \| `/say help` | endpoint, voice, player, device, cap |
+
+Menu choices persist to `~/.omp/cache/dankvoice.json` (runtime state, never
+tracked); the environment overrides the file, the file overrides defaults.
+"Speak a test phrase" synthesizes a short line through the current voice,
+player and device — the audible proof whenever a session "has say on" but
+stays silent.
 
 Auto-speak is skipped in `print`/`json` mode so benches and pipelines stay
 silent. Markdown is stripped before synthesis — fenced code is dropped, links
@@ -63,16 +70,21 @@ resolves, so no host address and no credential appears in this file. From
 |---|---|---|
 | `DANKVOICE_URL` | models.yml | speech base URL (`…/v1`), bypasses the YAML read |
 | `DANKVOICE_MODEL` | the id in that block (`frank-tts`) | model named in the request body |
+| `DANKVOICE_CONFIG` | `~/.omp/cache/dankvoice.json` | persisted menu choices (voice, player, sink, cap, auto) |
 | `DANKVOICE_VOICE` | empty (server default) | default voice name |
 | `DANKVOICE_AUTO=1` | off | start with auto-speak armed |
 | `DANKVOICE_MAX` | `700` | spoken characters per utterance |
 | `DANKVOICE_PLAYER` | detect | player binary, skipping detection |
 | `DANKVOICE_MODELS` | `~/.omp/agent/models.yml` | YAML to read the endpoint from |
 
-Player detection order is `pw-play` → `paplay` → `ffplay -nodisp -autoexit`
-(PipeWire first: the workstations run WirePlumber). Each utterance is written
-to `$TMPDIR/dankvoice-*/say-<ms>.wav` and the file plus its directory are
-removed when the player process exits.
+Player detection order is `pw-play` → `paplay` → `ffplay` (PipeWire first:
+the workstations run WirePlumber). A saved output device routes the player
+explicitly — `pw-play --target <sink>` or `paplay --device=<sink>`; ffplay
+has no device concept and ignores it — while an unset device leaves the
+player's own default. Sinks are enumerated with `wpctl list audio sinks`;
+if wireplumber is unreachable the menu offers only "system default". Each
+utterance is written to `$TMPDIR/dankvoice-*/say-<ms>.wav` and the file plus
+its directory are removed when the player process exits.
 
 ## Verified facts (2026-10-18)
 
@@ -101,6 +113,11 @@ removed when the player process exits.
   (1.20 s WAV), and an unknown voice name answers with the roster instead of
   speaking. An `agent_end` carrying `willContinue` (the harness scheduled an
   auto-retry) is never narrated — only the terminal settle speaks.
+* **Menu** — verified via driver scenarios 2026-10-18 (Refs #23): the menu
+  lists auto-speak/voice/device/player/cap/test-phrase; a voice chosen in the
+  menu is used by later utterances and survives a fresh load via the settings
+  file; a device chosen in the menu appears in the player invocation as
+  `--target <sink>`.
 
 ## Limits
 
@@ -125,6 +142,7 @@ removed when the player process exits.
   `@earendil-works/pi-coding-agent` `dist/core/extensions/types.d.ts`
   (`ExtensionAPI.on/registerCommand`, `ExtensionMode = "tui" | "rpc" | "json" | "print"`).
 * Gitea issue #21 on `dank/command-center` (the work item this page ships with).
+* Gitea issue #23 on `dank/command-center` (the options-menu work item).
 
 ## See Also
 

omp-docs/log.md

@@ -11,6 +11,21 @@ timestamp: 2026-08-28
 
 # Bundle Change Log
 
+
+## 2026-10-18 — dankvoice: `/say` options menu with output-device routing (Refs #23)
+
+Added `/say menu` (bare `/say` now opens it; `help` keeps the text listing), the
+pi-peon-style settings surface: auto-speak toggle, voice picked from the frank-tts
+roster, **output device** (PipeWire sinks via `wpctl` → `pw-play --target` /
+`paplay --device=`), player binary, spoken-char cap, and a "speak a test phrase"
+utterance that proves the audio path audibly. Choices persist to
+`~/.omp/cache/dankvoice.json` (`DANKVOICE_CONFIG`); env now wins over that file,
+which wins over defaults — answering the silent-session incident where
+PipeWire's remembered Bluetooth route played synthesized answers into nowhere.
+`detectPlayer` becomes `availablePlayers` + `playerFor`. Tests gain a fixture
+`wpctl`, a scripted `select` in the driver, and three menu scenarios: 15 green
+in `tests/dankvoice.bats`, 51 green suite-wide.
+
 ## 2026-10-18 — dankvoice: the cloned voices finally speak in the TUI (Refs #21)
 
 Nothing in the harness could pronounce them: the TUI vocalizer and `omp say` gate `--voice` against the bundled Kokoro enum (`omp say --voice narrator1 "test"` → `error: Expected --voice to be one of: af_heart, …`), so frank-tts was reachable only as a file. Added `agent/extensions/dankvoice.ts` — `/say <text>`, `/say on|off` (narrate the final answer at `agent_end`), `/say voice|voices|stop|status` — synthesizing over the OpenAI speech route and playing through `pw-play`/`paplay`/`ffplay`, with the endpoint read from the `api: openai-speech` row of `agent/models.yml` (no host, no secret in the file). Verified live in a real TUI session on the workstation: roster `GET /v1/audio/voices` → `narrator1, narrator2, narrator3`; `/say` produced 99,884 B / 2.08 s and 69,164 B / 1.44 s WAVs handed to the player, temp dirs cleaned afterwards; `/say on` armed the footer (`🔊 narrator1`) and each following finished turn spoke its answer (1.20 s WAV), an unknown voice name answered with the roster instead of speaking, and an `agent_end` carrying `willContinue` (the harness scheduled an auto-retry) is deliberately never narrated. Extension discovery itself proved with a probe file in `~/.omp/agent/extensions/` loaded by a fresh `omp -p` run. Reference page [dankvoice](core/dankvoice.md), registered in the core index; black-box seam `tests/dankvoice.bats` (12 tests).

tests/dankvoice.bats

@@ -3,15 +3,19 @@
 #
 # The extension's contract, from outside: it registers a `say` command and an
 # `agent_end` listener; what is observable is (a) the JSON it POSTs to the
-# speech route, (b) the file it hands to the player, and (c) the notification
-# text it prints. A fixture HTTP server stands in for frank-tts (it answers the
-# speech route with a fixed WAV, the roster route with a JSON array, and
-# everything else with 404) and a stub player stands in for pw-play: it records
-# the path it was given and copies the bytes it was told to play.
+# speech route, (b) the file it hands to the player, and (c) the notifications
+# and select-lists it renders. A fixture HTTP server stands in for frank-tts
+# (it answers the speech route with a fixed WAV, the roster route with a JSON
+# array, and everything else with 404), a stub player stands in for pw-play
+# (it records its full argv and copies the .wav it was given), and a fixture
+# `wpctl` in $WORK/bin stands in for wireplumber's sink enumeration.
 #
 # Driven by env: DV_EXT (extension under test), DV_STUB / DV_STUB_LOG / DV_COPY
-# (player fixture), DV_MODELS (models.yml fixture), DV_EMPTY_BIN (a PATH with no
-# players), DV_MODE (the harness mode reported to the extension).
+# (player fixture), DV_PWPLAY (stub aliased as pw-play), DV_WPCTL (the sink
+# name the fixture wpctl reports), DV_MODELS (models.yml fixture),
+# DANKVOICE_CONFIG (settings file), DV_PLAYER_BIN (player command override),
+# DV_SELECT (pipe-separated answers fed to ctx.ui.select in order), DV_MODE
+# (the harness mode reported to the extension).
 
 setup() {
   REPO="$(cd "$BATS_TEST_DIRNAME/.." && pwd)"
@@ -26,12 +30,27 @@ setup() {
 
   cat > "$DV_STUB" <<'SH'
 #!/usr/bin/env bash
-printf '%s\n' "$1" >> "$DV_STUB_LOG"
-cp "$1" "$DV_COPY"
+printf '%s\n' "$*" >> "$DV_STUB_LOG"
+for arg in "$@"; do case "$arg" in *.wav) cp "$arg" "$DV_COPY" ;; esac; done
 sleep 0.1
 SH
   chmod +x "$DV_STUB"
 
+  # the same stub reachable under the canonical player names, plus a fixture
+  # wpctl so output-device enumeration is deterministic on any machine
+  mkdir -p "$WORK/bin"
+  ln -s "$DV_STUB" "$WORK/bin/pw-play"
+  export DV_PWPLAY="$WORK/bin/pw-play"
+  export DV_WPCTL="alsa_output.usb-KT.0"
+  cat > "$WORK/bin/wpctl" <<'WPC'
+#!/usr/bin/env bash
+printf '57\talsa_output.pci-0000_07_00.6.HiFi__Speaker__sink\taudio/sink\t\n116\t%s\taudio/sink\t*\n' "$DV_WPCTL"
+WPC
+  chmod +x "$WORK/bin/wpctl"
+
+  # settings live in an isolated file so menu choices never leak between tests
+  export DANKVOICE_CONFIG="$WORK/settings.json"
+
   # models.yml fixture: a chat provider first, the speech provider second
   export DV_MODELS="$WORK/models.yml"
   cat > "$DV_MODELS" <<'YML'
@@ -54,6 +73,7 @@ YML
 // it, invoke one scenario, print what the endpoint received and what got played.
 import { createServer } from "node:http";
 import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname } from "node:path";
 
 const scenario = process.argv[2] ?? "speak";
 const AUDIO = Buffer.from([0x52, 0x49, 0x46, 0x46, 8, 0, 0, 0, 0x57, 0x41, 0x56, 0x45, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]);
@@ -88,7 +108,8 @@ if (scenario === "endpoint") {
   process.env.DANKVOICE_URL = `http://127.0.0.1:${port}/v1`;
 }
 if (scenario === "noplayer") process.env.PATH = process.env.DV_EMPTY_BIN ?? "/nonexistent-bin";
-process.env.DANKVOICE_PLAYER = scenario === "noplayer" ? "" : process.env.DV_STUB;
+else process.env.PATH = `${dirname(process.env.DV_STUB ?? ".")}/bin:${process.env.PATH ?? ""}`;
+process.env.DANKVOICE_PLAYER = scenario === "noplayer" ? "" : process.env.DV_PLAYER_BIN ?? process.env.DV_STUB;
 
 const extension = await import(process.env.DV_EXT as string);
 const commands = new Map<string, { handler: (args: string, ctx: unknown) => Promise<void> }>();
@@ -97,11 +118,19 @@ extension.default({
   registerCommand: (name: string, options: { handler: (args: string, ctx: unknown) => Promise<void> }) => commands.set(name, options),
   on: (event: string, handler: (event: unknown, ctx: unknown) => Promise<void> | void) => events.set(event, handler),
 });
+const answers = (process.env.DV_SELECT ?? "").split("|").filter((answer) => answer !== "");
+let answerIndex = 0;
 const ctx = {
   mode: process.env.DV_MODE ?? "tui",
   ui: {
     notify: (message: string, level?: string) => console.log(`NOTIFY ${level ?? "info"} ${message}`),
     setStatus: (key: string, text?: string) => console.log(`STATUS ${key} ${text ?? ""}`),
+    select: (title: string, options: string[]) => {
+      console.log(`SELECT ${title} ${options.join("|")}`);
+      const answer = answerIndex < answers.length ? answers[answerIndex] : undefined;
+      answerIndex += 1;
+      return Promise.resolve(answer ?? options[0]);
+    },
   },
 };
 const say = commands.get("say");
@@ -121,6 +150,16 @@ if (!say) {
       await say.handler("voice narrator2", ctx);
       await say.handler("good morning", ctx);
       break;
+    case "menu":
+      await say.handler("menu", ctx);
+      break;
+    case "empty":
+      await say.handler("", ctx);
+      break;
+    case "devicemenu":
+      await say.handler("menu", ctx);
+      await say.handler("hello world", ctx);
+      break;
     case "auto":
       await say.handler("on", ctx);
       await agentEnd?.(answer("the answer"), ctx);
@@ -171,6 +210,7 @@ for (const call of received) {
 console.log(`CALLS ${received.length}`);
 const log = process.env.DV_STUB_LOG && existsSync(process.env.DV_STUB_LOG) ? readFileSync(process.env.DV_STUB_LOG, "utf8").trim() : "";
 console.log(`PLAYS ${log === "" ? 0 : log.split("\n").length}`);
+if (log !== "") for (const line of log.split("\n")) console.log(`PLAYER ${line}`);
 if (process.env.DV_COPY && existsSync(process.env.DV_COPY)) console.log(`COPIED ${statSync(process.env.DV_COPY).size}`);
 server.close();
 TS
@@ -183,7 +223,7 @@ teardown() {
 }
 
 say_run() {
-  run bun "$DV_DRIVER" "$1"
+  run env DV_SELECT="${2:-}" bun "$DV_DRIVER" "$1"
 }
 
 @test "the extension registers the say command and an agent_end listener" {
@@ -261,3 +301,27 @@ say_run() {
  [[ "$output" == *"input=the settled answer"* ]]
  [[ "$output" != *"input=not yet"* ]]
 }
+
+@test "the menu lists every knob and a plain /say opens it" {
+  say_run menu
+  [[ "$output" == *"SELECT dankvoice — options Auto-speak: off (toggle)|Voice: server default (change)|Output device: system default (change)|Player: $DV_STUB (change)|Spoken cap: 700 chars (change)|Speak a test phrase"* ]]
+  [[ "$output" == *"NOTIFY info dankvoice: auto-speak armed (server default @ http://127.0.0.1:"* ]]
+  say_run empty
+  [[ "$output" == *"SELECT dankvoice — options"* ]]
+}
+
+@test "a voice picked from the menu is spoken by every later request" {
+  say_run menu "Voice: server default (change)|narrator2"
+  [[ "$output" == *"SELECT dankvoice — voice server default|narrator1|narrator2"* ]]
+  [[ "$output" == *"NOTIFY info dankvoice: voice = narrator2"* ]]
+  say_run speak
+  [[ "$output" == *"voice=narrator2 input=hello world"* ]]
+}
+
+@test "a device chosen from the menu becomes the player's output target" {
+  DV_PLAYER_BIN="$DV_PWPLAY" say_run menu "Output device: system default (change)|$DV_WPCTL"
+  [[ "$output" == *"SELECT dankvoice — output device system default|alsa_output.pci-0000_07_00.6.HiFi__Speaker__sink|$DV_WPCTL"* ]]
+  [[ "$output" == *"NOTIFY info dankvoice: output device = $DV_WPCTL"* ]]
+  DV_PLAYER_BIN="$DV_PWPLAY" say_run speak
+  [[ "$output" == *"PLAYER --target $DV_WPCTL"* ]]
+}