@markusylisiurunen/tau 0.3.75 → 0.3.77

package/dist/core/static/tau_docs/prompts-and-project-context.md

@@ -64,16 +64,6 @@ After recording succeeds, the picker becomes non-actionable and shows the prompt
 
 Only the newest picker in a chat is active. Pickers are bound to the session that opened them and expire after selection, session replacement, or runner restart. Duplicate taps do not record the same picker twice. Prompt selection does not consume pending attachments or group context.
 
-### Install starter prompts
-
-Use `tau install` to copy Tau's starter content:
-
-```bash
-tau install --prompt commit-staged
-```
-
-The default target is `.tau/prompts/` under the current directory. Add `--global` for `~/.config/tau/prompts/`. Existing prompt files are skipped unless `--force` is supplied. Running `tau install` without `--prompt` or `--skill` installs all starter prompts and skills.
-
 ## `AGENTS.md` provides standing context
 
 `AGENTS.md` is project context injected into the effective system prompt. It is suitable for repository conventions, architectural boundaries, verification commands, and instructions that should apply to every relevant request.

package/dist/core/static/tau_docs/remote-sessions.md

@@ -91,7 +91,7 @@ Remote `--new` supplies the conventional creation attribute `source: "tui"`. It
 
 ## Select an execution environment
 
-A session can use a local host directory, an already-provisioned Cloudflare Sandbox, or an already-provisioned Fly Sprite. In all cases, the execution cwd is an absolute path inside that environment.
+A session can use a local host directory or an already-provisioned Fly Sprite. In all cases, the execution cwd is an absolute path inside that environment.
 
 ### Host-local directory
 
@@ -103,22 +103,6 @@ tau attach --new --cwd /srv/workspaces/tau ws://host.example:8787
 
 The host process executes agent-visible filesystem and command operations on its own machine. Tau does not clone, pull, or provision a repository.
 
-### Cloudflare Sandbox
-
-The host must already have a named bridge in `cloudflareSandbox.bridges`, and the sandbox must already exist:
-
-```sh
-tau attach \
-  --new \
-  --execution-kind cloudflare-sandbox \
-  --cloudflare-bridge production \
-  --cloudflare-sandbox sandbox-42 \
-  --cwd /workspace/tau \
-  wss://tau.example.com
-```
-
-`--cloudflare-bridge` identifies host configuration. `--cloudflare-sandbox` identifies an existing sandbox reachable through that bridge. Tau does not create the sandbox or copy a repository into it.
-
 ### Fly Sprite
 
 The host must already have a named API target in `flySprites.apis`, and the Sprite must already exist:
@@ -166,7 +150,7 @@ An attached session spans three logical machines even when two happen to share o
 - command execution, platform, PATH, and runtime dependencies
 - automatic-compaction archives and other target-side temporary files
 
-This is why changing a host theme does not affect a remote TUI, why `!git status` runs against the execution environment, and why a custom diff application opens on the attaching machine. [Ownership and scope](ownership-and-scope.md) applies the same model across Tau.
+This is why changing a host’s theme selection does not affect a remote TUI, why `!git status` runs against the execution environment, and why a custom diff application opens on the attaching machine. [Ownership and scope](ownership-and-scope.md) applies the same model across Tau.
 
 ## Reload or restart the correct process
 
@@ -178,7 +162,7 @@ Different changes have different owners:
 | Effective model `apiKeys` in execution-environment or session configuration | Wait for idle, then run `/reload`; new sessions also resolve the current values. |
 | Managed Codex auth changed with `tau auth` | No host restart; auth storage is read again on later credential resolutions. |
 | Attaching themes, diff launcher, speech config, or configured client tools | Restart `tau attach`. |
-| Host process environment variables, history target, WebSocket listener, Cloudflare bridge, Fly API target, or host startup flags | Restart `tau serve`. |
+| Host process environment variables, history target, WebSocket listener, Fly API target, or host startup flags | Restart `tau serve`. |
 | Host Tau package, built-in tools, protocol, session recovery code, or built-in documentation | Upgrade and restart the host. |
 | TUI package, keybindings, rendering, local speech, or client-tool implementation | Upgrade and restart the attaching client. |
 
@@ -215,9 +199,9 @@ Avoid downgrading a host that has already written sessions with a newer storage
 The host lists only stored sessions whose execution-environment kind it can currently restore. Confirm that:
 
 - the connection uses the same host user and home directory as the original process
-- the Cloudflare bridge id or Fly API id still exists in host configuration
+- the Fly API id still exists in host configuration
 - host credentials are available to the restarted process
-- the target sandbox, Sprite, or local directory still exists
+- the target Sprite or local directory still exists
 - the session was created on this host rather than another machine with a different store
 
 Do not edit the session JSON to change environment identity. Restore the owning configuration or target instead.

package/dist/core/static/tau_docs/session-protocol-methods.md

@@ -63,12 +63,6 @@ Creates a session in one explicitly selected execution environment.
 params: {
   executionEnvironment:
     | { kind: "local"; cwd: string; env?: Record<string, string> }
-    | {
-        kind: "cloudflare-sandbox";
-        bridgeId: string;
-        sandboxId: string;
-        cwd: string;
-      }
     | {
         kind: "fly-sprite";
         apiId: string;
@@ -83,7 +77,7 @@ params: {
 result: { sessionId: string }
 ```
 
-`cwd` must be absolute inside the selected execution environment. Cloudflare sandboxes and Fly Sprites must already exist and be reachable through a host-configured resolver. Tau does not provision a target or repository.
+`cwd` must be absolute inside the selected execution environment. Fly Sprites must already exist and be reachable through a host-configured resolver. Tau does not provision a target or repository.
 
 `attributes` is required, including when empty. It accepts at most 32 immutable pairs; keys are 1 to 64 characters and values at most 1,024 characters. Tau stores the supplied strings without inferring missing provenance. Conventional attributes and their use are covered in [sessions](sessions.md) and [history](history.md).
 

package/dist/core/static/tau_docs/skills.md

@@ -133,28 +133,6 @@ Skill references compose. If `release-check` instructs the agent to use `@@skill
 
 After activation, the agent reads `SKILL.md` from the path in the discovered index. It should load only relevant files from `references/` or `assets/`, and prefer provided scripts when they implement the required workflow. Skills are treated as read-only unless the user explicitly asks to edit them.
 
-## Installing starter skills
-
-Tau ships starter prompts and skills that can be copied into a project:
-
-```bash
-tau install
-```
-
-By default this installs all starter prompts and skills under the current directory's `.tau/`. To install one skill:
-
-```bash
-tau install --skill code-review
-```
-
-To install under `~/.config/tau/` instead:
-
-```bash
-tau install --global --skill commit
-```
-
-Existing skill directories are skipped. `--force` replaces the entire same-named target directory, including files that are not present in the starter copy, so use it only when replacement is intended. `--prompt` and `--skill` are mutually exclusive. See [prompts and project context](prompts-and-project-context.md) for the prompt side of `tau install`.
-
 ## Applying changes and checking discovery
 
 A running TUI session keeps its current content catalog and prompt context until it reloads. Run:

package/dist/core/static/tau_docs/speech-generation.md

@@ -152,7 +152,7 @@ The output parent directory must exist. Neither the requested WAV nor `<output>.
 
 Stdout on success is one JSON object with absolute `output`, `artifacts`, and the number of `batches`. The manifest contains the script text; keep artifacts private for sensitive scripts.
 
-Failures exit nonzero and report the retained directory. Requests are not automatically retried because a failed request may already have incurred a charge.
+Failures exit nonzero and identify invalid script fields, chunks, or turns before generation, or the failed batch and processing stage afterward. Existing output or artifact paths require a fresh `--output` path; preserve recovery artifacts. Errors after output preparation report the retained directory, which may be incomplete. If final publication fails, copy the completed `assembled.wav` to a fresh path instead of generating again. Requests are not automatically retried because a failed request may already have incurred a charge; another generation request may incur another charge.
 
 To recover after a later batch fails, inspect the manifest's `completed` flags and chunk mapping. Generate only the unfinished chunks to a fresh output path, then assemble the completed PCM files from both runs in script order. Request stitching does not carry over between invocations.
 

package/dist/core/static/tau_docs/telegram.md

@@ -224,25 +224,28 @@ Every Telegram turn starts with hidden `<system>` guidance identifying Telegram
 
 Top-level and per-bot `systemMessage` values share a second hidden block after the default, in that order. Audio transcripts receive another warning that they may contain noise or errors. Unlike project context, hidden guidance is persisted with user turns and can appear in history, so never put credentials in configured messages.
 
-The runner's speech-to-text provider is loaded from normal Tau config at runner startup, based on the runner process's startup `cwd`. Restart the runner after changing that provider or its environment.
+The runner's speech credentials and `speech.voiceId` are loaded at startup from its environment and normal Tau config, based on the runner process's startup `cwd`. Restart the runner after changing those settings.
 
 ## Chat commands
 
 | Command | Behavior |
 | --- | --- |
-| `/use_<projectId>` | Saves the project preference for future `/new` sessions; does not change the active session. |
-| `/new` | Closes the current active session, then creates one from the current project preference. |
-| `/status` | Reports session state, project, model, reasoning, context usage, cost, and goal state when available. |
-| `/effort_low` | Selects low reasoning for later independent turns. |
-| `/effort_medium` | Selects medium reasoning for later independent turns. |
-| `/effort_high` | Selects high reasoning for later independent turns. |
-| `/effort_xhigh` | Selects xhigh reasoning for later independent turns. |
+| `/use_<projectId>` | Selects the project for future `/new` sessions. |
+| `/new` | Replaces the active session using the preferred project. |
+| `/status` | Reports session state, project, model, reasoning, context usage, cost, and goal. |
+| `/persona` | Switches persona while idle without losing history or starting a turn. |
+| `/effort_low` | Selects low reasoning for future turns. |
+| `/effort_medium` | Selects medium reasoning for future turns. |
+| `/effort_high` | Selects high reasoning for future turns. |
+| `/effort_xhigh` | Selects xhigh reasoning for future turns. |
 | `/prompt` | [Records a saved prompt](prompts-and-project-context.md#telegram-prompt-picker) while idle, without starting a turn. |
-| `/compact` | Runs summary-only manual compaction while the session is idle. |
+| `/compact` | Runs summary-only compaction while idle. |
 | `/interrupt` | Interrupts the active Tau turn. |
 | `/tts_on` | Enables a Gemini-generated voice note after each final assistant response. |
 | `/tts_off` | Disables voice responses. |
 
+[Persona](personas.md) selection is session-local; `/new` uses the project default.
+
 Preferences persist per bot and chat across restarts, projects, and sessions. Project changes apply to `/new`, not the active session.
 
 In groups, commands must explicitly mention the bot. Accepted forms include:
@@ -277,14 +280,9 @@ Uploads only queue files; captions are metadata. The next text or voice transcri
 
 Files use native temporary directories in the execution environment; OS cleanup can invalidate their paths. Pending queues and group context clear on shutdown. File contents and metadata are untrusted.
 
-OpenAI is the default. Select Gemini with `speechToText.provider`. Runner credentials are:
-
-- Gemini: `GEMINI_API_KEY`, then `apiKeys.google`
-- OpenAI: `OPENAI_API_KEY`, then `apiKeys.openai`
-
-Gemini extracts spelling hints with Gemini 3.8 Flash and transcribes uploaded audio verbatim with `gemini-3.5-transcribe`, using English (`en-US`) and Finnish (`fi-FI`) hints. It attempts remote file deletion afterward. OpenAI normalizes downloaded audio with runner-side `ffmpeg` and uploads it to `gpt-transcribe`. Missing keys prevent transcription, not file delivery. See [credentials](credentials.md).
+Voice transcription uses Gemini with `GEMINI_API_KEY`, then `apiKeys.google`. Optional hints use GPT-6 Luna (reasoning disabled) and OpenAI credentials. Gemini transcribes audio verbatim with `gemini-3.5-transcribe`, using English (`en-US`) and Finnish (`fi-FI`) hints. It attempts remote file deletion. File delivery needs no Google key. See [credentials](credentials.md).
 
-`/tts_on` uses `gemini-3.8-flash`, `gemini-3.1-flash-tts-preview`, Despina, the Google key, and runner `ffmpeg` with Opus. Source and rewritten text each allow 10,000 Unicode characters; audio allows 32 MiB. Rewrite and job timeouts are one and five minutes. Jobs are ephemeral. Failure sends `voice response failed. please try again.` without affecting text; details stay in logs.
+`/tts_on` rewrites text with `gpt-6-luna` (reasoning disabled) and generates speech with Eleven v4 Turbo. It requires both OpenAI and ElevenLabs credentials and runner `ffmpeg` with Opus. Voice notes use brisk delivery and 1.15× speed. See [`speech` configuration](config-reference.md#speech) for default and custom voice selection. Source and rewritten text each allow 10,000 Unicode characters; audio allows 32 MiB. Rewrite and job timeouts are one and five minutes. Jobs are ephemeral. Failure sends `voice response failed. please try again.` without affecting text; details stay in logs.
 
 ## Command client tools
 
@@ -335,7 +333,7 @@ Do not verify bot tokens, provider keys, Access secrets, transcript contents, or
 
 **A persistent-directory session fails recovery.** Restore the configured directory and its original path, or return the project config to the snapshot's durable `cwd`. Tau does not migrate an existing session to a new persistent directory.
 
-**Audio reports a missing key.** Set the credential for the configured speech provider in the runner process and restart it. A workspace-only environment change does not update the runner's startup speech configuration.
+**Audio reports a missing key.** Set the credential for the Gemini in the runner process and restart it. A workspace-only environment change does not update the runner's startup speech configuration.
 
 **A message sent during active work changes direction.** Telegram uses steering, not ordinary queueing, while a turn is running. Wait for completion before sending an independent next task, or use `/interrupt` to stop the current run first.
 

package/dist/core/static/tau_docs/troubleshooting.md

@@ -108,7 +108,7 @@ Providers must be known and model IDs are exact and case-sensitive. Check warnin
 
 ### Theme
 
-Check the client `cwd` and home, exact filename ID, colors, `disableBuiltinThemes`, and `defaultTheme`. `/reload` does not reload themes. Restart the TUI, then select `/theme:<id>`. A remote host's themes do not supply an attached client's theme.
+Check the exact built-in theme ID and the client’s `defaultTheme`. Select `/theme:<id>` for the current run, or restart the TUI to apply a new startup default. A remote host’s theme selection does not affect an attached client.
 
 ## A tool or subagent is unavailable
 
@@ -148,13 +148,13 @@ A detached owning client makes its tools unavailable and cancels active calls. R
 
 Find the process making the request:
 
-| Operation                                   | Owner        |
-| ------------------------------------------- | ------------ |
-| Model, host `web`, `history`, or `nook`     | Host         |
-| `/listen`, `/speak`, or TUI client tool     | Client       |
-| Telegram bot or transcription               | Runner       |
-| `tau nook`, `tau history`, or PDF unpack    | Invoking CLI |
-| Cloudflare Sandbox or Fly Sprite resolution | Host startup |
+| Operation                                | Owner        |
+| ---------------------------------------- | ------------ |
+| Model, host `web`, `history`, or `nook`  | Host         |
+| `/listen`, `/speak`, or TUI client tool  | Client       |
+| Telegram bot or transcription            | Runner       |
+| `tau nook`, `tau history`, or PDF unpack | Invoking CLI |
+| Fly Sprite resolution                    | Host startup |
 
 A laptop variable does not update a remote host. Environment changes require an owner restart. Runtime `apiKeys` can reload, but only from an eligible execution-environment level and subject to feature precedence.
 
@@ -205,11 +205,11 @@ If attachment reports an unsupported protocol version or invalid peer message, u
 
 For `tau attach --new`, `--cwd` must be an absolute path inside the selected execution environment. With the default local execution kind it is a host path, not a path on the attaching machine. Tau does not create the directory, clone a repository, or infer remote repository attributes.
 
-For Cloudflare Sandbox or Fly Sprite creation, verify on the host that:
+For Fly Sprite creation, verify on the host that:
 
-- the named bridge or API id exists in startup configuration;
+- the named API id exists in startup configuration;
 - its credential is available to the host process;
-- the named sandbox or Sprite already exists;
+- the named Sprite already exists;
 - the absolute target `cwd` exists there; and
 - the configured execution home matches the intended target account.
 
@@ -219,7 +219,7 @@ Without `--session` or `--new`, attach needs a TTY for its selector. In automati
 
 ## A session is missing, interrupted, or will not recover
 
-A selector shows only sessions this host can load and restore. Confirm its machine, OS user, home, Tau version, resolver configuration, and target still match the creator. Another user's `~/.config/tau/sessions` is a different store. Restore missing bridge/API definitions, credentials, local directory, sandbox, or Sprite. Never edit session JSON to substitute a target or `cwd`.
+A selector shows only sessions this host can load and restore. Confirm its machine, OS user, home, Tau version, resolver configuration, and target still match the creator. Another user's `~/.config/tau/sessions` is a different store. Restore missing API definitions, credentials, local directory, or Sprite. Never edit session JSON to substitute a target or `cwd`.
 
 Recovery returns idle, aborts unfinished turns, cancels running maintenance, removes live subagents, and blocks an active goal. Review the last assistant and tools, then safely check `!!pwd` and `!!git status --short`. Resume a goal only after understanding the stop. Retry continues current history without rerunning completed tools automatically.
 
@@ -273,13 +273,13 @@ Recovery needs the same `workspaceRoot`, project definitions, host home, and Tau
 
 ## Telegram audio or attachment processing fails
 
-Telegram audio transcription uses the runner's `speechToText.provider`, which defaults to OpenAI. OpenAI needs `OPENAI_API_KEY` or `apiKeys.openai` and runner-side `ffmpeg`; Gemini needs `GEMINI_API_KEY` or `apiKeys.google`. Set the credential for the runner process and restart it after changing the environment or provider.
+Telegram audio transcription uses Gemini and needs `GEMINI_API_KEY` or `apiKeys.google`. Set the credential for the runner process and restart it after changing the environment or configured key.
 
-Distinguish download, materialization, format, and transcription errors. The reply or runner log states which stage failed. Confirm Telegram can deliver the file to the bot, the attachment type is supported, the runner can write its temporary directory, and the selected provider accepts the media type. Do not log media bytes or transcripts merely to prove they exist.
+Distinguish download, materialization, format, and transcription errors. The reply or runner log states which stage failed. Confirm Telegram can deliver the file to the bot, the attachment type is supported, the runner can write its temporary directory, and Gemini accepts the media type. Do not log media bytes or transcripts merely to prove they exist.
 
 Successful audio turns echo `transcribed: …` before submission. In groups, non-triggering audio can be buffered for later mentioned context. If that is inappropriate for the chat, narrow `allowedChatIds` or avoid enabling the group.
 
-Outgoing `/tts_on` voice responses always need `GEMINI_API_KEY` or `apiKeys.google`, even when incoming audio uses OpenAI. They also require runner-side `ffmpeg` with Opus support. A generation or delivery failure sends `voice response failed. please try again.` while detailed diagnostics remain in runner logs. The original text response remains delivered.
+Outgoing `/tts_on` voice responses need both `OPENAI_API_KEY` or `apiKeys.openai` for rewriting and `ELEVENLABS_API_KEY` or `apiKeys.elevenlabs` for synthesis. Check [`speech.voiceId`](config-reference.md#speech) if a configured voice is unavailable. They also require runner-side `ffmpeg` with Opus support. A generation or delivery failure sends `voice response failed. please try again.` while detailed diagnostics remain in runner logs. The original text response remains delivered.
 
 ## Telegram replies or notifications are delayed or missing
 

package/dist/core/static/tau_docs/tui.md

@@ -47,7 +47,7 @@ When Tau is idle, Enter and Ctrl+Enter both start a normal turn. While a turn is
 
 - Enter queues the text as a new turn to run when the session becomes idle.
 - Ctrl+Enter steers the active turn. Tau applies steering at a safe continuation boundary rather than injecting it into a model response or tool execution in progress.
-- Alt+Up cancels all pending queued messages and steering that has not yet been applied, then restores their text to the editor. Multiple messages are separated with `---`.
+- Alt+Up cancels all pending queued messages and steering that has not yet been applied, then restores their text to the editor. Multiple messages are separated with `---`. Hidden guidance, such as transcription warnings, stays hidden in the pending list and editor. Restoring messages preserves their guidance in order after any guidance already attached to the draft. Submission places all guidance at the beginning of the combined message. Editing a non-empty draft preserves it; clearing the draft clears it.
 
 Pending input is session state shared by attached clients while the host remains alive. It is not durable across host restart or session recovery. A queued turn captures the persona, reasoning, tools, and model settings when that turn actually starts. Steering remains part of the active logical turn and keeps the settings captured when that turn began.
 
@@ -143,22 +143,7 @@ Direct commands require the session to be idle. In an attached TUI, `!pwd` repor
 
 ## Use themes
 
-Themes belong to the TUI process and never become session state. Tau loads built-in themes plus JSON files from these locations:
-
-- `~/.config/tau/themes/<id>.json` for user themes, when the TUI cwd is under the user’s home.
-- `.tau/themes/<id>.json` at discovered project configuration levels, with the nearest project definition winning by id.
-
-The filename is the theme id. A custom theme is a flat JSON object from semantic palette token names to colors:
-
-```json
-{
-  "brandAccent": "#8fb3ff",
-  "textMuted": "rgb(145, 151, 166)",
-  "feedbackError": "hsl(354, 70%, 72%)"
-}
-```
-
-Colors accept `#rgb`, `#rrggbb`, `rgb(r, g, b)`, and `hsl(h, s%, l%)`. Unknown tokens, non-string values, and invalid colors are ignored. Missing tokens render without a custom color. Custom themes are single-variant; built-in themes adapt to detected terminal appearance.
+Themes belong to the TUI process and never become session state. Tau’s built-in themes adapt to detected terminal appearance.
 
 Set the startup theme with `defaultTheme` in the attaching client’s [configuration](configuration.md), or switch for the current run:
 
@@ -166,7 +151,7 @@ Set the startup theme with `defaultTheme` in the attaching client’s [configura
 /theme:gold
 ```
 
-Theme ids are exact and case-sensitive. `/theme` does not persist the selection. `/reload` refreshes the hosted session, not the attaching client’s loaded theme files, so restart the TUI after adding or changing a theme. In remote use, changing theme files on the host has no effect unless the host and TUI are the same physical machine and the TUI loaded those files itself.
+Theme ids are exact and case-sensitive. `/theme` does not persist the selection. Restart the TUI to apply a new `defaultTheme`. A remote host’s theme selection does not affect an attached client.
 
 ## Review a diff
 
@@ -197,21 +182,21 @@ The TUI also advertises diff review as a client tool unless `--no-client-tools`
 
 ## Use speech
 
-`/listen` and Ctrl+Y are currently macOS-only. Recording uses local `ffmpeg` with the AVFoundation audio input and stops when Ctrl+Y is pressed again, when Escape is pressed, or at the provider recording limit: 9 minutes for Gemini and 20 minutes for OpenAI. The Gemini limit leaves time for setup and finalization within its 10-minute live session. Startup fails if the microphone produces no audio within 15 seconds. Stopping manually or reaching the recording limit finishes transcription and inserts the transcript at the cursor for review without submitting it.
+`/listen` and Ctrl+Y are currently macOS-only. Recording uses local `ffmpeg` with the AVFoundation audio input and stops when Ctrl+Y is pressed again, when Escape is pressed, or at the 9-minute recording limit. The Gemini limit leaves time for setup and finalization within its 10-minute live session. Startup fails if the microphone produces no audio within 15 seconds. Stopping manually or reaching the recording limit finishes transcription and inserts the transcript at the cursor for review without submitting it.
 
-Gemini displays a replaceable live preview in muted italic text at the original cursor position. Finalized dictation uses normal text once transcription settles. Its final transcript replaces the preview without duplication. Editing stays disabled from recording startup through finalization, and failure restores the original draft. OpenAI inserts its transcript after finalization. Recording and retries cannot start while another editor update is pending.
+Gemini displays a replaceable live preview in muted italic text at the original cursor position. Finalized dictation uses normal text once transcription settles. Its final transcript replaces the preview without duplication. Submitting a draft containing finalized dictation includes hidden guidance that some or all of the message may have been transcribed from speech and may contain transcription errors. The guidance remains after edits and clears when the draft is emptied. Editing stays disabled from recording startup through finalization, and failure restores the original draft. Recording and retries cannot start while another editor update is pending.
 
-If transcription fails, Tau retains the local WAV and reports its path. Run `/listen retry` to transcribe the same audio again with the current provider and conversation context, or `/listen discard` to delete it. Retained recordings longer than 20 minutes are rejected rather than sent to the provider. A replacement recording deletes the retained file only after the new capture starts producing audio. Tau keeps at most one failed recording, and exiting leaves that file at the reported path for manual recovery. For live transcription, both providers extract spelling hints from recent conversation while recording begins, buffer audio until the transcription session is ready, and then stream subsequent audio. Gemini uses Gemini 3.8 Flash for hint extraction and `gemini-3.5-transcribe-live` in verbatim mode with English (`en-US`) and Finnish (`fi-FI`) language hints; OpenAI uses GPT-6 Luna and `gpt-live-transcribe`. Hint extraction failure does not fail transcription. On retry, Gemini uploads the retained recording for `gemini-3.5-transcribe` verbatim transcription with the same language hints and attempts to delete the remote file afterward; OpenAI uploads it to `gpt-transcribe` with recent context.
+If transcription fails, Tau retains the local WAV and reports its path. Run `/listen retry` to transcribe the same audio again with Gemini and the current conversation context, or `/listen discard` to delete it. Retained recordings longer than 20 minutes are rejected rather than sent to the provider. A replacement recording deletes the retained file only after the new capture starts producing audio. Tau keeps at most one failed recording, and exiting leaves that file at the reported path for manual recovery. For live transcription, GPT-6 Luna extracts spelling hints from recent conversation while recording begins, with reasoning disabled. Tau buffers audio until the transcription session is ready and then streams subsequent audio. Gemini uses `gemini-3.5-transcribe-live` in verbatim mode with English (`en-US`) and Finnish (`fi-FI`) language hints. Missing OpenAI credentials or hint extraction failure does not fail transcription. On retry, Gemini uploads the retained recording for `gemini-3.5-transcribe` verbatim transcription with the same language hints and attempts to delete the remote file afterward.
 
-Install `ffmpeg` and configure a speech-to-text provider:
+Install `ffmpeg`:
 
 ```sh
 brew install ffmpeg
 ```
 
-OpenAI is the default and needs `OPENAI_API_KEY` or `apiKeys.openai`. Set `speechToText.provider` to `gemini` to use `GEMINI_API_KEY` or `apiKeys.google`. These settings and credentials are read by the TUI process, including during remote attachment.
+Speech transcription uses Gemini and requires `GEMINI_API_KEY` or `apiKeys.google`. Credentials are read by the TUI process, including during remote attachment.
 
-`/speak` is also macOS-only. It rewrites the last assistant response for speech, streams audio from Gemini, and plays it through the local `ffplay` command included with `ffmpeg`. It requires `GEMINI_API_KEY` or `apiKeys.google`, runs only while the session is idle, and can be stopped with Escape. Longer responses are divided into balanced segments targeting at most two minutes of generated speech each. Speech source and rewritten text are limited to 10,000 Unicode characters, and generation stops after 32 MiB of raw audio.
+`/speak` is also macOS-only. It rewrites the last assistant response with GPT-6 Luna (reasoning disabled), streams Eleven v4 Turbo audio, and plays it at 1.15× speed through the local `ffplay` command included with `ffmpeg`. It requires both `OPENAI_API_KEY` or `apiKeys.openai` for rewriting and `ELEVENLABS_API_KEY` or `apiKeys.elevenlabs` for synthesis, runs only while the session is idle, and can be stopped with Escape. Longer responses are divided into balanced segments targeting at most two minutes of generated speech each. Speech source and rewritten text are limited to 10,000 Unicode characters, and generation stops after 32 MiB of raw audio. Voice lookups and synthesis requests have a two-minute deadline. See [`speech` configuration](config-reference.md#speech) for the default Maisie/Caleb lookup and custom voice selection.
 
 ## Reload the right component
 

package/dist/core/telegram/adapter.js

@@ -777,9 +777,10 @@ class TelegramAdapterImpl {
     botUsername;
     pollIntervalMs;
     requestTimeoutSeconds;
-    speechToTextProvider;
     geminiApiKey;
-    openaiApiKey;
+    openAIApiKey;
+    elevenLabsApiKey;
+    speechVoiceId;
     speechToTextDeps;
     sessionManager;
     projectPreferences;
@@ -794,6 +795,7 @@ class TelegramAdapterImpl {
     commandHandlers;
     callbackActionHandlers;
     abortController = new AbortController();
+    personaPickers = new Map();
     promptPickers = new Map();
     activeSessionsByChat = new Map();
     sessionsByChat = new Map();
@@ -832,9 +834,10 @@ class TelegramAdapterImpl {
         this.botUsername = options.botUsername;
         this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
         this.requestTimeoutSeconds = options.requestTimeoutSeconds ?? DEFAULT_REQUEST_TIMEOUT_SECONDS;
-        this.speechToTextProvider = options.speechToTextProvider ?? "openai";
         this.geminiApiKey = options.geminiApiKey?.trim() || undefined;
-        this.openaiApiKey = options.openaiApiKey?.trim() || undefined;
+        this.openAIApiKey = options.openAIApiKey?.trim() || undefined;
+        this.elevenLabsApiKey = options.elevenLabsApiKey?.trim() || undefined;
+        this.speechVoiceId = options.speechVoiceId;
         this.speechToTextDeps = options.speechToTextDeps;
         this.sessionManager = options.sessionManager;
         this.projectPreferences = options.projectPreferences;
@@ -912,6 +915,11 @@ class TelegramAdapterImpl {
                 callbackAction: "status",
                 handler: async (chatId) => this.handleStatus(chatId),
             },
+            {
+                command: "/persona",
+                description: "switch the active session persona",
+                handler: async (chatId, args) => this.handlePersona(chatId, args),
+            },
             {
                 command: "/prompt",
                 description: "add a saved prompt without starting a turn",
@@ -1458,6 +1466,10 @@ class TelegramAdapterImpl {
         await handler(chatId, args, sourceMessageId);
     }
     async handleCallback(chatId, callbackData, messageId) {
+        if (callbackData.startsWith("persona:")) {
+            await this.handlePersonaCallback(chatId, callbackData, messageId);
+            return true;
+        }
         if (callbackData.startsWith("prompt:")) {
             await this.handlePromptCallback(chatId, callbackData, messageId);
             return true;
@@ -1528,6 +1540,99 @@ class TelegramAdapterImpl {
             await this.reply(chatId, `failed to save voice response preference: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    async handlePersona(chatId, args) {
+        if (args.length > 0) {
+            await this.reply(chatId, "use /persona to choose a persona.");
+            return;
+        }
+        const session = await this.requireActiveSession(chatId);
+        if (!session)
+            return;
+        try {
+            const snapshot = await this.getSessionManagerForChat(chatId).getSessionSnapshot(session.id);
+            if (!snapshot) {
+                await this.reply(chatId, "the session is still preparing.");
+                return;
+            }
+            const personas = snapshot.catalog.personas;
+            if (personas.length === 0) {
+                await this.reply(chatId, "this session has no personas.");
+                return;
+            }
+            this.personaPickers.set(chatId, {
+                token: randomUUID(),
+                sessionId: session.id,
+                personas,
+                currentPersonaId: snapshot.settings.personaId,
+            });
+            await this.showPersonaPage(chatId, 0);
+        }
+        catch (error) {
+            await this.reply(chatId, this.formatManagerError(error));
+        }
+    }
+    async showPersonaPage(chatId, page, messageId) {
+        const picker = this.personaPickers.get(chatId);
+        if (!picker)
+            return;
+        const start = page * 20;
+        const keyboard = picker.personas.slice(start, start + 20).map((persona, index) => [
+            {
+                text: `${persona.label ?? persona.id}${persona.id === picker.currentPersonaId ? " (current)" : ""}`,
+                callback_data: `persona:${picker.token}:select:${start + index}`,
+            },
+        ]);
+        const navigation = [];
+        if (page > 0)
+            navigation.push({
+                text: "previous",
+                callback_data: `persona:${picker.token}:page:${page - 1}`,
+            });
+        if (start + 20 < picker.personas.length)
+            navigation.push({ text: "next", callback_data: `persona:${picker.token}:page:${page + 1}` });
+        if (navigation.length > 0)
+            keyboard.push(navigation);
+        const text = "choose a persona for this session. switching is available only while Tau is idle.";
+        const replyMarkup = { inline_keyboard: keyboard };
+        if (messageId !== undefined) {
+            await this.sendWithRetry((signal) => this.api.editMessage(chatId, messageId, text, { replyMarkup, signal }));
+        }
+        else {
+            await this.reply(chatId, text, { replyMarkup });
+        }
+    }
+    async handlePersonaCallback(chatId, data, messageId) {
+        const match = /^persona:([^:]+):(select|page):(0|[1-9][0-9]*)$/.exec(data);
+        const picker = this.personaPickers.get(chatId);
+        if (!match ||
+            !picker ||
+            picker.token !== match[1] ||
+            this.getActiveSession(chatId)?.id !== picker.sessionId ||
+            messageId === undefined) {
+            await this.reply(chatId, "this persona picker has expired. use /persona to open a new one.");
+            return;
+        }
+        const index = Number(match[3]);
+        if (match[2] === "page") {
+            if (index * 20 < picker.personas.length)
+                await this.showPersonaPage(chatId, index, messageId);
+            return;
+        }
+        const persona = picker.personas[index];
+        if (!persona)
+            return;
+        let snapshot;
+        try {
+            snapshot = await this.getSessionManagerForChat(chatId).setPersona(picker.sessionId, persona.id);
+        }
+        catch (error) {
+            await this.reply(chatId, this.formatManagerError(error));
+            return;
+        }
+        this.personaPickers.delete(chatId);
+        const text = `switched to ${persona.label ?? persona.id}. this session is using ${snapshot.bootstrap.model.name || snapshot.bootstrap.model.id} with ${snapshot.settings.reasoning ?? "none"} reasoning.`;
+        await this.sendWithRetry((signal) => this.api.editMessage(chatId, messageId, text, { signal }));
+    }
     async handlePrompt(chatId, args) {
         if (args.length > 0) {
             await this.reply(chatId, "use /prompt to choose a saved prompt.");
@@ -1867,20 +1972,10 @@ class TelegramAdapterImpl {
         }
     }
     getSpeechToTextApiKey() {
-        switch (this.speechToTextProvider) {
-            case "gemini":
-                return this.geminiApiKey;
-            case "openai":
-                return this.openaiApiKey;
-        }
+        return this.geminiApiKey;
     }
     getSpeechToTextApiKeyErrorMessage(action) {
-        switch (this.speechToTextProvider) {
-            case "gemini":
-                return `set GEMINI_API_KEY or apiKeys.google to ${action}`;
-            case "openai":
-                return `set OPENAI_API_KEY or apiKeys.openai to ${action}`;
-        }
+        return `set GEMINI_API_KEY or apiKeys.google to ${action}`;
     }
     async transcribeTelegramVoice(chatId, message, options = {}) {
         if (message.durationMs > SPEECH_TO_TEXT_CLIENT_MAX_DURATION_MS) {
@@ -1901,9 +1996,9 @@ class TelegramAdapterImpl {
         let transcript;
         try {
             const transcription = createSpeechToTextTranscription({
-                provider: this.speechToTextProvider,
                 mode: "file",
                 apiKey,
+                openAIApiKey: this.openAIApiKey,
                 context: await this.resolveSpeechToTextContext(chatId),
                 deps: {
                     ...this.speechToTextDeps,
@@ -2234,11 +2329,16 @@ class TelegramAdapterImpl {
         }, TELEGRAM_TTS_JOB_TIMEOUT_MS);
         timeout.unref?.();
         try {
-            if (!this.geminiApiKey) {
-                throw new Error("missing Google credential for Telegram voice responses");
+            if (!this.openAIApiKey) {
+                throw new Error("missing OpenAI credential for Telegram voice responses");
+            }
+            if (!this.elevenLabsApiKey) {
+                throw new Error("missing ElevenLabs credential for Telegram voice responses");
             }
             const voice = await this.generateVoice({
-                apiKey: this.geminiApiKey,
+                openAIApiKey: this.openAIApiKey,
+                elevenLabsApiKey: this.elevenLabsApiKey,
+                voiceId: this.speechVoiceId,
                 sourceText,
                 fetchImpl: this.fetchImpl,
                 signal: AbortSignal.any([this.abortController.signal, timeoutController.signal]),