diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9e0c1a0c9..4803d7f7e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,23 @@
 # CHANGELOG - Uses semantic versioning (MAJOR.MINOR.PATCH)
 
+## [4.11.5] - 2025-11-02
+### 🔊 Saturn ElevenLabs narration
+**Problem**: Saturn Visual Solver streams rich reasoning text, but users must watch the terminal feed to follow progress. The user asked for a spoken version powered by their ElevenLabs API key so they can listen to the solver thinking in real time.
+
+**Solution**: Added a secure ElevenLabs proxy on the backend and optional narration controls in the Saturn UI. When enabled, reasoning deltas are buffered client-side, sent to the new `/api/audio/narrate` endpoint, and streamed back as audio clips for continuous playback.
+
+**Implementation**:
+- `server/services/audio/elevenLabsService.ts` wraps ElevenLabs streaming with proper logging and env-driven defaults.
+- `server/controllers/audioController.ts` exposes `/api/audio/status` and `/api/audio/narrate` routes, registered in `routes.ts`.
+- `client/src/hooks/useSaturnAudioNarration.ts` manages buffering, queueing, playback, and UI state.
+- `client/src/pages/SaturnVisualSolver.tsx` surfaces narration controls (toggle, volume slider, status) and forwards reasoning deltas.
+- `shared/config/audio.ts` centralises feature-flag resolution so both backend and frontend detect availability.
+
+**Benefits**:
+- No secret leakage: the API key stays on the server while the client receives only audio.
+- Narration is optional and non-blocking—users can toggle it per run without affecting solver logic.
+- Graceful fallbacks when ElevenLabs credentials are absent (controls hidden, helpful error copy rendered).
+
 ## [4.11.4] - 2025-11-01
 ### ✅ Saturn Correctness Display
 **Problem**: Saturn Visual Solver showed completion status ("COMPLETED") but not correctness status (whether predictions were RIGHT or WRONG). Users couldn't tell at a glance if Saturn solved the puzzle correctly.
diff --git a/client/src/hooks/useSaturnAudioNarration.ts b/client/src/hooks/useSaturnAudioNarration.ts
new file mode 100644
index 000000000..2c0e18a39
--- /dev/null
+++ b/client/src/hooks/useSaturnAudioNarration.ts
@@ -0,0 +1,287 @@
+/**
+ * Author: gpt-5-codex
+ * Date: 2025-11-02T00:00:00Z
+ * PURPOSE: React hook that converts Saturn reasoning deltas into ElevenLabs audio narration
+ * by proxying through the backend. Manages buffering, playback queueing, volume control,
+ * and graceful fallbacks when audio is unavailable.
+ * SRP/DRY check: Pass — isolates narration concerns away from SaturnVisualSolver.
+ */
+
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { resolveSaturnAudioConfig } from '@shared/config/audio';
+
+interface NarrationStatus {
+  enabled: boolean;
+  available: boolean;
+  status: 'idle' | 'buffering' | 'playing' | 'error';
+  error?: string | null;
+  volume: number;
+}
+
+const audioConfig = resolveSaturnAudioConfig();
+
+const STATUS_IDLE: NarrationStatus['status'] = 'idle';
+
+export interface UseSaturnAudioNarration {
+  enabled: boolean;
+  available: boolean;
+  status: NarrationStatus['status'];
+  error: string | null;
+  volume: number;
+  toggleEnabled: () => void;
+  setEnabled: (value: boolean) => void;
+  setVolume: (value: number) => void;
+  enqueueReasoning: (delta: string) => void;
+  flush: () => void;
+  reset: () => void;
+}
+
+const AUDIO_ENDPOINT = '/api/audio/narrate';
+const STATUS_ENDPOINT = '/api/audio/status';
+
+export function useSaturnAudioNarration(): UseSaturnAudioNarration {
+  const [enabled, setEnabled] = useState<boolean>(audioConfig.enabled);
+  const [available, setAvailable] = useState<boolean>(audioConfig.enabled);
+  const [status, setStatus] = useState<NarrationStatus['status']>(STATUS_IDLE);
+  const [error, setError] = useState<string | null>(null);
+  const [volume, setVolume] = useState<number>(0.8);
+
+  const volumeRef = useRef(volume);
+  const queueRef = useRef<Promise<void>>(Promise.resolve());
+  const bufferRef = useRef<string>('');
+  const flushTimeoutRef = useRef<number | null>(null);
+  const currentAudioRef = useRef<HTMLAudioElement | null>(null);
+  const destroyedRef = useRef(false);
+
+  const clearFlushTimeout = useCallback(() => {
+    if (flushTimeoutRef.current !== null) {
+      window.clearTimeout(flushTimeoutRef.current);
+      flushTimeoutRef.current = null;
+    }
+  }, []);
+
+  const resetBuffer = useCallback(() => {
+    bufferRef.current = '';
+    clearFlushTimeout();
+  }, [clearFlushTimeout]);
+
+  const stopPlayback = useCallback(() => {
+    const audio = currentAudioRef.current;
+    if (audio) {
+      try {
+        audio.pause();
+        audio.currentTime = 0;
+      } catch {
+        // ignore best-effort cleanup errors
+      }
+      currentAudioRef.current = null;
+    }
+    queueRef.current = Promise.resolve();
+    setStatus(STATUS_IDLE);
+  }, []);
+
+  useEffect(() => {
+    volumeRef.current = volume;
+    if (currentAudioRef.current) {
+      currentAudioRef.current.volume = volume;
+    }
+  }, [volume]);
+
+  useEffect(() => {
+    let cancelled = false;
+    async function fetchStatus() {
+      try {
+        const response = await fetch(STATUS_ENDPOINT, { cache: 'no-store' });
+        if (!response.ok) {
+          throw new Error(`Status request failed (${response.status})`);
+        }
+        const json = await response.json();
+        const isEnabled = Boolean(json?.data?.enabled);
+        if (!cancelled) {
+          setAvailable(isEnabled);
+          if (!isEnabled) {
+            setEnabled(false);
+          }
+        }
+      } catch (err) {
+        if (!cancelled) {
+          setAvailable(false);
+          setEnabled(false);
+          setError(err instanceof Error ? err.message : 'Audio status unavailable');
+        }
+      }
+    }
+    fetchStatus();
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+
+  useEffect(() => () => {
+    destroyedRef.current = true;
+    clearFlushTimeout();
+    stopPlayback();
+  }, [clearFlushTimeout, stopPlayback]);
+
+  const playAudio = useCallback(async (blob: Blob) => {
+    const url = URL.createObjectURL(blob);
+    try {
+      await new Promise<void>((resolve, reject) => {
+        if (destroyedRef.current) {
+          URL.revokeObjectURL(url);
+          return resolve();
+        }
+        const audio = new Audio(url);
+        audio.volume = volumeRef.current;
+        audio.onended = () => {
+          audio.src = '';
+          URL.revokeObjectURL(url);
+          if (currentAudioRef.current === audio) {
+            currentAudioRef.current = null;
+          }
+          resolve();
+        };
+        audio.onerror = () => {
+          audio.src = '';
+          URL.revokeObjectURL(url);
+          if (currentAudioRef.current === audio) {
+            currentAudioRef.current = null;
+          }
+          reject(new Error('Audio playback error'));
+        };
+        const playPromise = audio.play();
+        currentAudioRef.current = audio;
+        if (playPromise) {
+          playPromise.catch((err) => {
+            audio.src = '';
+            URL.revokeObjectURL(url);
+            if (currentAudioRef.current === audio) {
+              currentAudioRef.current = null;
+            }
+            reject(err instanceof Error ? err : new Error('Audio play failed'));
+          });
+        }
+      });
+    } finally {
+      URL.revokeObjectURL(url);
+    }
+  }, []);
+
+  const requestAudio = useCallback(async (text: string) => {
+    setStatus('buffering');
+    setError(null);
+
+    const response = await fetch(AUDIO_ENDPOINT, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ text }),
+    });
+
+    if (!response.ok) {
+      const message = await response.text().catch(() => '') || `Narration failed (${response.status})`;
+      throw new Error(message);
+    }
+
+    const arrayBuffer = await response.arrayBuffer();
+    const blob = new Blob([arrayBuffer], { type: response.headers.get('Content-Type') || 'audio/mpeg' });
+
+    setStatus('playing');
+    await playAudio(blob);
+  }, [playAudio]);
+
+  const enqueuePlayback = useCallback(
+    (text: string) => {
+      if (!text.trim()) {
+        return;
+      }
+      const tail = queueRef.current
+        .catch(() => undefined)
+        .then(() => requestAudio(text))
+        .catch((err) => {
+          setStatus('error');
+          setError(err instanceof Error ? err.message : 'Narration failed');
+        });
+      const finalPromise = tail.finally(() => {
+        if (queueRef.current === finalPromise) {
+          setStatus(STATUS_IDLE);
+        }
+      });
+      queueRef.current = finalPromise;
+    },
+    [requestAudio],
+  );
+
+  const flushBuffer = useCallback(() => {
+    clearFlushTimeout();
+    const payload = bufferRef.current.trim();
+    bufferRef.current = '';
+    if (!payload) {
+      return;
+    }
+    enqueuePlayback(payload);
+  }, [clearFlushTimeout, enqueuePlayback]);
+
+  const enqueueReasoning = useCallback(
+    (delta: string) => {
+      if (!enabled || !available) {
+        return;
+      }
+      bufferRef.current += delta;
+      clearFlushTimeout();
+      flushTimeoutRef.current = window.setTimeout(() => {
+        flushTimeoutRef.current = null;
+        flushBuffer();
+      }, 400);
+    },
+    [available, clearFlushTimeout, enabled, flushBuffer],
+  );
+
+  const reset = useCallback(() => {
+    resetBuffer();
+    stopPlayback();
+    setError(null);
+  }, [resetBuffer, stopPlayback]);
+
+  const setEnabledSafe = useCallback(
+    (value: boolean) => {
+      if (!available) {
+        setEnabled(false);
+        return;
+      }
+      setEnabled(value);
+      if (!value) {
+        reset();
+      }
+    },
+    [available, reset],
+  );
+
+  const toggleEnabled = useCallback(() => {
+    setEnabledSafe(!enabled);
+  }, [enabled, setEnabledSafe]);
+
+  useEffect(() => {
+    if (!enabled) {
+      resetBuffer();
+    }
+  }, [enabled, resetBuffer]);
+
+  return useMemo(
+    () => ({
+      enabled,
+      available,
+      status,
+      error,
+      volume,
+      toggleEnabled,
+      setEnabled: setEnabledSafe,
+      setVolume,
+      enqueueReasoning,
+      flush: flushBuffer,
+      reset,
+    }),
+    [available, enabled, error, flushBuffer, enqueueReasoning, reset, setEnabledSafe, status, toggleEnabled, volume],
+  );
+}
diff --git a/client/src/pages/SaturnVisualSolver.tsx b/client/src/pages/SaturnVisualSolver.tsx
index b7da84393..564ddebe0 100644
--- a/client/src/pages/SaturnVisualSolver.tsx
+++ b/client/src/pages/SaturnVisualSolver.tsx
@@ -25,11 +25,26 @@ import { getDefaultSaturnModel, getModelProvider, modelSupportsTemperature } fro
 import { PuzzleGridDisplay } from '@/components/puzzle/PuzzleGridDisplay';
 import { PuzzleGrid } from '@/components/puzzle/PuzzleGrid';
 import { DEFAULT_EMOJI_SET } from '@/lib/spaceEmojis';
+import { useSaturnAudioNarration } from '@/hooks/useSaturnAudioNarration';
 
 export default function SaturnVisualSolver() {
   const { taskId } = useParams<{ taskId: string }>();
   const { currentTask: task, isLoadingTask, taskError } = usePuzzle(taskId);
   const { state, start, cancel } = useSaturnProgress(taskId);
+  const {
+    enabled: audioEnabled,
+    available: audioAvailable,
+    status: audioStatus,
+    error: audioError,
+    volume: audioVolume,
+    toggleEnabled: toggleAudio,
+    setVolume: setAudioVolume,
+    enqueueReasoning,
+    flush: flushAudio,
+    reset: resetAudio,
+  } = useSaturnAudioNarration();
+  const reasoningCursorRef = React.useRef(0);
+  const previousStatusRef = React.useRef(state.status);
 
   // Settings state - GPT-5 Nano with balanced (low) reasoning depth and detailed summary by default
   const defaultModel = getDefaultSaturnModel();
@@ -56,6 +71,50 @@ export default function SaturnVisualSolver() {
   const showTemperatureControl = React.useMemo(() => isGrokFamily && modelSupportsTemperature(model), [isGrokFamily, model]);
   const showReasoningControls = React.useMemo(() => !isGrokFamily, [isGrokFamily]);
 
+  React.useEffect(() => {
+    const prev = previousStatusRef.current;
+    if (state.status === 'running' && prev !== 'running') {
+      reasoningCursorRef.current = state.streamingReasoning?.length ?? 0;
+      resetAudio();
+    }
+    if ((state.status === 'completed' || state.status === 'error') && prev === 'running') {
+      flushAudio();
+    }
+    if (state.status === 'idle') {
+      reasoningCursorRef.current = 0;
+    }
+    previousStatusRef.current = state.status;
+  }, [flushAudio, resetAudio, state.status, state.streamingReasoning]);
+
+  React.useEffect(() => {
+    if (!audioEnabled) {
+      return;
+    }
+    const reasoningText = state.streamingReasoning ?? '';
+    if (reasoningText.length < reasoningCursorRef.current) {
+      reasoningCursorRef.current = reasoningText.length;
+      return;
+    }
+    if (reasoningText.length > reasoningCursorRef.current) {
+      const delta = reasoningText.slice(reasoningCursorRef.current);
+      reasoningCursorRef.current = reasoningText.length;
+      enqueueReasoning(delta);
+    }
+  }, [audioEnabled, enqueueReasoning, state.streamingReasoning]);
+
+  const previousAudioEnabledRef = React.useRef(audioEnabled);
+
+  React.useEffect(() => {
+    const wasEnabled = previousAudioEnabledRef.current;
+    if (audioEnabled && !wasEnabled) {
+      reasoningCursorRef.current = state.streamingReasoning?.length ?? 0;
+    }
+    if (!audioEnabled && wasEnabled) {
+      resetAudio();
+    }
+    previousAudioEnabledRef.current = audioEnabled;
+  }, [audioEnabled, resetAudio, state.streamingReasoning]);
+
 
   // Error states
   if (!taskId) {
@@ -129,6 +188,28 @@ export default function SaturnVisualSolver() {
             </div>
           )}
           <a href="/solver/readme" className="btn btn-ghost btn-xs">README</a>
+          {audioAvailable && (
+            <div className="flex items-center gap-1">
+              <button
+                type="button"
+                onClick={toggleAudio}
+                className={`btn btn-xs ${audioEnabled ? 'btn-secondary' : 'btn-ghost'}`}
+                title={audioEnabled ? 'Disable narration' : 'Enable narration'}
+              >
+                🔊 {audioEnabled ? 'On' : 'Off'}
+              </button>
+              <input
+                type="range"
+                min="0"
+                max="1"
+                step="0.05"
+                value={audioVolume}
+                onChange={(e) => setAudioVolume(parseFloat(e.target.value))}
+                className="range range-xs w-20"
+                disabled={!audioEnabled}
+              />
+            </div>
+          )}
           {isRunning && (
             <button onClick={cancel} className="btn btn-error btn-sm gap-1">
               <Square className="h-3.5 w-3.5" />
@@ -402,6 +483,26 @@ export default function SaturnVisualSolver() {
             {/* AI Streaming Output - Show ONLY while running */}
             {!isDone && (
               <div className="flex-1 min-h-0">
+                {audioAvailable && (
+                  <div className="px-2 pb-1 text-[11px] text-gray-500 flex items-center gap-2">
+                    <span>
+                      {audioEnabled ? '🔊 Narration' : '🔇 Narration disabled'}
+                    </span>
+                    {audioEnabled && (
+                      <span>
+                        {audioStatus === 'buffering' && 'preparing…'}
+                        {audioStatus === 'playing' && 'playing'}
+                        {audioStatus === 'idle' && 'idle'}
+                        {audioStatus === 'error' && 'error'}
+                      </span>
+                    )}
+                    {!audioEnabled && audioError && <span className="text-red-500">{audioError}</span>}
+                    {audioEnabled && audioError && <span className="text-red-500">{audioError}</span>}
+                  </div>
+                )}
+                {!audioAvailable && audioError && (
+                  <div className="px-2 pb-1 text-[11px] text-red-500">🔇 {audioError}</div>
+                )}
                 <SaturnTerminalLogs
                   streamingText={state.streamingText}
                   streamingReasoning={state.streamingReasoning}
diff --git a/docs/2025-11-02-saturn-tts-plan.md b/docs/2025-11-02-saturn-tts-plan.md
new file mode 100644
index 000000000..1f3656ceb
--- /dev/null
+++ b/docs/2025-11-02-saturn-tts-plan.md
@@ -0,0 +1,41 @@
+# 2025-11-02 Saturn audio streaming plan
+
+## Goal
+Enable Saturn Visual Solver streaming reasoning text to be rendered as real-time audio using the ElevenLabs text-to-speech streaming API, without exposing the API key client-side.
+
+## Scope & files
+- `server/services/audio/elevenLabsService.ts` (new): wrap ElevenLabs streaming API with server-side helpers.
+- `server/controllers/audioController.ts` (new): expose SSE/WebSocket-compatible proxy endpoint for ElevenLabs audio stream.
+- `server/routes.ts`: register the new endpoint.
+- `client/src/hooks/useSaturnProgress.ts`: emit reasoning chunks to audio pipeline.
+- `client/src/hooks/useAudioStream.ts` (new): manage browser audio streaming for ElevenLabs responses.
+- `client/src/pages/SaturnVisualSolver.tsx` and/or related Saturn UI components: add opt-in toggle and audio playback controls.
+- `shared/config/audio.ts` (new): share feature flags/env toggles for audio streaming.
+- `CHANGELOG.md`: record change summary.
+
+## Tasks
+1. **Server-side audio proxy**
+   - Read `ELEVENLABS_API_KEY` and optional `ELEVENLABS_VOICE_ID` from environment.
+   - Validate key presence; respond with 503 when missing.
+   - Implement `ElevenLabsService.streamText` to accept async iterator of text chunks and return Node Readable stream producing MPEG audio via ElevenLabs streaming endpoint (`/v1/text-to-speech/{voice_id}/stream`).
+   - Provide fallback voice (e.g., `Rachel`) when env voice not set.
+
+2. **Streaming controller**
+   - New endpoint `POST /api/audio/stream` accepting JSON body with `textChunks` (array) or enabling chunked reasoning bridging via SSE.
+   - For Saturn integration, create lightweight `POST /api/audio/saturn` that relays reasoning text, streaming audio back as `audio/mpeg`.
+   - Ensure error handling and logging follow existing patterns.
+
+3. **Client audio hook**
+   - Build hook to open `ReadableStreamDefaultReader` from `fetch` and feed into `AudioContext` via `MediaSource`/`SourceBuffer` or Web Audio streaming.
+   - Manage playback state (playing, muted, volume slider) and expose controls to UI.
+
+4. **Saturn UI integration**
+   - Add toggle/button to enable "Speak reasoning" in Saturn Visual Solver UI (default off).
+   - When enabled, send reasoning deltas to ElevenLabs endpoint incrementally (debounce for chunking) and play resulting audio stream.
+   - Display playback status (e.g., "Narrating...", error message).
+
+5. **Testing & docs**
+   - Validate manual run using sample Saturn run (simulate reasoning chunk).
+   - Document env variables in README or dedicated docs section if required.
+   - Update CHANGELOG with feature entry.
+
diff --git a/server/controllers/audioController.ts b/server/controllers/audioController.ts
new file mode 100644
index 000000000..6935116a1
--- /dev/null
+++ b/server/controllers/audioController.ts
@@ -0,0 +1,60 @@
+/**
+ * Author: gpt-5-codex
+ * Date: 2025-11-02T00:00:00Z
+ * PURPOSE: Express controller exposing Saturn audio narration endpoints backed by
+ * ElevenLabs streaming. Provides status discovery and audio proxying with robust
+ * validation and logging.
+ * SRP/DRY check: Pass — controller delegates to ElevenLabs service and response formatter.
+ */
+
+import type { Request, Response } from 'express';
+import { elevenLabsService } from '../services/audio/elevenLabsService.ts';
+import { formatResponse } from '../utils/responseFormatter.ts';
+import { logger } from '../utils/logger.ts';
+
+class AudioController {
+  status = async (_req: Request, res: Response) => {
+    const configured = elevenLabsService.isConfigured();
+
+    return res.json(
+      formatResponse.success({
+        enabled: configured,
+        voiceId: configured ? elevenLabsService.getVoiceId() : null,
+        modelId: configured ? elevenLabsService.getModelId() : null,
+      }),
+    );
+  };
+
+  narrate = async (req: Request, res: Response) => {
+    if (!elevenLabsService.isConfigured()) {
+      return res
+        .status(503)
+        .json(formatResponse.error('service_unavailable', 'ElevenLabs API key not configured for Saturn audio narration.'));
+    }
+
+    const { text, voiceId, modelId } = req.body ?? {};
+
+    if (typeof text !== 'string' || text.trim().length === 0) {
+      return res.status(400).json(formatResponse.error('bad_request', 'text is required for narration.'));
+    }
+
+    try {
+      const { stream, contentType } = await elevenLabsService.streamText(text, { voiceId, modelId });
+      res.setHeader('Content-Type', contentType);
+      res.setHeader('Cache-Control', 'no-store');
+      res.setHeader('Transfer-Encoding', 'chunked');
+
+      return stream.pipe(res);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Failed to stream audio';
+      logger.logError(`[SaturnAudio] Narration request failed: ${message}`, { error, context: 'SaturnAudio' });
+      if (!res.headersSent) {
+        return res.status(502).json(formatResponse.error('bad_gateway', message));
+      }
+      res.end();
+      return undefined;
+    }
+  };
+}
+
+export const audioController = new AudioController();
diff --git a/server/routes.ts b/server/routes.ts
index 8dac5e7a2..ff4926159 100644
--- a/server/routes.ts
+++ b/server/routes.ts
@@ -25,6 +25,7 @@ import * as modelManagementController from './controllers/modelManagementControl
 import * as discussionController from './controllers/discussionController.js';
 import { batchController } from './controllers/batchController.ts';
 import { streamController } from "./controllers/streamController.ts";
+import { audioController } from "./controllers/audioController.ts";
 
 import { eloController } from "./controllers/eloController";
 import modelDatasetController from "./controllers/modelDatasetController.ts";
@@ -83,6 +84,10 @@ export async function registerRoutes(app: Express): Promise<Server> {
   );
   app.delete("/api/stream/analyze/:sessionId", asyncHandler(streamController.cancel));
   app.post("/api/stream/cancel/:sessionId", asyncHandler(streamController.cancel));
+
+  // Audio narration routes (Saturn ElevenLabs proxy)
+  app.get("/api/audio/status", asyncHandler(audioController.status));
+  app.post("/api/audio/narrate", asyncHandler(audioController.narrate));
   
   // Debug route to force puzzle loader reinitialization
   app.post("/api/puzzle/reinitialize", asyncHandler(puzzleController.reinitialize));
diff --git a/server/services/audio/elevenLabsService.ts b/server/services/audio/elevenLabsService.ts
new file mode 100644
index 000000000..728210f02
--- /dev/null
+++ b/server/services/audio/elevenLabsService.ts
@@ -0,0 +1,98 @@
+/**
+ * Author: gpt-5-codex
+ * Date: 2025-11-02T00:00:00Z
+ * PURPOSE: Wraps ElevenLabs text-to-speech streaming so Saturn can narrate reasoning
+ * without exposing secrets to the client. Provides status helpers for controllers
+ * and streams audio directly to Express responses.
+ * SRP/DRY check: Pass — isolates ElevenLabs integration details from controllers.
+ */
+
+import { Readable } from 'node:stream';
+import { logger } from '../../utils/logger.ts';
+
+const DEFAULT_VOICE_ID = '21m00Tcm4TlvDq8ikWAM'; // Rachel
+const DEFAULT_MODEL_ID = 'eleven_turbo_v2_5';
+
+export interface ElevenLabsStreamOptions {
+  voiceId?: string;
+  modelId?: string;
+  optimizeLatency?: 0 | 1 | 2 | 3 | 4 | 5;
+}
+
+export interface ElevenLabsStreamResult {
+  stream: Readable;
+  contentType: string;
+}
+
+class ElevenLabsService {
+  isConfigured(): boolean {
+    return Boolean(process.env.ELEVENLABS_API_KEY);
+  }
+
+  getVoiceId(): string {
+    return process.env.ELEVENLABS_VOICE_ID || DEFAULT_VOICE_ID;
+  }
+
+  getModelId(): string {
+    return process.env.ELEVENLABS_MODEL_ID || DEFAULT_MODEL_ID;
+  }
+
+  private getApiKey(): string {
+    const apiKey = process.env.ELEVENLABS_API_KEY;
+    if (!apiKey) {
+      throw new Error('ElevenLabs API key not configured');
+    }
+    return apiKey;
+  }
+
+  async streamText(text: string, opts: ElevenLabsStreamOptions = {}): Promise<ElevenLabsStreamResult> {
+    if (!text?.trim()) {
+      throw new Error('Text is required for ElevenLabs streaming');
+    }
+
+    const apiKey = this.getApiKey();
+    const voiceId = opts.voiceId || this.getVoiceId();
+    const modelId = opts.modelId || this.getModelId();
+    const optimizeLatency = opts.optimizeLatency ?? 3;
+
+    const url = `https://api.elevenlabs.io/v1/text-to-speech/${voiceId}/stream`;
+
+    const body = JSON.stringify({
+      text,
+      model_id: modelId,
+      optimize_streaming_latency: optimizeLatency,
+      voice_settings: {
+        stability: 0.4,
+        similarity_boost: 0.8,
+      },
+    });
+
+    logger.debug(`Streaming ElevenLabs audio (voice=${voiceId}, model=${modelId}, latency=${optimizeLatency})`, 'ElevenLabs');
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Accept: 'audio/mpeg',
+        'xi-api-key': apiKey,
+      },
+      body,
+    });
+
+    if (!response.ok || !response.body) {
+      const payload = await response.text().catch(() => '');
+      const message = `ElevenLabs request failed (${response.status} ${response.statusText}) ${payload}`;
+      logger.error(message, 'ElevenLabs');
+      throw new Error(message);
+    }
+
+    const nodeStream = Readable.fromWeb(response.body as unknown as ReadableStream<Uint8Array>);
+
+    return {
+      stream: nodeStream,
+      contentType: response.headers.get('content-type') || 'audio/mpeg',
+    };
+  }
+}
+
+export const elevenLabsService = new ElevenLabsService();
diff --git a/shared/config/audio.ts b/shared/config/audio.ts
new file mode 100644
index 000000000..27fb7e6ad
--- /dev/null
+++ b/shared/config/audio.ts
@@ -0,0 +1,80 @@
+/**
+ * Author: gpt-5-codex
+ * Date: 2025-11-02T00:00:00Z
+ * PURPOSE: Shared helpers for resolving Saturn audio narration feature flags so
+ * both backend (Node) and frontend (Vite) can detect whether ElevenLabs text-to-speech
+ * is available without duplicating environment variable parsing logic.
+ * SRP/DRY check: Pass — consolidates audio configuration resolution.
+ */
+
+export interface SaturnAudioConfig {
+  enabled: boolean;
+  defaultEnabled: boolean;
+  backendAdvertises: boolean;
+  frontendAdvertises: boolean;
+}
+
+const BACKEND_KEY = 'SATURN_AUDIO_ENABLED';
+const FRONTEND_KEY = 'VITE_SATURN_AUDIO_ENABLED';
+
+const TRUE_LITERALS = new Set(['true', '1', 'yes', 'y', 'on']);
+const FALSE_LITERALS = new Set(['false', '0', 'no', 'n', 'off']);
+
+function parseBoolean(value: string | boolean | undefined): boolean | undefined {
+  if (typeof value === 'boolean') {
+    return value;
+  }
+  if (typeof value === 'string') {
+    const trimmed = value.trim().toLowerCase();
+    if (TRUE_LITERALS.has(trimmed)) {
+      return true;
+    }
+    if (FALSE_LITERALS.has(trimmed)) {
+      return false;
+    }
+  }
+  return undefined;
+}
+
+function readProcessEnv(): Record<string, string | boolean | undefined> | undefined {
+  try {
+    return typeof process !== 'undefined' ? (process.env as Record<string, string | boolean | undefined>) : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function readImportMetaEnv(): Record<string, string | boolean | undefined> | undefined {
+  try {
+    const meta = typeof import.meta !== 'undefined' ? (import.meta as ImportMeta) : undefined;
+    if (!meta?.env) {
+      return undefined;
+    }
+    return meta.env as Record<string, string | boolean | undefined>;
+  } catch {
+    return undefined;
+  }
+}
+
+export function resolveSaturnAudioConfig(): SaturnAudioConfig {
+  const processEnv = readProcessEnv();
+  const importMetaEnv = readImportMetaEnv();
+  const defaultEnabled = false;
+
+  const backendAdvertises = parseBoolean(processEnv?.[BACKEND_KEY]);
+  const frontendAdvertises =
+    parseBoolean(processEnv?.[FRONTEND_KEY]) ?? parseBoolean(importMetaEnv?.[FRONTEND_KEY]) ?? backendAdvertises;
+
+  const enabled = backendAdvertises ?? frontendAdvertises ?? defaultEnabled;
+
+  return {
+    enabled,
+    defaultEnabled,
+    backendAdvertises: backendAdvertises ?? defaultEnabled,
+    frontendAdvertises: frontendAdvertises ?? defaultEnabled,
+  };
+}
+
+export function isSaturnAudioEnabled(): boolean {
+  return resolveSaturnAudioConfig().enabled;
+}