dankvoice: humanize answers via the @tiny role and narrate thinking

Answers spoken with /say were verbatim markdown-cleaned text while the
built-in vocalizer speaks prose rewritten by a small model. Port that
enhancer (bundle Qyr/T6o: same prompt, 1536 tokens, 6 s, 4000-char
window, null-fallback/empty-skip contract) and resolve its model from
modelRoles.tiny exactly as the harness does, so auto-speak sounds like
the enhanced TUI voice instead of a pager. agent_end now also speaks the
last assistant message's thinking blocks as their own unit before the
answer; narration-flagged thinking counts as answer text. Both knobs are
menu-toggleable, persisted, and env-overridable; the fixture gains a
chat route (echo/prose) and seven scenarios cover the round-trip, the
404 fallback, ordering, the kill switches and role resolution (22 green,
58 suite-wide; live smoke through real frank-zealot + frank-tts).

Refs #27

agent/extensions/dankvoice.ts

@@ -28,14 +28,26 @@
  *   DANKVOICE_CONFIG   settings file (default ~/.omp/cache/dankvoice.json)
  *   DANKVOICE_PLAYER   player binary, skipping detection
  *   DANKVOICE_VOICE    voice name ("" = server default)
- *   DANKVOICE_MAX      spoken-character cap per utterance (default 700)
+ *   DANKVOICE_MAX      spoken-character budget per answer (default 700)
  *   DANKVOICE_AUTO=1   start with auto-speak armed
+ *   DANKVOICE_REWRITE_URL   @tiny chat base URL (…/v1) for spoken-prose rewrite
+ *   DANKVOICE_REWRITE_MODEL chat model id (default: the @tiny role's model)
+ *   DANKVOICE_REWRITE=0     disable the rewrite step (speak mechanical text)
+ *   DANKVOICE_THINKING=0|1  narration of thinking blocks (default: on)
+ *   DANKVOICE_OMPCONFIG     omp config.yml to resolve the @tiny role from
  *
- * 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. 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.
+ * Long answers are cut into speakable segments by a state machine ported
+ * from omp's built-in vocalizer: strong boundaries on [.!?…] runs followed
+ * by whitespace (so "!!!!!" and "..." stay one boundary), guards for
+ * abbreviations and decimals, code fences and tables swallowed, markdown
+ * cleaned. Each segment is synthesized to a temp WAV in $TMPDIR and played
+ * to completion before the next request goes out — requests are strictly
+ * sequential, so audio never stacks. The chain runs detached from the event
+ * handler, so an utterance may outlive the harness handler timeout. A new
+ * utterance interrupts the previous one. 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";
@@ -185,25 +197,421 @@ export function playerFor(command: string, sink: string): Player {
   return { command, args: ["--target", sink] };
 }
 
-/** What a speech engine should say: prose only, no fences, no markup, bounded. */
-export function stripForSpeech(text: string, maxChars: number = DEFAULT_MAX_CHARS): string {
-  let out = text;
-  out = out.replace(/```[\s\S]*?```/g, " ");
-  out = out.replace(/~~~[\s\S]*?~~~/g, " ");
-  out = out.replace(/`([^`]*)`/g, "$1");
-  out = out.replace(/!\[[^\]]*\]\([^)]*\)/g, " ");
-  out = out.replace(/\[([^\]]*)\]\([^)]*\)/g, "$1");
-  out = out.replace(/^\s{0,3}#{1,6}\s+/gm, "");
-  out = out.replace(/^\s*[-*+]\s+/gm, "");
-  out = out.replace(/^\s*\|[-: |]+\|\s*$/gm, " ");
-  out = out.replace(/\|/g, " ");
-  out = out.replace(/[*_]{1,3}([^*_]+)[*_]{1,3}/g, "$1");
-  out = out.replace(/\s+/g, " ").trim();
-  if (out.length <= maxChars) return out;
-  const window = out.slice(0, maxChars);
-  const cut = Math.max(window.lastIndexOf(". "), window.lastIndexOf("! "), window.lastIndexOf("? "));
-  const clipped = cut > maxChars / 2 ? window.slice(0, cut + 1) : window.replace(/[,;:]\s*\S*$/, "");
-  return `${clipped.trim()} …`;
+// ------------------------------------------------------------ segmenting
+//
+// Ported from omp's built-in speak-aloud vocalizer (the `fHe` segmenter and
+// its helpers in dist/cli.js). The same boundary rules as the stock path,
+// kept deliberately: push() takes text and returns the segments that are
+// complete, flush() ends the message.
+
+const SENTENCE_END = /[.!?\u2026]+[)\]"'\u00BB\u201D\u2019]*\s/g;
+const WEAK_BREAK = /[,;:\u2014\u2013]\s/g;
+const ABBREVIATION = /(?:^|\s)(?:e\.g|i\.e|etc|vs|Mr|Mrs|Ms|Dr|St|No)\.$/i;
+const LINE_HEAD = /^(?:#{1,6}|[-*+]|-{2,}|\*{2,}|_{2,}|\d{1,3}|\d{1,3}[.)]|>+|`{1,2}|~{1,2})$/;
+const HORIZONTAL_RULE = /^(?:-{3,}|\*{3,}|_{3,})\s*$/;
+
+const IMAGE_LINK = /!\[([^\]]*)\]\(([^()]*)\)/g;
+const LINK = /\[([^\]]+)\]\(([^()]*)\)/g;
+const BRACKETED_URL = /<(https?:\/\/[^\s>]+)>/g;
+const BARE_URL = /\bhttps?:\/\/[^\s<>()"'\]]+|\bwww\.[\w-]+(?:\.[\w-]+)+[^\s<>()"'\]]*/g;
+const INLINE_CODE = /`{1,2}([^`]+)`{1,2}/g;
+const BOLD_MARKUP = /\*\*|__|~~/g;
+const STAR = /\*(?=\S)|(?<=\S)\*/g;
+const UNDERSCORE = /(^|\s)_+|_+(?=\s|$)/g;
+const HTML_TAG = /<\/?[a-zA-Z][^<>]*>/g;
+const EMPHASIS_RUN = /(^|\s)[-*_]{3,}(?=\s|$)/g;
+const DEEP_PATH = /(^|[\s("'`])((?:~|\.{1,2})?\/?[\w.@+-]+(?:\/[\w.@+-]+){2,}\/?)/g;
+const HAS_WORD = /[\p{L}\p{N}]/u;
+
+/** Speak a URL by host and a file path by its last segment. */
+export function spokenDomain(url: string): string {
+  return url.replace(/^[a-z][\w+.-]*:\/\//i, "").replace(/^www\./i, "").replace(/[/?#].*$/, "");
+}
+
+/** Final per-segment cleanup; empty when nothing speakable survived. */
+export function cleanForSpeech(text: string): string {
+  const out = text
+    .replace(IMAGE_LINK, "$1")
+    .replace(LINK, "$1")
+    .replace(BRACKETED_URL, (_match, url: string) => spokenDomain(url))
+    .replace(BARE_URL, (url: string) => spokenDomain(url))
+    .replace(INLINE_CODE, "$1")
+    .replace(BOLD_MARKUP, "")
+    .replace(STAR, "")
+    .replace(UNDERSCORE, "$1")
+    .replace(HTML_TAG, " ")
+    .replace(EMPHASIS_RUN, "$1")
+    .replace(DEEP_PATH, (_match, pre: string, path: string) => {
+      const parts = path.split("/").filter((part) => part.length > 0);
+      return pre + (parts[parts.length - 1] ?? path);
+    })
+    .replace(/\s+/g, " ")
+    .trim();
+  return HAS_WORD.test(out) ? out : "";
+}
+
+function sentenceBoundary(text: string, minChars: number): number {
+  SENTENCE_END.lastIndex = 0;
+  for (let match = SENTENCE_END.exec(text); match; match = SENTENCE_END.exec(text)) {
+    const end = match.index + match[0].length;
+    if (end < minChars) continue;
+    if (ABBREVIATION.test(text.slice(0, end).trimEnd())) continue;
+    if ((text.slice(0, end).match(/`/g)?.length ?? 0) % 2 !== 0) continue;
+    return end;
+  }
+  return -1;
+}
+
+function firstWeakBreak(text: string, minChars: number): number {
+  WEAK_BREAK.lastIndex = 0;
+  for (let match = WEAK_BREAK.exec(text); match; match = WEAK_BREAK.exec(text)) {
+    const end = match.index + match[0].length;
+    if (end >= minChars) return end;
+  }
+  return -1;
+}
+
+function lastWeakBreakWithin(text: string, minChars: number, maxChars: number): number {
+  WEAK_BREAK.lastIndex = 0;
+  let found = -1;
+  for (let match = WEAK_BREAK.exec(text); match; match = WEAK_BREAK.exec(text)) {
+    const end = match.index + match[0].length;
+    if (end > maxChars) break;
+    if (end >= minChars) found = end;
+  }
+  return found;
+}
+
+function wordWrapCut(text: string, maxChars: number): number {
+  const space = text.lastIndexOf(" ", maxChars);
+  return space > 0 ? space + 1 : Math.min(maxChars, text.length);
+}
+
+type LineHead =
+  | { kind: "swallow" }
+  | { kind: "fence"; fence: string }
+  | { kind: "marker"; spoken: string }
+  | { kind: "prose"; text: string }
+  | { kind: "undecided" };
+
+/** Classify a line start: tables and fences swallow, list markers get spoken. */
+export function classifyLineHead(head: string): LineHead {
+  if (head === "|") return { kind: "swallow" };
+  if (/^(?:`{3}|~{3})/.test(head)) return { kind: "fence", fence: head.slice(0, 3) };
+  if (/^#{1,6}[ \t]/.test(head)) return { kind: "marker", spoken: "" };
+  if (/^[-*+][ \t]/.test(head)) return { kind: "marker", spoken: "" };
+  const ordered = /^(\d{1,3})[.)][ \t]/.exec(head);
+  if (ordered) return { kind: "marker", spoken: `${ordered[1]}, ` };
+  if (/^>+/.test(head) && !/^>+$/.test(head)) return { kind: "prose", text: head.replace(/^>+[ \t]?/, "") };
+  if (LINE_HEAD.test(head)) return { kind: "undecided" };
+  return { kind: "prose", text: head };
+}
+
+type SegmenterState = "linestart" | "prose" | "swallow" | "code";
+
+/** The built-in vocalizer's segmenter: streamed text in, speakable segments out. */
+export class SpeechSegmenter {
+  #state: SegmenterState = "linestart";
+  #head = "";
+  #fence = "";
+  #fenceLine = "";
+  #resume: SegmenterState = "linestart";
+  #buffer = "";
+  #started = false;
+
+  push(chunk: string): string[] {
+    const out: string[] = [];
+    for (const char of chunk) this.#feed(char, out);
+    this.#split(out);
+    return out;
+  }
+
+  flush(): string[] {
+    const out: string[] = [];
+    if (this.#state === "linestart" && this.#head.length > 0 && !HORIZONTAL_RULE.test(this.#head)) this.#buffer += this.#head;
+    this.#head = "";
+    this.#state = "linestart";
+    this.#emit(out);
+    return out;
+  }
+
+  /** Streaming idle flush: only cut a tail that already looks finished. */
+  flushIdle(): string[] {
+    const out: string[] = [];
+    const tail = this.#buffer.trimEnd();
+    if (!/[.!?\u2026][)\]"'\u00BB\u201D\u2019]*$/.test(tail) && tail.length < 24) return out;
+    this.#emit(out);
+    return out;
+  }
+
+  #feed(char: string, out: string[]): void {
+    switch (this.#state) {
+      case "linestart":
+        this.#feedLineStart(char, out);
+        return;
+      case "prose":
+        if (char === "\n") this.#endLine(out);
+        else this.#buffer += char;
+        return;
+      case "swallow":
+        if (char === "\n") this.#state = this.#resume;
+        return;
+      case "code":
+        this.#feedCode(char);
+        return;
+    }
+  }
+
+  #feedLineStart(char: string, out: string[]): void {
+    if (char === "\n") {
+      const head = this.#head;
+      this.#head = "";
+      if (head.length > 0 && !HORIZONTAL_RULE.test(head)) this.#buffer += head;
+      this.#endLine(out);
+      return;
+    }
+    this.#head += char;
+    const classified = classifyLineHead(this.#head);
+    if (classified.kind === "undecided") {
+      if (this.#head.length > 8) {
+        this.#buffer += this.#head;
+        this.#head = "";
+        this.#state = "prose";
+      }
+      return;
+    }
+    this.#head = "";
+    switch (classified.kind) {
+      case "prose":
+        this.#buffer += classified.text;
+        this.#state = "prose";
+        return;
+      case "marker":
+        this.#buffer += classified.spoken;
+        this.#state = "prose";
+        return;
+      case "swallow":
+        this.#state = "swallow";
+        this.#resume = "linestart";
+        return;
+      case "fence":
+        this.#fence = classified.fence;
+        this.#fenceLine = "";
+        this.#state = "swallow";
+        this.#resume = "code";
+        return;
+    }
+  }
+
+  #feedCode(char: string): void {
+    if (char === "\n") {
+      this.#fenceLine = "";
+      return;
+    }
+    if (this.#fenceLine.length < 3) {
+      this.#fenceLine += char;
+      if (this.#fenceLine === this.#fence) {
+        this.#state = "swallow";
+        this.#resume = "linestart";
+      }
+    }
+  }
+
+  #endLine(out: string[]): void {
+    this.#state = "linestart";
+    this.#emit(out);
+  }
+
+  #emit(out: string[]): void {
+    this.#split(out);
+    const segment = this.#buffer;
+    this.#buffer = "";
+    this.#pushSegment(segment, out);
+  }
+
+  #split(out: string[]): void {
+    for (;;) {
+      const buffer = this.#buffer;
+      const boundary = sentenceBoundary(buffer, this.#started ? 24 : 12);
+      if (boundary !== -1 && boundary <= 280) {
+        this.#cut(boundary, out);
+        continue;
+      }
+      if (!this.#started && buffer.length >= 40) {
+        const weak = firstWeakBreak(buffer, 12);
+        if (weak !== -1 && weak <= 140) {
+          this.#cut(weak, out);
+          continue;
+        }
+        if (buffer.length >= 140) {
+          this.#cut(wordWrapCut(buffer, 140), out);
+          continue;
+        }
+      }
+      if (this.#started && buffer.length >= 160) {
+        const weak = lastWeakBreakWithin(buffer, 24, 160);
+        if (weak !== -1) {
+          this.#cut(weak, out);
+          continue;
+        }
+      }
+      if (buffer.length > 280) {
+        const weak = lastWeakBreakWithin(buffer, 24, 280);
+        this.#cut(weak !== -1 ? weak : wordWrapCut(buffer, 280), out);
+        continue;
+      }
+      return;
+    }
+  }
+
+  #cut(end: number, out: string[]): void {
+    const head = this.#buffer.slice(0, end);
+    this.#buffer = this.#buffer.slice(end);
+    this.#pushSegment(head, out);
+  }
+
+  #pushSegment(raw: string, out: string[]): void {
+    const cleaned = cleanForSpeech(raw);
+    if (!cleaned) return;
+    out.push(cleaned);
+    this.#started = true;
+  }
+}
+
+/** A whole message to speakable segments: the segmenter run start to end. */
+export function segmentsForSpeech(text: string): string[] {
+  const segmenter = new SpeechSegmenter();
+  const segments = segmenter.push(text);
+  for (const tail of segmenter.flush()) segments.push(tail);
+  return segments;
+}
+
+/** The leading whole segments that fit the user's spoken-character budget. */
+export function budgetSegments(segments: string[], maxChars: number): string[] {
+  const chosen: string[] = [];
+  let used = 0;
+  for (const segment of segments) {
+    if (used + segment.length > maxChars) break;
+    used += segment.length;
+    chosen.push(segment);
+  }
+  return chosen;
+}
+
+// ------------------------------------------------------------ humanization
+//
+// Port of the built-in vocalizer's speech enhancer (the `Qyr` class and its
+// system prompt `T6o` in dist/cli.js): rewrite each unit into natural spoken
+// prose with the @tiny model before synthesis. Same prompt, same budgets
+// (1536 max tokens, 6 s, 4000-char input window), and the same contract:
+// null means the enhancer failed — fall back to the mechanical text — while
+// an empty string means the enhancer found nothing worth saying.
+
+const REWRITE_MAX_TOKENS = 1536;
+const REWRITE_TIMEOUT_MS = 6_000;
+const REWRITE_MAX_INPUT = 4_000;
+
+const REWRITE_SYSTEM_PROMPT = `Rewrite coding-assistant replies as words a person would say aloud. Audience: developer listening while working; written reply remains onscreen. Narrate; NEVER dictate syntax.
+
+Output ONLY spoken words—no Markdown, quotes, preamble, or stage directions.
+
+- Natural colleague-over-the-shoulder summary. Preserve original meaning, order, tone; add no opinions, greetings, or content absent from text.
+- NEVER read URLs, Markdown/table syntax, or separators. Link: label or site name ("the Bun issue on GitHub"). File path: file name only (say "vocalizer.ts," not "vocalizer dot t s").
+- Code blocks: NEVER read; replace each with one short clause describing it or its function ("a small helper that retries the request"). Skip it if surrounding prose already explains it.
+- Short inline identifiers, flags, commands: speak as-is ("run bun check"); paraphrase if awkward.
+- Speak numbers, versions, symbols naturally: "v1.2" → "version one point two"; "→" → "to"; "&" → "and"; "~5s" → "about five seconds".
+- Lists: flowing sentences ("first, then, and finally"); NEVER recite bullets or numbers.
+- Concise: same length or shorter; compress boilerplate, NEVER pad.
+- Partial mid-thought fragments: render only what exists; NEVER invent an ending.
+- Pure code, tables, or markup: empty reply.
+`;
+
+export interface RewriteTarget {
+  /** OpenAI-compatible chat completions route of the @tiny model. */
+  chatUrl: string;
+  /** Served model id to name in the request body. */
+  model: string;
+}
+
+/**
+ * Resolve the @tiny role the way the harness does: `modelRoles.tiny` in
+ * config.yml reads `provider (host)/model:effort`; the provider block in
+ * models.yml supplies the base URL. Unknown role or provider → undefined.
+ */
+export function resolveTinyRewriter(modelsYml: string, configYml: string): RewriteTarget | undefined {
+  const role = configYml.match(/^[ \t]*tiny:[ \t]*(.+?)[ \t]*$/m)?.[1];
+  if (!role) return undefined;
+  const ref = role.includes(":") ? role.slice(0, role.lastIndexOf(":")) : role;
+  const slash = ref.lastIndexOf("/");
+  if (slash <= 0) return undefined;
+  const wantProvider = ref.slice(0, slash).trim();
+  const wantModel = ref.slice(slash + 1).trim();
+  if (!wantProvider || !wantModel) return undefined;
+  let inProvider = false;
+  let base: string | undefined;
+  for (const line of modelsYml.split(/\r?\n/)) {
+    const key = line.match(/^ {2}"?([^"\s][^":]*?)"?[ \t]*:[ \t]*$/);
+    if (key) {
+      inProvider = key[1].trim() === wantProvider;
+      base = undefined;
+      continue;
+    }
+    if (!inProvider) continue;
+    const url = line.trim().match(/^baseUrl:\s*(\S+)/);
+    if (url) {
+      base = url[1].replace(/\/+$/, "");
+      continue;
+    }
+    if (line.trim().match(/^-\s*id:\s*(\S+)/)?.[1] === wantModel && base) {
+      return { chatUrl: `${base}/chat/completions`, model: wantModel };
+    }
+  }
+  return undefined;
+}
+
+/** Env override first, then the @tiny role; both miss → no humanization. */
+export function resolveRewriter(env: NodeJS.ProcessEnv, modelsYml: string, configYml: string): RewriteTarget | undefined {
+  const override = env.DANKVOICE_REWRITE_URL?.trim().replace(/\/+$/, "");
+  if (override) return { chatUrl: `${override}/chat/completions`, model: env.DANKVOICE_REWRITE_MODEL?.trim() || "tiny" };
+  return resolveTinyRewriter(modelsYml, configYml);
+}
+
+/** The enhancer's rewrite step; never throws — null is its "couldn't". */
+export async function rewriteForSpeech(target: RewriteTarget, text: string): Promise<string | null> {
+  try {
+    const res = await fetch(target.chatUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        model: target.model,
+        messages: [
+          { role: "system", content: REWRITE_SYSTEM_PROMPT },
+          { role: "user", content: text.slice(0, REWRITE_MAX_INPUT) },
+        ],
+        max_tokens: REWRITE_MAX_TOKENS,
+      }),
+      signal: AbortSignal.timeout(REWRITE_TIMEOUT_MS),
+    });
+    if (!res.ok) return null;
+    const payload: unknown = await res.json();
+    if (!payload || typeof payload !== "object" || !("choices" in payload) || !Array.isArray(payload.choices) || payload.choices.length === 0) return null;
+    const first: unknown = payload.choices[0];
+    if (!first || typeof first !== "object" || !("message" in first)) return null;
+    const message: unknown = first.message;
+    if (!message || typeof message !== "object" || !("content" in message)) return null;
+    const content: unknown = message.content;
+    if (typeof content === "string") return content.trim();
+    if (!Array.isArray(content)) return null;
+    const parts: string[] = [];
+    for (const part of content) {
+      if (part && typeof part === "object" && "type" in part && part.type === "text" && "text" in part && typeof part.text === "string") {
+        parts.push(part.text);
+      }
+    }
+    return parts.join(" ").trim();
+  } catch {
+    return null;
+  }
 }
 
 /** The text the assistant last actually said; tool-only messages do not count. */
@@ -217,8 +625,12 @@ export function lastAssistantText(messages: readonly unknown[]): string {
     if (!Array.isArray(content)) continue;
     const parts: string[] = [];
     for (const part of content) {
-      if (part && typeof part === "object" && "type" in part && part.type === "text" && "text" in part && typeof part.text === "string") {
+      if (!part || typeof part !== "object" || !("type" in part)) continue;
+      if (part.type === "text" && "text" in part && typeof part.text === "string") {
         parts.push(part.text);
+      } else if (part.type === "thinking" && "narration" in part && part.narration === true && "thinking" in part && typeof part.thinking === "string") {
+        // provider-returned thinking addressed to the user: it is answer text
+        parts.push(part.thinking);
       }
     }
     const joined = parts.join("\n").trim();
@@ -227,6 +639,23 @@ export function lastAssistantText(messages: readonly unknown[]): string {
   return "";
 }
 
+/** The last assistant message's true thinking blocks; narration-flagged ones are answer text elsewhere. */
+export function lastAssistantThinking(messages: readonly unknown[]): string {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (!message || typeof message !== "object" || !("role" in message) || message.role !== "assistant") continue;
+    if (!("content" in message) || !Array.isArray(message.content)) return "";
+    const parts: string[] = [];
+    for (const part of message.content) {
+      if (part && typeof part === "object" && "type" in part && part.type === "thinking" && !(("narration" in part) && part.narration === true) && "thinking" in part && typeof part.thinking === "string") {
+        parts.push(part.thinking);
+      }
+    }
+    return parts.join("\n").trim();
+  }
+  return "";
+}
+
 /** Menu choices, persisted between sessions; every field optional. */
 export interface Settings {
   voice?: string;
@@ -234,6 +663,7 @@ export interface Settings {
   sink?: string;
   maxChars?: number;
   auto?: boolean;
+  thinking?: boolean;
 }
 
 /** Where menu choices live: DANKVOICE_CONFIG, else ~/.omp/cache/dankvoice.json. */
@@ -252,6 +682,7 @@ export function readSettings(path: string): Settings {
     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;
+    if (typeof raw.thinking === "boolean") settings.thinking = raw.thinking;
     return settings;
   } catch {
     return {};
@@ -281,11 +712,13 @@ export function parseSinkList(output: string): SinkRow[] {
 
 interface Config {
   target?: SpeechTarget;
+  rewriter?: RewriteTarget;
   player?: Player;
   sink: string;
   maxChars: number;
   auto: boolean;
   voice: string;
+  thinking: boolean;
 }
 
 function lookupOnPath(command: string): string | null {
@@ -302,12 +735,22 @@ function readModelsYml(): string {
   }
 }
 
+function readOmpConfigYml(): string {
+  const path = process.env.DANKVOICE_OMPCONFIG ?? join(process.env.HOME ?? "", ".omp", "agent", "config.yml");
+  try {
+    return readFileSync(path, "utf8");
+  } catch {
+    return "";
+  }
+}
+
 function loadConfig(): Config {
   const env = process.env;
   const settings = readSettings(settingsPath(env));
+  const modelsYml = readModelsYml();
   const overrideUrl = env.DANKVOICE_URL?.trim().replace(/\/+$/, "");
   const modelOverride = env.DANKVOICE_MODEL?.trim();
-  const fromYml = overrideUrl ? undefined : resolveSpeechEndpoint(readModelsYml());
+  const fromYml = overrideUrl ? undefined : resolveSpeechEndpoint(modelsYml);
   const target: SpeechTarget | undefined = overrideUrl
     ? {
         speechUrl: `${overrideUrl}/audio/speech`,
@@ -321,13 +764,17 @@ function loadConfig(): Config {
   const playerCommand = env.DANKVOICE_PLAYER?.trim() || settings.player || availablePlayers(lookupOnPath)[0];
   const sink = settings.sink ?? "";
   const maxChars = Number(env.DANKVOICE_MAX);
+  const rewriter = env.DANKVOICE_REWRITE === "0" ? undefined : resolveRewriter(env, modelsYml, readOmpConfigYml());
+  const thinking = env.DANKVOICE_THINKING === "1" ? true : env.DANKVOICE_THINKING === "0" ? false : (settings.thinking ?? true);
   return {
     target,
+    rewriter,
     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 ?? "",
+    thinking,
   };
 }
 
@@ -408,14 +855,16 @@ function startPlayback(player: Player, file: string, dir: string): ChildProcess
 
 export default function dankvoice(pi: ExtensionAPI) {
   const cfg = loadConfig();
-  const state: { auto: boolean; voice: string; child?: ChildProcess; lastCtx?: ExtensionContext } = {
+  const state: { auto: boolean; voice: string; child?: ChildProcess; run: number; lastCtx?: ExtensionContext } = {
     auto: cfg.auto,
     voice: cfg.voice,
+    run: 0,
   };
   const voiceLabel = () => state.voice || "server default";
   const reflectStatus = () => state.lastCtx?.ui.setStatus("dankvoice", state.auto ? `🔊 ${voiceLabel()}` : undefined);
 
   const stop = () => {
+    state.run += 1; // retire the live chain; its loop stops at the next gate
     if (state.child && state.child.exitCode === null) state.child.kill("SIGTERM");
     state.child = undefined;
   };
@@ -429,6 +878,7 @@ export default function dankvoice(pi: ExtensionAPI) {
       sink: cfg.sink,
       maxChars: cfg.maxChars,
       auto: state.auto,
+      thinking: cfg.thinking,
     };
     try {
       writeFileSync(settingsPath(process.env), `${JSON.stringify(settings, null, 2)}\n`);
@@ -455,9 +905,15 @@ export default function dankvoice(pi: ExtensionAPI) {
     persistSettings(ctx);
   };
 
-  async function speak(ctx: ExtensionContext, text: string) {
-    const spoken = stripForSpeech(text, cfg.maxChars);
-    if (!spoken) return;
+  /**
+   * Speak one answer as strictly sequential requests: synthesize a segment,
+   * play it to the end, only then ask for the next — audio never stacks.
+   * Like the built-in enhancer path, each unit (thinking first, then the
+   * answer) is rewritten into spoken prose by the @tiny model before
+   * segmentation; a failed rewrite falls back to the mechanical text and an
+   * empty rewrite skips its unit. Superseded chains exit at the gates.
+   */
+  async function speak(ctx: ExtensionContext, text: string, thinking = "") {
     if (!cfg.target) {
       ctx.ui.notify(missingTarget(), "error");
       return;
@@ -466,19 +922,47 @@ export default function dankvoice(pi: ExtensionAPI) {
       ctx.ui.notify("dankvoice: no audio player found (pw-play, paplay or ffplay)", "error");
       return;
     }
+    const target = cfg.target;
+    const player = cfg.player;
+    const units: string[] = [];
+    if (cfg.thinking && thinking.trim()) units.push(thinking.trim());
+    if (text.trim()) units.push(text.trim());
+    const segments: string[] = [];
+    let used = 0;
+    for (const unit of units) {
+      const rewritten = cfg.rewriter ? await rewriteForSpeech(cfg.rewriter, unit) : null;
+      if (rewritten === "") continue;
+      const chosen = budgetSegments(segmentsForSpeech(rewritten ?? unit), Math.max(0, cfg.maxChars - used));
+      used += chosen.reduce((chars, segment) => chars + segment.length, 0);
+      segments.push(...chosen);
+    }
+    if (segments.length === 0) return;
     stop();
-    const dir = mkdtempSync(join(tmpdir(), "dankvoice-"));
-    try {
-      const file = await synthesize(cfg.target, speechBody(cfg.target.model, spoken, state.voice), dir, SYNTH_TIMEOUT_MS);
-      state.child = startPlayback(cfg.player, file, dir);
-    } catch (error) {
-      stop();
+    const run = state.run;
+    for (const segment of segments) {
+      if (state.run !== run) return;
+      const dir = mkdtempSync(join(tmpdir(), "dankvoice-"));
       try {
-        rmSync(dir, { recursive: true, force: true });
-      } catch {
-        // ignore
+        const file = await synthesize(target, speechBody(target.model, segment, state.voice), dir, SYNTH_TIMEOUT_MS);
+        if (state.run !== run) {
+          rmSync(dir, { recursive: true, force: true });
+          return;
+        }
+        await new Promise<void>((resolve) => {
+          const child = startPlayback(player, file, dir);
+          state.child = child;
+          child.once("exit", () => resolve());
+          child.once("error", () => resolve());
+        });
+      } catch (error) {
+        try {
+          rmSync(dir, { recursive: true, force: true });
+        } catch {
+          // temp files are not worth a toast
+        }
+        ctx.ui.notify(`dankvoice: ${error instanceof Error ? error.message : String(error)}`, "error");
+        return;
       }
-      ctx.ui.notify(`dankvoice: ${error instanceof Error ? error.message : String(error)}`, "error");
     }
   }
 
@@ -489,6 +973,8 @@ export default function dankvoice(pi: ExtensionAPI) {
       `Output device: ${cfg.sink || "system default"} (change)`,
       `Player: ${cfg.player?.command ?? "none"} (change)`,
       `Spoken cap: ${cfg.maxChars} chars (change)`,
+      `Thinking narration: ${cfg.thinking ? "on" : "off"} (toggle)`,
+      `Humanize answers: ${cfg.rewriter ? `on (${cfg.rewriter.model})` : "off"} (toggle)`,
       "Speak a test phrase",
     ];
     const choice = await ctx.ui.select("dankvoice — options", options);
@@ -545,6 +1031,18 @@ export default function dankvoice(pi: ExtensionAPI) {
       persistSettings(ctx);
       return;
     }
+    if (choice === options[5]) {
+      cfg.thinking = !cfg.thinking;
+      ctx.ui.notify(`dankvoice: thinking narration ${cfg.thinking ? "on" : "off"}`, "info");
+      persistSettings(ctx);
+      return;
+    }
+    if (choice === options[6]) {
+      cfg.rewriter = cfg.rewriter ? undefined : resolveRewriter(process.env, readModelsYml(), readOmpConfigYml());
+      ctx.ui.notify(cfg.rewriter ? `dankvoice: humanizing with ${cfg.rewriter.model}` : "dankvoice: humanization off", "info");
+      persistSettings(ctx);
+      return;
+    }
     await speak(ctx, `dankvoice: ${voiceLabel()} through ${cfg.player?.command ?? "no player"}, checking.`);
   }
 
@@ -598,18 +1096,18 @@ 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"} · device ${cfg.sink || "system default"} · 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 · thinking ${cfg.thinking ? "on" : "off"} · humanize ${cfg.rewriter ? cfg.rewriter.model : "off"}`,
             "info",
           );
           return;
         case "speak":
-          await speak(ctx, action.text);
+          void speak(ctx, action.text).catch((error) => ctx.ui.notify(`dankvoice: ${error instanceof Error ? error.message : String(error)}`, "error"));
           return;
       }
     },
   });
 
-  pi.on("agent_end", async (event, ctx) => {
+  pi.on("agent_end", (event, ctx) => {
     state.lastCtx = ctx;
     if (!state.auto) return;
     // `willContinue` means the harness already scheduled a continuation
@@ -617,7 +1115,12 @@ export default function dankvoice(pi: ExtensionAPI) {
     // settle, so narrating it would speak an answer the model is about to redo.
     if (event.willContinue) return;
     if (ctx.mode === "print" || ctx.mode === "json") return;
-    await speak(ctx, lastAssistantText(event.messages));
+    // Fire-and-forget: a multi-segment utterance legitimately outlives the
+    // harness's handler timeout, and blocking here would only produce a
+    // spurious "handler timed out" toast while playback continues anyway.
+    void speak(ctx, lastAssistantText(event.messages), lastAssistantThinking(event.messages)).catch((error) =>
+      ctx.ui.notify(`dankvoice: ${error instanceof Error ? error.message : String(error)}`, "error"),
+    );
   });
 
   pi.on("session_shutdown", () => {

omp-docs/core/dankvoice.md

@@ -9,17 +9,19 @@ tags:
   - voice
   - frank-tts
   - dankclaw
-verified: 2026-10-18
-timestamp: 2026-10-18
+verified: 2026-10-19
+timestamp: 2026-10-19
 ---
 
 # dankvoice
 
 `agent/extensions/dankvoice.ts` adds cloned-voice speech to the interactive
 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)).
+speakers and `/say on` narrates the assistant's thinking and final answer
+after every turn. The words are first rewritten into natural spoken prose by
+the **@tiny** role model (exactly what the built-in vocalizer's
+`speech.enhanced` does), and everything is served by **frank-tts**
+(Dankclaw :7772, the `speech` model role in [agent/models.yml](/core/index.md)).
 
 ## Why it exists
 
@@ -39,13 +41,13 @@ 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` \| `/say menu` | options menu (`ctx.ui.select`): auto-speak toggle, voice, output device, player, spoken cap, thinking-narration toggle, humanize toggle, 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 on` \| `/say off` | arm/disarm auto-speak of the thinking blocks and 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, device, cap |
+| `/say status` \| `/say help` | endpoint, voice, player, device, cap, thinking, humanize |
 
 Menu choices persist to `~/.omp/cache/dankvoice.json` (runtime state, never
 tracked); the environment overrides the file, the file overrides defaults.
@@ -54,9 +56,43 @@ 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
-collapse to their label, bullets and table pipes disappear — and the utterance
-is truncated at a sentence boundary inside the cap.
+silent. Each spoken unit — thinking first when narrated, then the answer —
+is first rewritten into spoken prose by the @tiny model; when the enhancer
+(below) declines, the text goes to segmentation as-is, where fenced code and
+tables vanish, links collapse to their label and bullets and table pipes
+disappear. A long answer is never one monolithic synthesis request; see
+[Segmentation](#segmentation) for how utterances are cut and played.
+
+## Segmentation
+
+Utterances are cut by a state machine ported from the harness's own
+speak-aloud vocalizer (the minified `fHe` class in the agent bundle's
+`dist/cli.js`), kept deliberately in lockstep with the stock path:
+
+* A strong boundary is a run of `[.!?…]` followed by whitespace — so
+  `!!!!!` and `...` are one boundary, never a pile of cuts.
+* Boundaries after `e.g.`, `etc.`, `Mr.` and friends, or inside inline
+  code, don't count; decimals (`3.5`, `1,5`) survive because a boundary
+  requires trailing whitespace.
+* Line starts are classified: table rows and fenced code are swallowed
+  whole (their content is never read aloud), heading and bullet markers
+  vanish, ordered-list markers speak their number ("1, …"), quote markers
+  strip.
+* Per segment, markdown is cleaned: links collapse to their label, URLs
+  to their host, deep paths to their last segment; emphasis markup dies.
+* Segments aim for one sentence; run-ons break at commas or word wraps
+  before 280 characters.
+
+Playback is strictly sequential: segment N+1 is synthesized only after
+segment N's player process exited, so audio never stacks. The chain runs
+detached from `agent_end` (fire-and-forget) and may legitimately outlive
+the harness's 30 s handler timeout — the old awaiting design produced a
+"handler timed out after 30000ms" toast on long answers. A new utterance,
+`/say stop`, or disarming auto-speak retires the live chain through a run
+token: the current player is killed and pending segments are skipped.
+`DANKVOICE_MAX` is a per-answer character budget: the leading whole
+segments that fit are spoken, the rest are dropped — the thinking unit
+draws on it before the answer does.
 
 ## Endpoint resolution
 
@@ -73,9 +109,14 @@ resolves, so no host address and no credential appears in this file. From
 | `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_MAX` | `700` | spoken-character budget per answer (whole leading segments, shared by the thinking and answer units) |
 | `DANKVOICE_PLAYER` | detect | player binary, skipping detection |
 | `DANKVOICE_MODELS` | `~/.omp/agent/models.yml` | YAML to read the endpoint from |
+| `DANKVOICE_REWRITE_URL` | the @tiny role | chat base URL (`…/v1`) for the enhancer, bypassing role resolution |
+| `DANKVOICE_REWRITE_MODEL` | the @tiny role's model | chat model named in the rewrite body |
+| `DANKVOICE_REWRITE=0` | enhancer on when a route resolves | speak mechanical text |
+| `DANKVOICE_THINKING` | settings file, default on | `0`/`1` force thinking narration off/on |
+| `DANKVOICE_OMPCONFIG` | `~/.omp/agent/config.yml` | YAML to read the `modelRoles.tiny` role from |
 
 Player detection order is `pw-play` → `paplay` → `ffplay` (PipeWire first:
 the workstations run WirePlumber). A saved output device routes the player
@@ -86,7 +127,29 @@ 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)
+## Humanized narration (the @tiny role)
+
+The built-in vocalizer never reads answers aloud verbatim when
+`speech.enhanced` is on: a small model rewrites each utterance into words a
+person would say. `dankvoice` ports that enhancer — same system prompt
+(verbatim from the bundle), same budgets (1536 max tokens, 6 s timeout,
+4000-char input window), same contract (a failed rewrite falls back to the
+mechanically cleaned text; an empty rewrite skips the unit as "nothing to
+say"). The target model is the harness's `@tiny` role, resolved the way the
+harness resolves it: `modelRoles.tiny` in `agent/config.yml` reads
+`provider (host)/model:effort`; the provider block in `agent/models.yml`
+supplies the `baseUrl`; the request is `POST {base}/chat/completions`. On
+this fleet that is **frank-zealot** (`llamacpp (dankclaw-3090)`,
+`:7771`) — the 6 s abort keeps a slow tiny model off the critical path.
+
+Thinking blocks ride the same path: at `agent_end` the last assistant
+message's true `thinking` parts are narrated (rewritten first, as their own
+unit, before the answer), while blocks flagged `narration: true` — which
+providers use to address the user through the thinking channel — count as
+answer text. The menu, `/say status`, and `DANKVOICE_THINKING` toggle it;
+the choice persists in the settings file.
+
+## Verified facts (2026-10-18, extended 2026-10-19)
 
 * **Extension discovery** — any `.ts` file in `~/.omp/agent/extensions/` loads
   at startup: a probe file there printed `loaded 2026-10-19T02:36:55Z` from a
@@ -118,6 +181,21 @@ its directory are removed when the player process exits.
   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>`.
+* **Segmented playback** — driver scenarios 2026-10-19: "First stop here.
+  Second one goes!!! Really? Third ... done" produced exactly 3 sequential
+  requests and 3 plays; "Model 3.5 ships today. Version 1,5 too." produced
+  exactly 2 (decimals never split); the markdown fixture's fenced code and
+  URL never reached the fixture endpoint; with `DANKVOICE_MAX=60` only the
+  leading segment was spoken.
+* **Humanize + thinking (2026-10-19, Refs #27)** — driver scenarios cover the
+  rewrite round-trip (fixture chat route), the 404 → mechanical fallback,
+  thinking narrated as its own unit before the answer, `DANKVOICE_THINKING=0`
+  silencing it, and `narration: true` spoken once as the answer; the endpoint
+  status line shows the resolved humanize model from the @tiny role. Live
+  smoke against the real services: a markdown `/say` became 3 sequential
+  prose segments (mechanical cleanup of that text yields at most 2), and a
+  thinking+answer `agent_end` played thinking first. 22 green in
+  `tests/dankvoice.bats`.
 
 ## Limits
 
@@ -125,8 +203,13 @@ its directory are removed when the player process exits.
   a compile-time enum in the harness bundle, and no setting routes it to
   frank-tts. Cloned voices live only on this file-producing/speaking path and
   on the `tts` tool. See [Handy](/tools/handy.md) for the STT half.
-* `agent_end` narrates the final message text only — mid-turn tool chatter is
-  never spoken.
+* `agent_end` narrates thinking blocks and the final message only — mid-turn
+  tool chatter is never spoken. Thinking covers the last assistant message;
+  tool-loop gaps in earlier messages are skipped by design.
+* Humanized narration is serial: audio starts only after the @tiny rewrite
+  returns (≤ 6 s per unit, then frank-tts synthesis). Say `/say off`-grade
+  latency is the price of prose; `DANKVOICE_REWRITE=0` trades it back for
+  instant mechanical speech.
 * frank-tts is LAN-only: no Caddy vhost fronts :7772, so this extension is
   usable on the home network.
 * Deployment, packs and the voice registry are owned by the
@@ -141,8 +224,14 @@ its directory are removed when the player process exits.
 * `omp --help` (extension discovery flags, `say`, `plugin`) and
   `@earendil-works/pi-coding-agent` `dist/core/extensions/types.d.ts`
   (`ExtensionAPI.on/registerCommand`, `ExtensionMode = "tui" | "rpc" | "json" | "print"`).
+* The stock speak-aloud implementation — vocalizer pipeline `I6o`, utterance
+  segmenter `fHe` and speech enhancer `Qyr` with its prompt `T6o` — in
+  `@oh-my-pi/pi-coding-agent`'s `dist/cli.js`, read off the minified bundle
+  2026-10-19: dankvoice ports the mechanical and the enhanced halves, so an
+  LLM rewrite does happen before frank-tts.
 * 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).
+* Gitea issue #27 on `dank/command-center` (the enhanced-narration work item).
 
 ## See Also
 

omp-docs/log.md

@@ -12,6 +12,45 @@ timestamp: 2026-08-28
 # Bundle Change Log
 
 
+## 2026-10-19 — dankvoice: humanized narration and thinking aloud (Refs #27)
+
+dankvoice answered in verbatim markdown-cleaned text while the built-in
+vocalizer speaks humanized prose — the bundle's `Qyr` enhancer (`speech.enhanced`,
+system prompt `T6o`) now lives in the extension: every spoken unit is rewritten
+by the @tiny role (resolved from `modelRoles.tiny` in config.yml + the provider
+baseUrl in models.yml → frank-zealot :7771) under the same budgets (1536 tokens,
+6 s, 4000-char window), with mechanical cleanup as the fallback and an empty
+rewrite skipping the unit. Auto-speak also narrates the last assistant message's
+thinking blocks before the answer (`narration: true` blocks count as answer
+text); both are menu-toggleable and persisted (`thinking` in the settings file),
+env levers `DANKVOICE_REWRITE_URL/MODEL/REWRITE=0/THINKING/OMPCONFIG`. The
+fixture grows a chat route with echo/prose modes; 7 new scenarios, 22 green.
+Live smoke: a markdown answer became 3 sequential prose segments through real
+zealot + frank-tts, thinking played before its answer.
+
+## 2026-10-19 — dankvoice: segmented sequential speech, copied from the bundle's vocalizer
+
+Silent-answer incident follow-up: `agent_end` awaiting one whole-answer
+synthesis hit the harness's 30 s extension-handler timeout
+(`handler timed out after 30000ms`) on long answers, and the single frank-tts
+request for the entire answer was the stall. Instead of inventing a heuristic,
+ported the utterance-splitting state machine out of the built-in speak-aloud
+vocalizer (minified class `fHe` in `dist/cli.js`): strong boundaries are
+`[.!?…]+` runs followed by whitespace — `!!!!!`/`...` stay one cut — with
+abbreviation and inline-code guards; `3.5`/`1,5` survive because a boundary
+needs trailing whitespace; fenced code and tables swallow whole; headings and
+bullets vanish, ordered markers speak their number ("1, "); links collapse to
+labels, URLs to hosts, paths to basenames; run-ons break at commas or word
+wraps before 280 chars. `speak()` now synthesizes segment N+1 only after
+segment N's player exited — strictly sequential, audio never stacks — and
+`agent_end`/`/say <text>` fire-and-forget a chain retired through a run token
+by `/say stop`, disarming, or a newer utterance. `DANKVOICE_MAX` became a
+per-answer budget of whole leading segments; the hand-rolled `stripForSpeech`
+truncator is gone. No LLM "humanization" rewrite happens (the bundle's
+`speech.enhanced` rewrites with the tiny/smol model; dankvoice speaks
+mechanically cleaned text through the cloned voices). Tests: two new driver
+scenarios plus two rewrites, 17/17 in `tests/dankvoice.bats`.
+
 ## 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

tests/dankvoice.bats

@@ -68,6 +68,13 @@ providers:
         api: openai-speech
 YML
 
+  # omp config.yml fixture: the @tiny role points at the chat provider above
+  export DV_OMPCONFIG="$WORK/ompconfig.yml"
+  cat > "$DV_OMPCONFIG" <<'CFY'
+modelRoles:
+  tiny: chat (box)/chatmodel:off
+CFY
+
   cat > "$WORK/driver.ts" <<'TS'
 // Black-box driver: stand up the frank-tts fixture, load the extension against
 // it, invoke one scenario, print what the endpoint received and what got played.
@@ -95,6 +102,14 @@ const server = createServer((req, res) => {
       res.end(AUDIO);
       return;
     }
+    if (process.env.DV_REWRITE && req.url?.endsWith("/chat/completions")) {
+      res.setHeader("content-type", "application/json");
+      const spoken = process.env.DV_REWRITE === "echo"
+        ? String(JSON.parse(body).messages?.[1]?.content ?? "")
+        : "Spoken, humanized words.";
+      res.end(JSON.stringify({ choices: [{ message: { content: spoken } }] }));
+      return;
+    }
     res.statusCode = 404;
     res.end("{}");
   });
@@ -107,6 +122,8 @@ if (scenario === "endpoint") {
 } else {
   process.env.DANKVOICE_URL = `http://127.0.0.1:${port}/v1`;
 }
+process.env.DANKVOICE_OMPCONFIG = process.env.DV_OMPCONFIG;
+if (scenario !== "endpoint") process.env.DANKVOICE_REWRITE_URL = `http://127.0.0.1:${port}/v1`;
 if (scenario === "noplayer") process.env.PATH = process.env.DV_EMPTY_BIN ?? "/nonexistent-bin";
 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;
@@ -189,6 +206,23 @@ if (!say) {
     case "truncate":
       await say.handler("Sentence one is here. ".repeat(40), ctx);
       break;
+    case "sentences":
+      await say.handler("First stop here. Second one goes!!! Really? Third ... done", ctx);
+      break;
+    case "decimals":
+      await say.handler("Model 3.5 ships today. Version 1,5 too.", ctx);
+      break;
+    case "rewrite":
+      await say.handler("The deploy failed because a secret was missing.", ctx);
+      break;
+    case "thinking":
+      await say.handler("on", ctx);
+      await agentEnd?.({ messages: [{ role: "assistant", content: [{ type: "thinking", thinking: "Considering the wiring." }, { type: "text", text: "The answer is nine." }] }] }, ctx);
+      break;
+    case "narration":
+      await say.handler("on", ctx);
+      await agentEnd?.({ messages: [{ role: "assistant", content: [{ type: "thinking", thinking: "Here is the result.", narration: true }] }] }, ctx);
+      break;
     case "noplayer":
       await say.handler("speak anyway", ctx);
       break;
@@ -207,7 +241,7 @@ for (const call of received) {
   };
   console.log(`CALL ${call.url} model=${field("model")} format=${field("response_format")} voice=${field("voice")} input=${field("input")}`);
 }
-console.log(`CALLS ${received.length}`);
+console.log(`CALLS ${received.filter((call) => call.url?.endsWith("/audio/speech")).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}`);
@@ -275,18 +309,76 @@ say_run() {
 @test "the endpoint is taken from the speech row of the models file, never the chat provider" {
   say_run endpoint
   [[ "$output" == *"http://127.0.0.1:1/v1/audio/speech"* ]]
+  [[ "$output" == *"humanize chatmodel"* ]]
   [[ "$output" != *"10.0.0.1"* ]]
 }
 
 @test "markdown never reaches the speech engine" {
   say_run markdown
-  [[ "$output" == *"input=Title Use pw-play here. see docs and bold a b"* ]]
+  [[ "$output" == *"input=Title"* ]]
+  [[ "$output" == *"input=Use pw-play here."* ]]
+  [[ "$output" == *"input=see docs and bold"* ]]
+  [[ "$output" != *"npm i x"* ]]
+  [[ "$output" != *"example.test"* ]]
 }
 
-@test "an over-long utterance is bounded and cut at a sentence boundary" {
+@test "the spoken budget keeps only the leading whole segments" {
   DANKVOICE_MAX=60 say_run truncate
-  [[ "$output" == *"here. …"* ]]
-  [ "$(grep -o 'Sentence one is here\.' <<<"$output" | wc -l)" -le 4 ]
+  [[ "$output" == *"CALLS 1"* ]]
+  [[ "$output" == *"PLAYS 1"* ]]
+  [[ "$output" == *"input=Sentence one is here."* ]]
+}
+
+@test "a long answer is spoken as sequential sentence-sized requests" {
+  say_run sentences
+  [[ "$output" == *"CALLS 3"* ]]
+  [[ "$output" == *"PLAYS 3"* ]]
+  [[ "$output" == *"input=First stop here."* ]]
+  [[ "$output" == *"input=Second one goes!!! Really?"* ]]
+  [[ "$output" == *"input=Third ... done"* ]]
+}
+
+@test "decimals and comma-decimals never split a sentence" {
+  say_run decimals
+  [[ "$output" == *"CALLS 2"* ]]
+  [[ "$output" == *"input=Model 3.5 ships today."* ]]
+  [[ "$output" == *"input=Version 1,5 too."* ]]
+}
+
+@test "an answer is rewritten into spoken prose before synthesis" {
+  DV_REWRITE=prose say_run rewrite
+  [[ "$output" == *"CALL /v1/chat/completions"* ]]
+  [[ "$output" == *"input=Spoken, humanized words."* ]]
+  [[ "$output" == *"CALLS 1"* ]]
+}
+
+@test "a failed rewrite speaks the mechanical text unchanged" {
+  say_run speak
+  [[ "$output" == *"input=hello world"* ]]
+}
+
+@test "thinking is narrated before the answer as its own segment" {
+  DV_REWRITE=echo say_run thinking
+  [[ "$output" == *"input=Considering the wiring."* ]]
+  [[ "$output" == *"input=The answer is nine."* ]]
+  [[ "$output" == *"CALLS 2"* ]]
+  local first second
+  first=$(grep -n "input=Considering the wiring\." <<<"$output" | head -1 | cut -d: -f1)
+  second=$(grep -n "input=The answer is nine\." <<<"$output" | head -1 | cut -d: -f1)
+  [ -n "$first" ] && [ -n "$second" ] && [ "$first" -lt "$second" ]
+}
+
+@test "thinking narration can be switched off" {
+  DANKVOICE_THINKING=0 DV_REWRITE=echo say_run thinking
+  [[ "$output" == *"input=The answer is nine."* ]]
+  [[ "$output" != *"input=Considering the wiring."* ]]
+  [[ "$output" == *"CALLS 1"* ]]
+}
+
+@test "narration-flagged thinking is spoken once as the answer" {
+  DV_REWRITE=echo say_run narration
+  [[ "$output" == *"input=Here is the result."* ]]
+  [[ "$output" == *"CALLS 1"* ]]
 }
 
 @test "a missing player is reported, not swallowed" {
@@ -304,7 +396,7 @@ say_run() {
 
 @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" == *"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)|Thinking narration: on (toggle)|Humanize answers: on (tiny) (toggle)|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"* ]]