diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 160e149e..4bd979d8 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -10,6 +10,9 @@ on:
       - main
       - dev
 
+permissions:
+  contents: read
+
 jobs:
   frontend:
     runs-on: ubuntu-24.04
@@ -20,6 +23,8 @@ jobs:
     steps:
       - name: Checkout code
         uses: actions/checkout@v6
+        with:
+          persist-credentials: false
 
       - name: Set up Node.js
         uses: actions/setup-node@v6
@@ -48,6 +53,7 @@ jobs:
         uses: actions/checkout@v6
         with:
           fetch-depth: 0
+          persist-credentials: false
       
       - name: Set up Temurin JDK
         uses: actions/setup-java@v5
diff --git a/frontend/src/lib/components/LearnView.svelte b/frontend/src/lib/components/LearnView.svelte
index 6f66c9a3..c07340d3 100644
--- a/frontend/src/lib/components/LearnView.svelte
+++ b/frontend/src/lib/components/LearnView.svelte
@@ -609,7 +609,12 @@
             <!-- Lesson Header - full width with inner constraint -->
             <div class="lesson-header">
                 <div class="lesson-header-inner">
-                    <button type="button" class="back-btn" onclick={goBack}>
+                    <button
+                        type="button"
+                        class="back-btn"
+                        aria-label="All Lessons"
+                        onclick={goBack}
+                    >
                         <svg
                             viewBox="0 0 20 20"
                             fill="currentColor"
diff --git a/frontend/src/lib/components/LearnView.test.ts b/frontend/src/lib/components/LearnView.test.ts
index 5974c2d5..05fe28a8 100644
--- a/frontend/src/lib/components/LearnView.test.ts
+++ b/frontend/src/lib/components/LearnView.test.ts
@@ -36,6 +36,25 @@ describe("LearnView guided chat streaming stability", () => {
     vi.unstubAllGlobals();
   });
 
+  it("keeps the All Lessons back control named when its visual label is hidden on mobile", async () => {
+    fetchTocMock.mockResolvedValue([
+      { slug: "intro", title: "Test Lesson", summary: "Lesson summary", keywords: [] },
+    ]);
+
+    streamLessonContentMock.mockImplementation(async (_slug, callbacks) => {
+      callbacks.onChunk("# Lesson");
+    });
+    fetchGuidedLessonCitationsMock.mockResolvedValue({ success: true, citations: [] });
+
+    const { findByRole } = await renderLearnView();
+    const lessonButton = await findByRole("button", { name: /test lesson/i });
+    await fireEvent.click(lessonButton);
+
+    const allLessonsButton = await findByRole("button", { name: "All Lessons" });
+    expect(allLessonsButton).toHaveAttribute("aria-label", "All Lessons");
+    expect(allLessonsButton).toHaveTextContent("All Lessons");
+  });
+
   it("keeps the guided assistant message DOM node stable when the stream completes", async () => {
     fetchTocMock.mockResolvedValue([
       { slug: "intro", title: "Test Lesson", summary: "Lesson summary", keywords: [] },
diff --git a/frontend/src/lib/services/javaLanguageDetection.ts b/frontend/src/lib/services/javaLanguageDetection.ts
index 007ef198..bb85f40c 100644
--- a/frontend/src/lib/services/javaLanguageDetection.ts
+++ b/frontend/src/lib/services/javaLanguageDetection.ts
@@ -1,5 +1,5 @@
 /** Keywords indicating Java code for auto-detection. */
-const JAVA_KEYWORDS = [
+const JAVA_KEYWORDS = new Set<string>([
   "public",
   "private",
   "class",
@@ -8,7 +8,16 @@ const JAVA_KEYWORDS = [
   "String",
   "int",
   "boolean",
-] as const;
+]);
+
+/** Java's identifier-ignorable ISO control character ranges. */
+const JAVA_IDENTIFIER_IGNORABLE_CONTROL_RANGES = "\\u0000-\\u0008\\u000E-\\u001B\\u007F-\\u009F";
+
+/** Matches Java identifier parts, including identifier-ignorable characters. */
+const JAVA_IDENTIFIER_PART_PATTERN = new RegExp(
+  `[\\p{ID_Continue}\\p{Sc}\\p{Cf}${JAVA_IDENTIFIER_IGNORABLE_CONTROL_RANGES}]`,
+  "u",
+);
 
 /** CSS class applied to detected Java code blocks for syntax highlighting. */
 const JAVA_LANGUAGE_CLASS = "language-java";
@@ -16,6 +25,26 @@ const JAVA_LANGUAGE_CLASS = "language-java";
 /** Selector for unmarked code blocks eligible for language detection. */
 const UNMARKED_CODE_SELECTOR = "pre > code:not([class])";
 
+/** Determines whether the code text contains a standalone Java keyword token. */
+function containsJavaKeyword(codeText: string): boolean {
+  let javaIdentifier = "";
+
+  for (const codeCharacter of codeText) {
+    if (JAVA_IDENTIFIER_PART_PATTERN.test(codeCharacter)) {
+      javaIdentifier += codeCharacter;
+      continue;
+    }
+
+    if (JAVA_KEYWORDS.has(javaIdentifier)) {
+      return true;
+    }
+
+    javaIdentifier = "";
+  }
+
+  return JAVA_KEYWORDS.has(javaIdentifier);
+}
+
 /** Adds Java highlighting metadata to unmarked code blocks that contain Java keywords. */
 export function applyJavaLanguageDetection(container: HTMLElement | null | undefined): void {
   if (!container || typeof container.querySelectorAll !== "function") {
@@ -31,7 +60,7 @@ export function applyJavaLanguageDetection(container: HTMLElement | null | undef
   const codeBlocks = container.querySelectorAll(UNMARKED_CODE_SELECTOR);
   codeBlocks.forEach((codeBlock) => {
     const codeText = codeBlock.textContent ?? "";
-    if (JAVA_KEYWORDS.some((javaKeyword) => codeText.includes(javaKeyword))) {
+    if (containsJavaKeyword(codeText)) {
       codeBlock.className = JAVA_LANGUAGE_CLASS;
     }
   });
diff --git a/frontend/src/lib/services/markdown.test.ts b/frontend/src/lib/services/markdown.test.ts
index d592520f..ccbf742e 100644
--- a/frontend/src/lib/services/markdown.test.ts
+++ b/frontend/src/lib/services/markdown.test.ts
@@ -189,23 +189,17 @@ describe("applyJavaLanguageDetection", () => {
     expect(code.className).toBe("");
   });
 
-  it("detects various Java keywords", () => {
-    const javaKeywords = [
-      "public",
-      "private",
-      "class",
-      "import",
-      "void",
-      "String",
-      "int",
-      "boolean",
+  it("detects Java keywords at identifier boundaries", () => {
+    const javaKeywordBoundarySnippets = [
+      "int[] greetingCounts = { 1 };",
+      'String.valueOf("hello");',
     ];
 
-    for (const keyword of javaKeywords) {
+    for (const javaKeywordBoundarySnippet of javaKeywordBoundarySnippets) {
       const container = document.createElement("div");
       const pre = document.createElement("pre");
       const code = document.createElement("code");
-      code.textContent = `${keyword} something`;
+      code.textContent = javaKeywordBoundarySnippet;
       pre.appendChild(code);
       container.appendChild(pre);
 
@@ -214,6 +208,30 @@ describe("applyJavaLanguageDetection", () => {
       expect(code.className).toBe("language-java");
     }
   });
+
+  it("does not classify keyword substrings or identifier continuations as Java", () => {
+    const nonJavaSnippets = [
+      'print("hello")',
+      "const point = { horizontal: 1 };",
+      'const hint = "tip";',
+      'const publication = "article";',
+      'const republic = "state";',
+      'const public\uFEFFation = "article";',
+    ];
+
+    for (const nonJavaSnippet of nonJavaSnippets) {
+      const container = document.createElement("div");
+      const pre = document.createElement("pre");
+      const code = document.createElement("code");
+      code.textContent = nonJavaSnippet;
+      pre.appendChild(code);
+      container.appendChild(pre);
+
+      applyJavaLanguageDetection(container);
+
+      expect(code.className).toBe("");
+    }
+  });
 });
 
 describe("escapeHtml", () => {
diff --git a/frontend/src/lib/services/streamRecovery.test.ts b/frontend/src/lib/services/streamRecovery.test.ts
index e4000470..0e78d958 100644
--- a/frontend/src/lib/services/streamRecovery.test.ts
+++ b/frontend/src/lib/services/streamRecovery.test.ts
@@ -99,6 +99,46 @@ describe("streamRecovery", () => {
     expect(retryDecision).toBe(true);
   });
 
+  it("retries a generic terminal stream error when the backend marks it retryable", () => {
+    const retryDecision = shouldRetryStreamRequest(
+      new Error("Streaming error"),
+      {
+        message: "Streaming error",
+        code: "stream.provider.retryable-error",
+        retryable: true,
+        stage: "stream",
+      },
+      null,
+      false,
+      0,
+      1,
+    );
+
+    expect(retryDecision).toBe(true);
+  });
+
+  it("refuses retry when a terminal error overrides an earlier retryable status", () => {
+    const retryDecision = shouldRetryStreamRequest(
+      new Error("Streaming error"),
+      {
+        message: "Streaming error",
+        code: "stream.provider.fatal-error",
+        retryable: false,
+        stage: "stream",
+      },
+      {
+        message: "Provider fallback succeeded",
+        retryable: true,
+        stage: "stream",
+      },
+      false,
+      0,
+      1,
+    );
+
+    expect(retryDecision).toBe(false);
+  });
+
   it("preserves stream error details in thrown stream failure exception", () => {
     const streamFailureException = toStreamFailureException(new Error("Transport failed"), {
       message: "OverflowException",
diff --git a/frontend/src/lib/services/streamRecovery.ts b/frontend/src/lib/services/streamRecovery.ts
index 62b9b75b..91257c43 100644
--- a/frontend/src/lib/services/streamRecovery.ts
+++ b/frontend/src/lib/services/streamRecovery.ts
@@ -56,7 +56,8 @@ export const MAX_STREAM_RECOVERY_RETRIES = resolveStreamRecoveryRetryCount(
  * The retry gate is intentionally strict:
  * - bounded retries via MAX_STREAM_RECOVERY_RETRIES,
  * - only before any assistant chunk has been rendered,
- * - only for known malformed/overflow stream signatures.
+ * - terminal backend metadata takes precedence over earlier status events,
+ * - unstructured failures require a known recoverable signature.
  */
 export function shouldRetryStreamRequest(
   streamFailure: unknown,
@@ -72,6 +73,9 @@ export function shouldRetryStreamRequest(
   if (attemptedRetries >= maxRecoveryRetries) {
     return false;
   }
+  if (typeof streamErrorEvent?.retryable === "boolean") {
+    return streamErrorEvent.retryable;
+  }
   if (latestStreamStatus?.stage === "stream" && latestStreamStatus.retryable === false) {
     return false;
   }
diff --git a/frontend/src/styles/global.css b/frontend/src/styles/global.css
index 70661105..8ef0e25b 100644
--- a/frontend/src/styles/global.css
+++ b/frontend/src/styles/global.css
@@ -5,7 +5,7 @@
  */
 
 @font-face {
-  font-family: "Fraunces";
+  font-family: Fraunces;
   src: url("/fonts/Fraunces-Variable.ttf") format("truetype");
   font-weight: 100 900;
   font-display: swap;
@@ -294,27 +294,6 @@ body {
   }
 }
 
-@keyframes slide-in-right {
-  from {
-    opacity: 0;
-    transform: translateX(-12px);
-  }
-  to {
-    opacity: 1;
-    transform: translateX(0);
-  }
-}
-
-@keyframes pulse-subtle {
-  0%,
-  100% {
-    opacity: 1;
-  }
-  50% {
-    opacity: 0.6;
-  }
-}
-
 @keyframes typing-cursor {
   0%,
   100% {
diff --git a/src/main/java/com/williamcallahan/javachat/config/SystemPromptConfig.java b/src/main/java/com/williamcallahan/javachat/config/SystemPromptConfig.java
index 6a0a0166..d263aae4 100644
--- a/src/main/java/com/williamcallahan/javachat/config/SystemPromptConfig.java
+++ b/src/main/java/com/williamcallahan/javachat/config/SystemPromptConfig.java
@@ -11,7 +11,13 @@
 public class SystemPromptConfig {
 
     private static final String JDK_VERSION_PLACEHOLDER = "__JDK_VERSION__";
-    private static final String CORE_PROMPT_TEMPLATE = """
+    static final String MARKER_PROSE_LINE_CLAUSE = "Put each enrichment marker only on its own prose line.";
+    static final String MARKER_CODE_BOUNDARY_CLAUSE =
+            "Never place an enrichment marker inside inline code or a fenced code block; put it before or after the fence.";
+    static final String JAVA_FENCE_VALIDITY_CLAUSE =
+            "A fenced `java` block contains syntactically valid Java that compiles with its stated imports and context. Use real APIs appropriate to the response context; never invent API names, method signatures, or type arguments.";
+    private static final String CORE_PROMPT_TEMPLATE =
+            """
             You are a Java learning assistant focused on Java __JDK_VERSION__ and current stable JDK releases.
 
             ## Default Environment
@@ -42,14 +48,19 @@ If the user asks about a feature, answer for Java __JDK_VERSION__ (preview disab
             - Prefer official docs and stable releases over previews or early-access content
 
             ## Learning Enhancement Markers
-            CRITICAL: Embed learning insights directly in your response using these markers. EACH marker MUST be on its own line.
+            Embed learning insights directly in prose using these markers:
             - {{hint:Text here}} for helpful tips and best practices
             - {{reminder:Text here}} for important things to remember
             - {{background:Text here}} for conceptual explanations
-            - {{example:code here}} for inline code examples
+            - {{example:code here}} for concise Java examples
             - {{warning:Text here}} for common pitfalls to avoid
 
-            Integrate these markers naturally throughout your explanation. Don't group them at the end.
+            ### Marker and Code Boundaries
+            - %s
+            - %s
+            - %s
+
+            Integrate these markers naturally throughout your prose. Don't group them at the end.
 
             ## Citation Handling
             Do NOT include footnote references like [1], [2] or citation/reference sections in your response.
@@ -63,7 +74,7 @@ Simply reference sources naturally in prose when relevant (e.g., "the JDK docume
             - If a feature became final before the active Java version context, treat it as a standard language feature without version caveats
             - The active Java version context is the user-stated version when provided; otherwise use the default (__JDK_VERSION__)
             - If the user explicitly states an older Java version, apply version-appropriate warnings (e.g., preview features in that version)
-            """;
+            """.formatted(MARKER_PROSE_LINE_CLAUSE, MARKER_CODE_BOUNDARY_CLAUSE, JAVA_FENCE_VALIDITY_CLAUSE);
 
     @Value("${DOCS_JDK_VERSION:25}")
     private String jdkVersion;
diff --git a/src/main/java/com/williamcallahan/javachat/service/OpenAIStreamingService.java b/src/main/java/com/williamcallahan/javachat/service/OpenAIStreamingService.java
index cb925a69..2b1e06d5 100644
--- a/src/main/java/com/williamcallahan/javachat/service/OpenAIStreamingService.java
+++ b/src/main/java/com/williamcallahan/javachat/service/OpenAIStreamingService.java
@@ -165,14 +165,23 @@ public Mono<StreamingResult> streamResponse(StructuredPrompt structuredPrompt, d
                     }
 
                     OpenAiProviderCandidate initialProvider = availableProviders.get(0);
+                    // Routing selects two candidates, so one pre-text fallback signal is sufficient.
                     Sinks.Many<StreamingNotice> noticeSink =
-                            Sinks.many().multicast().onBackpressureBuffer();
+                            Sinks.many().replay().limit(1);
+                    Sinks.One<RateLimitService.ApiProvider> providerChangeSink = Sinks.one();
                     StreamingAttemptContext attemptContext =
-                            StreamingAttemptContext.first(availableProviders, noticeSink);
+                            StreamingAttemptContext.first(availableProviders, noticeSink, providerChangeSink);
                     Flux<String> contentFlux = executeStreamingWithPreTextRetry(
                                     structuredPrompt, temperature, attemptContext)
-                            .doFinally(ignoredSignal -> noticeSink.tryEmitComplete());
-                    return Mono.just(new StreamingResult(contentFlux, initialProvider.provider(), noticeSink.asFlux()));
+                            .doFinally(ignoredSignalType -> {
+                                noticeSink.tryEmitComplete();
+                                providerChangeSink.tryEmitEmpty();
+                            });
+                    return Mono.just(new StreamingResult(
+                            contentFlux,
+                            initialProvider.provider(),
+                            providerChangeSink.asMono().flux(),
+                            noticeSink.asFlux()));
                 })
                 .subscribeOn(Schedulers.boundedElastic());
     }
@@ -370,6 +379,7 @@ private Flux<String> executeStreamingWithPreTextRetry(
                             nextAttempt.maxAttempts(),
                             streamingFailure.getClass().getSimpleName());
 
+                    emitProviderChange(attemptContext.providerChangeSink(), retryProvider.provider());
                     emitStreamingNotice(
                             attemptContext.noticeSink(),
                             StreamingNotice.builder(
@@ -485,4 +495,15 @@ private void emitStreamingNotice(Sinks.Many<StreamingNotice> noticeSink, Streami
             log.debug("Failed to emit streaming notice (emitResult={})", emitResult);
         }
     }
+
+    private void emitProviderChange(
+            Sinks.One<RateLimitService.ApiProvider> providerChangeSink, RateLimitService.ApiProvider fallbackProvider) {
+        Sinks.EmitResult emitResult = providerChangeSink.tryEmitValue(fallbackProvider);
+        if (emitResult.isFailure()) {
+            log.debug(
+                    "Failed to emit fallback provider change (providerId={}, emitResult={})",
+                    fallbackProvider.ordinal(),
+                    emitResult);
+        }
+    }
 }
diff --git a/src/main/java/com/williamcallahan/javachat/service/StreamingAttemptContext.java b/src/main/java/com/williamcallahan/javachat/service/StreamingAttemptContext.java
index 0bfc9557..34367b1c 100644
--- a/src/main/java/com/williamcallahan/javachat/service/StreamingAttemptContext.java
+++ b/src/main/java/com/williamcallahan/javachat/service/StreamingAttemptContext.java
@@ -8,10 +8,14 @@
  * Tracks bounded provider attempts during streaming before response text is emitted.
  */
 record StreamingAttemptContext(
-        List<OpenAiProviderCandidate> availableProviders, int attemptIndex, Sinks.Many<StreamingNotice> noticeSink) {
+        List<OpenAiProviderCandidate> availableProviders,
+        int attemptIndex,
+        Sinks.Many<StreamingNotice> noticeSink,
+        Sinks.One<RateLimitService.ApiProvider> providerChangeSink) {
     StreamingAttemptContext {
         Objects.requireNonNull(availableProviders, "availableProviders");
         Objects.requireNonNull(noticeSink, "noticeSink");
+        Objects.requireNonNull(providerChangeSink, "providerChangeSink");
         if (availableProviders.isEmpty()) {
             throw new IllegalArgumentException("availableProviders cannot be empty");
         }
@@ -23,8 +27,10 @@ record StreamingAttemptContext(
     }
 
     static StreamingAttemptContext first(
-            List<OpenAiProviderCandidate> availableProviders, Sinks.Many<StreamingNotice> noticeSink) {
-        return new StreamingAttemptContext(availableProviders, 0, noticeSink);
+            List<OpenAiProviderCandidate> availableProviders,
+            Sinks.Many<StreamingNotice> noticeSink,
+            Sinks.One<RateLimitService.ApiProvider> providerChangeSink) {
+        return new StreamingAttemptContext(availableProviders, 0, noticeSink, providerChangeSink);
     }
 
     OpenAiProviderCandidate currentProvider() {
@@ -48,7 +54,7 @@ StreamingAttemptContext withNextAttempt() {
             throw new IllegalStateException("streaming attempts are exhausted");
         }
 
-        return new StreamingAttemptContext(availableProviders, attemptIndex + 1, noticeSink);
+        return new StreamingAttemptContext(availableProviders, attemptIndex + 1, noticeSink, providerChangeSink);
     }
 
     private static int maximumAttemptsFor(List<OpenAiProviderCandidate> availableProviders) {
diff --git a/src/main/java/com/williamcallahan/javachat/service/StreamingResult.java b/src/main/java/com/williamcallahan/javachat/service/StreamingResult.java
index dbab186c..8c2d18bd 100644
--- a/src/main/java/com/williamcallahan/javachat/service/StreamingResult.java
+++ b/src/main/java/com/williamcallahan/javachat/service/StreamingResult.java
@@ -7,10 +7,14 @@
  *
  * @param textChunks the streaming response flux
  * @param provider the initially selected LLM provider for this request
+ * @param providerChanges providers selected for a retry after a pre-text fallback
  * @param notices runtime streaming notices (for example, pre-first-token provider failover)
  */
 public record StreamingResult(
-        Flux<String> textChunks, RateLimitService.ApiProvider provider, Flux<StreamingNotice> notices) {
+        Flux<String> textChunks,
+        RateLimitService.ApiProvider provider,
+        Flux<RateLimitService.ApiProvider> providerChanges,
+        Flux<StreamingNotice> notices) {
     /** Returns a user-friendly display name for the provider. */
     public String providerDisplayName() {
         return provider.getName();
diff --git a/src/main/java/com/williamcallahan/javachat/web/ChatController.java b/src/main/java/com/williamcallahan/javachat/web/ChatController.java
index 00f6c0c3..c099860a 100644
--- a/src/main/java/com/williamcallahan/javachat/web/ChatController.java
+++ b/src/main/java/com/williamcallahan/javachat/web/ChatController.java
@@ -175,6 +175,9 @@ public Flux<ServerSentEvent<String>> stream(
 
                                     Flux<ServerSentEvent<String>> runtimeStreamingStatusEvents =
                                             sseSupport.streamingNoticeEvents(streamingResult.notices());
+                                    Flux<ServerSentEvent<String>> providerChangeEvents = streamingResult
+                                            .providerChanges()
+                                            .map(provider -> sseSupport.providerEvent(provider.getName()));
 
                                     // Wrap chunks in JSON to preserve whitespace
                                     Flux<ServerSentEvent<String>> dataEvents = dataStream.map(sseSupport::textEvent);
@@ -182,10 +185,16 @@ public Flux<ServerSentEvent<String>> stream(
                                     Flux<ServerSentEvent<String>> citationEvent =
                                             Flux.just(sseSupport.citationEvent(finalCitations));
 
+                                    // Subscribe to replayable fallback signals before the ref-counted data stream
+                                    // starts.
                                     return Flux.concat(
                                             Flux.just(providerEvent),
                                             statusEvents,
-                                            Flux.merge(dataEvents, heartbeats, runtimeStreamingStatusEvents),
+                                            Flux.merge(
+                                                    providerChangeEvents,
+                                                    runtimeStreamingStatusEvents,
+                                                    dataEvents,
+                                                    heartbeats),
                                             citationEvent);
                                 })
                                 .doOnComplete(() -> {
diff --git a/src/main/java/com/williamcallahan/javachat/web/GuidedLearningController.java b/src/main/java/com/williamcallahan/javachat/web/GuidedLearningController.java
index 1028daf1..ea5b827b 100644
--- a/src/main/java/com/williamcallahan/javachat/web/GuidedLearningController.java
+++ b/src/main/java/com/williamcallahan/javachat/web/GuidedLearningController.java
@@ -43,6 +43,9 @@
 @PreAuthorize("permitAll()")
 public class GuidedLearningController extends BaseController {
     private static final int MAX_GUIDED_LOG_FIELD_LENGTH = 256;
+    private static final String GUIDED_CHAT_STREAM_ERROR_MESSAGE = "Streaming error";
+    private static final String GUIDED_CHAT_STREAM_ERROR_DETAILS =
+            "The response stream encountered an error. Please try again.";
     private static final Logger log = LoggerFactory.getLogger(GuidedLearningController.class);
 
     /** Timeout for synchronous lesson content generation operations. */
@@ -296,11 +299,19 @@ private Flux<ServerSentEvent<String>> streamGuidedResponse(String sessionId, Str
                                         sseSupport.citationWarningStatusFlux(finalCitationWarning);
                                 Flux<ServerSentEvent<String>> runtimeStreamingStatusEvents =
                                         sseSupport.streamingNoticeEvents(streamingResult.notices());
+                                Flux<ServerSentEvent<String>> providerChangeEvents = streamingResult
+                                        .providerChanges()
+                                        .map(provider -> sseSupport.providerEvent(provider.getName()));
 
+                                // Subscribe to replayable fallback signals before the ref-counted data stream starts.
                                 return Flux.concat(
                                         Flux.just(providerEvent),
                                         statusEvents,
-                                        Flux.merge(dataEvents, heartbeats, runtimeStreamingStatusEvents),
+                                        Flux.merge(
+                                                providerChangeEvents,
+                                                runtimeStreamingStatusEvents,
+                                                dataEvents,
+                                                heartbeats),
                                         citationEvent);
                             })
                             .doOnComplete(() -> chatMemory.addAssistant(sessionId, fullResponse.toString()));
@@ -322,14 +333,9 @@ private Flux<ServerSentEvent<String>> streamGuidedResponse(String sessionId, Str
                                 .addKeyValue("exceptionType", error.getClass().getSimpleName())
                                 .log();
                     }
-                    Throwable upstreamFailure = terminalFailureContext
-                            .map(ReportedStreamingFailure::upstreamFailure)
-                            .orElse(error);
                     boolean retryable = openAIStreamingService.isRecoverableStreamingFailure(error);
                     return sseSupport.streamErrorEvent(
-                            "Streaming error: " + upstreamFailure.getClass().getSimpleName(),
-                            "The response stream encountered an error. Please try again.",
-                            retryable);
+                            GUIDED_CHAT_STREAM_ERROR_MESSAGE, GUIDED_CHAT_STREAM_ERROR_DETAILS, retryable);
                 });
     }
 
diff --git a/src/test/java/com/williamcallahan/javachat/config/SystemPromptConfigTest.java b/src/test/java/com/williamcallahan/javachat/config/SystemPromptConfigTest.java
new file mode 100644
index 00000000..b34022a1
--- /dev/null
+++ b/src/test/java/com/williamcallahan/javachat/config/SystemPromptConfigTest.java
@@ -0,0 +1,28 @@
+package com.williamcallahan.javachat.config;
+
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.test.util.ReflectionTestUtils;
+
+/**
+ * Verifies that the core prompt protects prose enrichment markers and Java code blocks.
+ */
+class SystemPromptConfigTest {
+
+    private static final String TEST_JDK_VERSION = "25";
+
+    @Test
+    void shouldRequireSafeMarkerPlacementAndValidJavaFences() {
+        SystemPromptConfig systemPromptConfig = new SystemPromptConfig();
+        ReflectionTestUtils.setField(systemPromptConfig, "jdkVersion", TEST_JDK_VERSION);
+
+        String corePrompt = systemPromptConfig.getCoreSystemPrompt();
+
+        assertAll(
+                () -> assertTrue(corePrompt.contains(SystemPromptConfig.MARKER_PROSE_LINE_CLAUSE)),
+                () -> assertTrue(corePrompt.contains(SystemPromptConfig.MARKER_CODE_BOUNDARY_CLAUSE)),
+                () -> assertTrue(corePrompt.contains(SystemPromptConfig.JAVA_FENCE_VALIDITY_CLAUSE)));
+    }
+}
diff --git a/src/test/java/com/williamcallahan/javachat/service/OpenAIStreamingServiceTest.java b/src/test/java/com/williamcallahan/javachat/service/OpenAIStreamingServiceTest.java
index bcd2ed54..5187e786 100644
--- a/src/test/java/com/williamcallahan/javachat/service/OpenAIStreamingServiceTest.java
+++ b/src/test/java/com/williamcallahan/javachat/service/OpenAIStreamingServiceTest.java
@@ -35,9 +35,11 @@
 import com.williamcallahan.javachat.application.prompt.PromptTruncator;
 import com.williamcallahan.javachat.application.streaming.StreamingFailureReporter;
 import com.williamcallahan.javachat.domain.prompt.StructuredPrompt;
+import com.williamcallahan.javachat.web.SseConstants;
 import java.io.InterruptedIOException;
 import java.time.Duration;
 import java.util.List;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.stream.Stream;
 import org.junit.jupiter.api.AfterEach;
@@ -298,7 +300,7 @@ void emptyTextDeltaDoesNotRepeatTheOnlyProvider() {
     }
 
     @Test
-    void preTextFailureMovesToDistinctSecondProvider() {
+    void preTextFailureMovesToDistinctSecondProviderAndPublishesReplayableFallbackSignals() {
         RateLimitService rateLimitService = mock(RateLimitService.class);
         when(rateLimitService.isProviderAvailable(RateLimitService.ApiProvider.GITHUB_MODELS))
                 .thenReturn(true);
@@ -333,12 +335,30 @@ void preTextFailureMovesToDistinctSecondProvider() {
         ReflectionTestUtils.setField(streamingService, "clientPrimary", githubModelsClient);
         ReflectionTestUtils.setField(streamingService, "clientSecondary", openAiClient);
 
-        StepVerifier.create(streamingService
-                        .streamResponse(StructuredPrompt.fromRawPrompt("test", 1), 0.7)
-                        .flatMapMany(StreamingResult::textChunks))
+        StreamingResult streamingResult = Objects.requireNonNull(streamingService
+                .streamResponse(StructuredPrompt.fromRawPrompt("test", 1), 0.7)
+                .block());
+
+        assertEquals(RateLimitService.ApiProvider.GITHUB_MODELS, streamingResult.provider());
+        StepVerifier.create(streamingResult.textChunks())
                 .expectNext("second provider text")
                 .verifyComplete();
 
+        StepVerifier.create(streamingResult.providerChanges())
+                .expectNext(RateLimitService.ApiProvider.OPENAI)
+                .verifyComplete();
+
+        StepVerifier.create(streamingResult.notices())
+                .assertNext(fallbackNotice -> {
+                    assertEquals(SseConstants.STATUS_CODE_STREAM_PROVIDER_FALLBACK, fallbackNotice.code());
+                    assertEquals("openai", fallbackNotice.provider());
+                    assertEquals(SseConstants.STATUS_STAGE_STREAM, fallbackNotice.stage());
+                    assertEquals(2, fallbackNotice.attempt());
+                    assertEquals(2, fallbackNotice.maxAttempts());
+                    assertTrue(fallbackNotice.retryable());
+                })
+                .verifyComplete();
+
         verify(githubModelsResponseService).createStreaming(any(ResponseCreateParams.class), any(RequestOptions.class));
         verify(openAiResponseService).createStreaming(any(ResponseCreateParams.class), any(RequestOptions.class));
     }
diff --git a/src/test/java/com/williamcallahan/javachat/service/StreamingAttemptContextTest.java b/src/test/java/com/williamcallahan/javachat/service/StreamingAttemptContextTest.java
index bac718db..9729b694 100644
--- a/src/test/java/com/williamcallahan/javachat/service/StreamingAttemptContextTest.java
+++ b/src/test/java/com/williamcallahan/javachat/service/StreamingAttemptContextTest.java
@@ -20,7 +20,8 @@ class StreamingAttemptContextTest {
     @Test
     void singleProviderIsAttemptedExactlyOnce() {
         OpenAiProviderCandidate onlyProvider = provider(RateLimitService.ApiProvider.OPENAI);
-        StreamingAttemptContext firstAttempt = StreamingAttemptContext.first(List.of(onlyProvider), noticeSink());
+        StreamingAttemptContext firstAttempt =
+                StreamingAttemptContext.first(List.of(onlyProvider), noticeSink(), providerChangeSink());
 
         assertAttempt(firstAttempt, onlyProvider, 1, SINGLE_PROVIDER_ATTEMPT_COUNT, false);
         assertThrows(IllegalStateException.class, firstAttempt::withNextAttempt);
@@ -30,8 +31,8 @@ void singleProviderIsAttemptedExactlyOnce() {
     void multipleProvidersAreAttemptedExactlyOnceEach() {
         OpenAiProviderCandidate primaryProvider = provider(RateLimitService.ApiProvider.OPENAI);
         OpenAiProviderCandidate secondaryProvider = provider(RateLimitService.ApiProvider.GITHUB_MODELS);
-        StreamingAttemptContext firstAttempt =
-                StreamingAttemptContext.first(List.of(primaryProvider, secondaryProvider), noticeSink());
+        StreamingAttemptContext firstAttempt = StreamingAttemptContext.first(
+                List.of(primaryProvider, secondaryProvider), noticeSink(), providerChangeSink());
 
         assertAttempt(firstAttempt, primaryProvider, 1, DISTINCT_PROVIDER_ATTEMPT_COUNT, true);
 
@@ -49,6 +50,10 @@ private static Sinks.Many<StreamingNotice> noticeSink() {
         return Sinks.many().multicast().onBackpressureBuffer();
     }
 
+    private static Sinks.One<RateLimitService.ApiProvider> providerChangeSink() {
+        return Sinks.one();
+    }
+
     private static void assertAttempt(
             StreamingAttemptContext attemptContext,
             OpenAiProviderCandidate expectedProvider,
diff --git a/src/test/java/com/williamcallahan/javachat/web/ChatControllerStreamingFailureTest.java b/src/test/java/com/williamcallahan/javachat/web/ChatControllerStreamingFailureTest.java
index d8c219e9..5bfd27cc 100644
--- a/src/test/java/com/williamcallahan/javachat/web/ChatControllerStreamingFailureTest.java
+++ b/src/test/java/com/williamcallahan/javachat/web/ChatControllerStreamingFailureTest.java
@@ -127,7 +127,10 @@ private List<ServerSentEvent<String>> streamFailure(Throwable streamingFailure,
         when(retrievalService.toCitations(anyList())).thenReturn(new RetrievalService.CitationOutcome(List.of(), 0));
         when(streamingService.streamResponse(any(StructuredPrompt.class), anyDouble()))
                 .thenReturn(Mono.just(new StreamingResult(
-                        Flux.error(streamingFailure), RateLimitService.ApiProvider.OPENAI, Flux.empty())));
+                        Flux.error(streamingFailure),
+                        RateLimitService.ApiProvider.OPENAI,
+                        Flux.empty(),
+                        Flux.empty())));
         when(streamingService.isRecoverableStreamingFailure(streamingFailure)).thenReturn(retryable);
 
         return chatController.stream(new ChatStreamRequest(SESSION_ID, USER_QUERY, null), new MockHttpServletResponse())
diff --git a/src/test/java/com/williamcallahan/javachat/web/GuidedLearningControllerStreamingFailureTest.java b/src/test/java/com/williamcallahan/javachat/web/GuidedLearningControllerStreamingFailureTest.java
index bedfc897..a28dcc3b 100644
--- a/src/test/java/com/williamcallahan/javachat/web/GuidedLearningControllerStreamingFailureTest.java
+++ b/src/test/java/com/williamcallahan/javachat/web/GuidedLearningControllerStreamingFailureTest.java
@@ -1,5 +1,9 @@
 package com.williamcallahan.javachat.web;
 
+import static com.williamcallahan.javachat.web.SseConstants.EVENT_ERROR;
+import static com.williamcallahan.javachat.web.SseConstants.STATUS_CODE_STREAM_PROVIDER_FATAL_ERROR;
+import static com.williamcallahan.javachat.web.SseConstants.STATUS_CODE_STREAM_PROVIDER_RETRYABLE_ERROR;
+import static com.williamcallahan.javachat.web.SseConstants.STATUS_STAGE_STREAM;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNull;
@@ -15,6 +19,7 @@
 import ch.qos.logback.classic.Logger;
 import ch.qos.logback.classic.spi.ILoggingEvent;
 import ch.qos.logback.core.read.ListAppender;
+import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.williamcallahan.javachat.config.AppProperties;
 import com.williamcallahan.javachat.domain.prompt.StructuredPrompt;
@@ -26,16 +31,18 @@
 import com.williamcallahan.javachat.service.RetrievalService;
 import com.williamcallahan.javachat.service.StreamingResult;
 import java.util.List;
+import java.util.Objects;
 import java.util.Optional;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.slf4j.LoggerFactory;
+import org.springframework.http.codec.ServerSentEvent;
 import org.springframework.mock.web.MockHttpServletResponse;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
-/** Verifies guided stream boundaries do not duplicate service-owned terminal stream alerts. */
+/** Verifies guided stream boundaries keep failure diagnostics internal without duplicating terminal alerts. */
 class GuidedLearningControllerStreamingFailureTest {
     private static final String SESSION_ID = "guided-session";
     private static final String LESSON_SLUG = "sealed-classes";
@@ -44,6 +51,7 @@ class GuidedLearningControllerStreamingFailureTest {
 
     private final Logger controllerLogger = (Logger) LoggerFactory.getLogger(GuidedLearningController.class);
     private final ListAppender<ILoggingEvent> logAppender = new ListAppender<>();
+    private final ObjectMapper objectMapper = new ObjectMapper();
 
     private GuidedLearningService guidedLearningService;
     private ChatMemoryService chatMemoryService;
@@ -65,7 +73,7 @@ void setUpController() {
                 streamingService,
                 new ExceptionResponseBuilder(),
                 mock(MarkdownService.class),
-                new SseSupport(new ObjectMapper()),
+                new SseSupport(objectMapper),
                 new AppProperties());
     }
 
@@ -77,7 +85,7 @@ void stopCapturingControllerLogs() {
     }
 
     @Test
-    void guidedChatDoesNotEmitDuplicateErrorForTerminalStreamingFailure() {
+    void guidedChatKeepsTerminalExceptionTypeOutOfRetryableClientError() throws JsonProcessingException {
         ReportedTerminalStreamingFailure terminalFailure = terminalFailure();
         when(streamingService.isAvailable()).thenReturn(true);
         when(chatMemoryService.getHistory(SESSION_ID)).thenReturn(List.of());
@@ -87,15 +95,24 @@ void guidedChatDoesNotEmitDuplicateErrorForTerminalStreamingFailure() {
         when(guidedLearningService.citationsForBookDocuments(anyList())).thenReturn(List.of());
         when(streamingService.streamResponse(any(StructuredPrompt.class), anyDouble()))
                 .thenReturn(Mono.just(new StreamingResult(
-                        Flux.error(terminalFailure), RateLimitService.ApiProvider.OPENAI, Flux.empty())));
+                        Flux.error(terminalFailure), RateLimitService.ApiProvider.OPENAI, Flux.empty(), Flux.empty())));
         when(streamingService.isRecoverableStreamingFailure(terminalFailure)).thenReturn(true);
 
-        List<?> streamEvents = guidedController.stream(
+        List<ServerSentEvent<String>> streamEvents = guidedController.stream(
                         new GuidedStreamRequest(SESSION_ID, LESSON_SLUG, USER_QUERY), new MockHttpServletResponse())
                 .collectList()
                 .block();
 
         assertFalse(streamEvents.isEmpty());
+        String serializedStreamError = serializedErrorEvent(streamEvents);
+        SseSupport.SseEventPayload streamError =
+                objectMapper.readValue(serializedStreamError, SseSupport.SseEventPayload.class);
+        assertEquals("Streaming error", streamError.message());
+        assertEquals("The response stream encountered an error. Please try again.", streamError.details());
+        assertEquals(STATUS_CODE_STREAM_PROVIDER_RETRYABLE_ERROR, streamError.code());
+        assertEquals(Boolean.TRUE, streamError.retryable());
+        assertEquals(STATUS_STAGE_STREAM, streamError.stage());
+        assertFalse(serializedStreamError.contains(IllegalStateException.class.getSimpleName()));
         assertEquals(0, controllerErrorCount());
     }
 
@@ -106,7 +123,7 @@ void guidedLessonContentDoesNotEmitDuplicateErrorForTerminalStreamingFailure() {
         when(guidedLearningService.streamLessonContent(LESSON_SLUG)).thenReturn(Flux.error(terminalFailure));
         when(streamingService.isRecoverableStreamingFailure(terminalFailure)).thenReturn(true);
 
-        List<?> streamEvents = guidedController
+        List<ServerSentEvent<String>> streamEvents = guidedController
                 .streamLesson(LESSON_SLUG, new MockHttpServletResponse())
                 .collectList()
                 .block();
@@ -116,7 +133,7 @@ void guidedLessonContentDoesNotEmitDuplicateErrorForTerminalStreamingFailure() {
     }
 
     @Test
-    void guidedChatLogsBoundedNonTerminalContextWithoutThrowable() {
+    void guidedChatKeepsNonTerminalExceptionTypeInStructuredLogOnly() throws JsonProcessingException {
         IllegalStateException upstreamFailure = new IllegalStateException(UPSTREAM_SECRET_MESSAGE);
         when(streamingService.isAvailable()).thenReturn(true);
         when(chatMemoryService.getHistory(SESSION_ID)).thenReturn(List.of());
@@ -126,15 +143,23 @@ void guidedChatLogsBoundedNonTerminalContextWithoutThrowable() {
         when(guidedLearningService.citationsForBookDocuments(anyList())).thenReturn(List.of());
         when(streamingService.streamResponse(any(StructuredPrompt.class), anyDouble()))
                 .thenReturn(Mono.just(new StreamingResult(
-                        Flux.error(upstreamFailure), RateLimitService.ApiProvider.OPENAI, Flux.empty())));
+                        Flux.error(upstreamFailure), RateLimitService.ApiProvider.OPENAI, Flux.empty(), Flux.empty())));
         when(streamingService.isRecoverableStreamingFailure(upstreamFailure)).thenReturn(false);
 
-        List<?> streamEvents = guidedController.stream(
+        List<ServerSentEvent<String>> streamEvents = guidedController.stream(
                         new GuidedStreamRequest(SESSION_ID, LESSON_SLUG, USER_QUERY), new MockHttpServletResponse())
                 .collectList()
                 .block();
 
         assertFalse(streamEvents.isEmpty());
+        String serializedStreamError = serializedErrorEvent(streamEvents);
+        SseSupport.SseEventPayload streamError =
+                objectMapper.readValue(serializedStreamError, SseSupport.SseEventPayload.class);
+        assertEquals("Streaming error", streamError.message());
+        assertEquals(STATUS_CODE_STREAM_PROVIDER_FATAL_ERROR, streamError.code());
+        assertEquals(Boolean.FALSE, streamError.retryable());
+        assertFalse(serializedStreamError.contains(IllegalStateException.class.getSimpleName()));
+        assertFalse(serializedStreamError.contains(UPSTREAM_SECRET_MESSAGE));
         ILoggingEvent controllerAlert = logAppender.list.stream()
                 .filter(logEvent -> logEvent.getLevel() == Level.ERROR)
                 .findFirst()
@@ -156,6 +181,14 @@ private long controllerErrorCount() {
                 .count();
     }
 
+    private static String serializedErrorEvent(List<ServerSentEvent<String>> streamEvents) {
+        ServerSentEvent<String> errorEvent = streamEvents.stream()
+                .filter(streamEvent -> EVENT_ERROR.equals(streamEvent.event()))
+                .findFirst()
+                .orElseThrow();
+        return Objects.requireNonNull(errorEvent.data(), "error event data");
+    }
+
     private void assertLogField(ILoggingEvent controllerAlert, String fieldName, Object expectedField) {
         assertTrue(controllerAlert.getKeyValuePairs().stream()
                 .anyMatch(structuredField ->
diff --git a/src/test/java/com/williamcallahan/javachat/web/GuidedSseCitationEventTest.java b/src/test/java/com/williamcallahan/javachat/web/GuidedSseCitationEventTest.java
index 4d0257f0..335cdf01 100644
--- a/src/test/java/com/williamcallahan/javachat/web/GuidedSseCitationEventTest.java
+++ b/src/test/java/com/williamcallahan/javachat/web/GuidedSseCitationEventTest.java
@@ -75,8 +75,8 @@ void guidedStreamEmitsCitationEvent() throws Exception {
         given(openAIStreamingService.isAvailable()).willReturn(true);
         given(chatMemoryService.getHistory(anyString())).willReturn(List.of());
         given(openAIStreamingService.streamResponse(any(StructuredPrompt.class), anyDouble()))
-                .willReturn(Mono.just(
-                        new StreamingResult(Flux.just("Hello"), RateLimitService.ApiProvider.OPENAI, Flux.empty())));
+                .willReturn(Mono.just(new StreamingResult(
+                        Flux.just("Hello"), RateLimitService.ApiProvider.OPENAI, Flux.empty(), Flux.empty())));
         given(guidedLearningService.buildStructuredGuidedPromptWithContext(anyList(), anyString(), anyString()))
                 .willReturn(new GuidedLearningService.GuidedChatPromptOutcome(
                         StructuredPrompt.fromRawPrompt("test", 1), List.of()));
diff --git a/src/test/java/com/williamcallahan/javachat/web/StreamingProviderFallbackSseEventTest.java b/src/test/java/com/williamcallahan/javachat/web/StreamingProviderFallbackSseEventTest.java
new file mode 100644
index 00000000..bc951986
--- /dev/null
+++ b/src/test/java/com/williamcallahan/javachat/web/StreamingProviderFallbackSseEventTest.java
@@ -0,0 +1,187 @@
+package com.williamcallahan.javachat.web;
+
+import static com.williamcallahan.javachat.web.SseConstants.STATUS_CODE_STREAM_PROVIDER_FALLBACK;
+import static com.williamcallahan.javachat.web.SseConstants.STATUS_STAGE_STREAM;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyDouble;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.csrf;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.asyncDispatch;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.request;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+import com.williamcallahan.javachat.config.AppProperties;
+import com.williamcallahan.javachat.config.ModelConfiguration;
+import com.williamcallahan.javachat.config.WebMvcConfig;
+import com.williamcallahan.javachat.domain.prompt.StructuredPrompt;
+import com.williamcallahan.javachat.service.ChatMemoryService;
+import com.williamcallahan.javachat.service.ChatService;
+import com.williamcallahan.javachat.service.GuidedLearningService;
+import com.williamcallahan.javachat.service.MarkdownService;
+import com.williamcallahan.javachat.service.OpenAIStreamingService;
+import com.williamcallahan.javachat.service.RateLimitService;
+import com.williamcallahan.javachat.service.RetrievalService;
+import com.williamcallahan.javachat.service.StreamingNotice;
+import com.williamcallahan.javachat.service.StreamingResult;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
+import org.springframework.context.annotation.Import;
+import org.springframework.http.MediaType;
+import org.springframework.test.context.bean.override.mockito.MockitoBean;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.MvcResult;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+/** Verifies both chat SSE endpoints publish the provider selected after a pre-text fallback. */
+@WebMvcTest(controllers = {ChatController.class, GuidedLearningController.class})
+@Import({AppProperties.class, WebMvcConfig.class, SseSupport.class})
+@org.springframework.security.test.context.support.WithMockUser
+class StreamingProviderFallbackSseEventTest {
+    private static final String CHAT_SESSION_ID = "chat-provider-fallback";
+    private static final String GUIDED_SESSION_ID = "guided-provider-fallback";
+    private static final String LESSON_SLUG = "sealed-classes";
+    private static final String USER_QUERY = "explain provider fallback";
+    private static final String FALLBACK_RESPONSE_TEXT = "fallback provider response";
+    private static final String INITIAL_PROVIDER_NAME = "github_models";
+    private static final String FALLBACK_PROVIDER_NAME = "openai";
+
+    @Autowired
+    MockMvc mockMvc;
+
+    @MockitoBean
+    ChatService chatService;
+
+    @MockitoBean
+    ChatMemoryService chatMemoryService;
+
+    @MockitoBean
+    GuidedLearningService guidedLearningService;
+
+    @MockitoBean
+    MarkdownService markdownService;
+
+    @MockitoBean
+    OpenAIStreamingService openAIStreamingService;
+
+    @MockitoBean
+    RetrievalService retrievalService;
+
+    @MockitoBean
+    ExceptionResponseBuilder exceptionResponseBuilder;
+
+    @Test
+    void chatStreamPublishesFallbackProviderAndNoticeBeforeFallbackText() throws Exception {
+        given(chatMemoryService.getHistory(CHAT_SESSION_ID)).willReturn(List.of());
+        given(chatService.buildStructuredPromptWithContextOutcome(
+                        anyList(), eq(USER_QUERY), eq(ModelConfiguration.DEFAULT_MODEL)))
+                .willReturn(new ChatService.StructuredPromptOutcome(
+                        StructuredPrompt.fromRawPrompt("test", 1), List.of(), List.of()));
+        given(retrievalService.toCitations(anyList())).willReturn(new RetrievalService.CitationOutcome(List.of(), 0));
+        given(openAIStreamingService.isAvailable()).willReturn(true);
+        StreamingResult providerFallbackStreamingResult = providerFallbackStreamingResult();
+        given(openAIStreamingService.streamResponse(any(StructuredPrompt.class), anyDouble()))
+                .willReturn(Mono.just(providerFallbackStreamingResult));
+
+        String serializedSseStream = serializeSseResponse(
+                "/api/chat/stream", "{\"sessionId\":\"" + CHAT_SESSION_ID + "\",\"message\":\"" + USER_QUERY + "\"}");
+
+        assertFallbackProviderProtocol(serializedSseStream);
+    }
+
+    @Test
+    void guidedStreamPublishesFallbackProviderAndNoticeBeforeFallbackText() throws Exception {
+        given(chatMemoryService.getHistory(GUIDED_SESSION_ID)).willReturn(List.of());
+        given(guidedLearningService.buildStructuredGuidedPromptWithContext(anyList(), eq(LESSON_SLUG), eq(USER_QUERY)))
+                .willReturn(new GuidedLearningService.GuidedChatPromptOutcome(
+                        StructuredPrompt.fromRawPrompt("test", 1), List.of()));
+        given(guidedLearningService.citationsForBookDocuments(anyList())).willReturn(List.of());
+        given(openAIStreamingService.isAvailable()).willReturn(true);
+        StreamingResult providerFallbackStreamingResult = providerFallbackStreamingResult();
+        given(openAIStreamingService.streamResponse(any(StructuredPrompt.class), anyDouble()))
+                .willReturn(Mono.just(providerFallbackStreamingResult));
+
+        String serializedSseStream = serializeSseResponse(
+                "/api/guided/stream",
+                "{\"sessionId\":\"" + GUIDED_SESSION_ID + "\",\"slug\":\"" + LESSON_SLUG + "\",\"latest\":\""
+                        + USER_QUERY + "\"}");
+
+        assertFallbackProviderProtocol(serializedSseStream);
+    }
+
+    private StreamingResult providerFallbackStreamingResult() {
+        StreamingNotice fallbackNotice = mock(StreamingNotice.class);
+        given(fallbackNotice.summary()).willReturn("Retrying stream with provider");
+        given(fallbackNotice.diagnosticContext()).willReturn("Retrying before response text was emitted.");
+        given(fallbackNotice.code()).willReturn(STATUS_CODE_STREAM_PROVIDER_FALLBACK);
+        given(fallbackNotice.retryable()).willReturn(true);
+        given(fallbackNotice.provider()).willReturn(FALLBACK_PROVIDER_NAME);
+        given(fallbackNotice.stage()).willReturn(STATUS_STAGE_STREAM);
+        given(fallbackNotice.attempt()).willReturn(2);
+        given(fallbackNotice.maxAttempts()).willReturn(2);
+
+        return new StreamingResult(
+                Flux.just(FALLBACK_RESPONSE_TEXT),
+                RateLimitService.ApiProvider.GITHUB_MODELS,
+                Flux.just(RateLimitService.ApiProvider.OPENAI),
+                Flux.just(fallbackNotice));
+    }
+
+    private String serializeSseResponse(String endpoint, String requestJson) throws Exception {
+        MvcResult asynchronousStream = mockMvc.perform(post(endpoint)
+                        .with(csrf())
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(requestJson))
+                .andExpect(request().asyncStarted())
+                .andReturn();
+
+        return mockMvc.perform(asyncDispatch(asynchronousStream))
+                .andExpect(status().isOk())
+                .andReturn()
+                .getResponse()
+                .getContentAsString();
+    }
+
+    private static void assertFallbackProviderProtocol(String serializedSseStream) {
+        int initialProviderEventPosition = providerEventPosition(serializedSseStream, INITIAL_PROVIDER_NAME);
+        int fallbackProviderEventPosition = providerEventPosition(serializedSseStream, FALLBACK_PROVIDER_NAME);
+        int fallbackNoticePosition =
+                serializedSseStream.indexOf("\"code\":\"" + STATUS_CODE_STREAM_PROVIDER_FALLBACK + "\"");
+        int fallbackTextPosition = serializedSseStream.indexOf("\"text\":\"" + FALLBACK_RESPONSE_TEXT + "\"");
+
+        assertTrue(
+                initialProviderEventPosition >= 0,
+                "Initial provider event is missing. Payload was:\n" + serializedSseStream);
+        assertTrue(
+                fallbackProviderEventPosition >= 0,
+                "Fallback provider event is missing. Payload was:\n" + serializedSseStream);
+        assertTrue(fallbackNoticePosition >= 0, "Fallback notice is missing. Payload was:\n" + serializedSseStream);
+        assertTrue(fallbackTextPosition >= 0, "Fallback text event is missing. Payload was:\n" + serializedSseStream);
+        assertTrue(
+                initialProviderEventPosition < fallbackProviderEventPosition,
+                "Initial provider must precede fallback provider. Payload was:\n" + serializedSseStream);
+        assertTrue(
+                fallbackProviderEventPosition < fallbackTextPosition,
+                "Fallback provider must precede fallback text. Payload was:\n" + serializedSseStream);
+        assertTrue(
+                fallbackNoticePosition < fallbackTextPosition,
+                "Fallback notice must precede fallback text. Payload was:\n" + serializedSseStream);
+    }
+
+    private static int providerEventPosition(String serializedSseStream, String providerName) {
+        String compactProviderEvent = "event:provider\ndata:{\"provider\":\"" + providerName + "\"}";
+        int compactEventPosition = serializedSseStream.indexOf(compactProviderEvent);
+        if (compactEventPosition >= 0) {
+            return compactEventPosition;
+        }
+        String spacedProviderEvent = "event: provider\ndata: {\"provider\":\"" + providerName + "\"}";
+        return serializedSseStream.indexOf(spacedProviderEvent);
+    }
+}