fix(slack): Harden streamed continuation edges

Keep streamed Slack replies stable when code fences hit the continuation boundary.

Reserve enough room for the streamed continuation suffix up front and avoid
skipping normalization when the non-streamed path falls back to raw reply text.
Add regression coverage for the boundary fence case and whitespace fallback.

Co-Authored-By: Codex GPT-5.4 <noreply@openai.com>

Author: dcramer

packages/junior/src/chat/runtime/reply-executor.ts

@@ -14,8 +14,8 @@ import {
 } from "@/chat/logging";
 import {
   buildSlackOutputMessage,
-  getSlackContinuationBudget,
   getSlackInterruptionMarker,
+  getSlackStreamingContinuationBudget,
   splitSlackReplyText,
   takeSlackContinuationPrefix,
 } from "@/chat/slack/output";
@@ -291,7 +291,7 @@ export function createReplyToThread(deps: ReplyExecutorDeps) {
         let overflowText = "";
         let streamOverflowed = false;
         let beforeFirstResponsePostCalled = false;
-        const continuationBudget = getSlackContinuationBudget();
+        const continuationBudget = getSlackStreamingContinuationBudget();
         const normalizeStreamDelta = createSlackStreamDeltaNormalizer();
         const beforeFirstResponsePost = async (): Promise<void> => {
           if (beforeFirstResponsePostCalled) {
@@ -556,8 +556,10 @@ export function createReplyToThread(deps: ReplyExecutorDeps) {
           // completed after the visible reply has been accepted by Slack.
           if (shouldPostThreadReply) {
             if (!streamedReplyPromise) {
-              const postChunks =
-                replyTextChunks.length > 0 ? replyTextChunks : [reply.text];
+              const hasNormalizedPostChunks = replyTextChunks.length > 0;
+              const postChunks = hasNormalizedPostChunks
+                ? replyTextChunks
+                : [reply.text];
               let sent: SentMessage | undefined;
               for (const [index, chunk] of postChunks.entries()) {
                 sent = await postThreadReply(
@@ -566,7 +568,7 @@ export function createReplyToThread(deps: ReplyExecutorDeps) {
                     index === 0 && resolvedAttachFiles === "inline"
                       ? replyFiles
                       : undefined,
-                    { normalized: true },
+                    { normalized: hasNormalizedPostChunks },
                   ),
                   index === 0 ? "thread_reply" : "thread_reply_continuation",
                 );

packages/junior/src/chat/slack/output.ts

@@ -5,6 +5,7 @@ const MAX_INLINE_CHARS = 2200;
 const MAX_INLINE_LINES = 45;
 const CONTINUED_MARKER = "\n\n[Continued below]";
 const INTERRUPTED_MARKER = "\n\n[Response interrupted before completion]";
+const STREAMING_FENCE_CLOSE_GUARD = "\n```";
 
 /** Insert blank lines between content blocks so Slack renders them with visual separation. */
 export function ensureBlockSpacing(text: string): string {
@@ -372,6 +373,19 @@ export function getSlackContinuationBudget(): {
   return reserveInlineBudgetForSuffix(CONTINUED_MARKER);
 }
 
+/**
+ * Reserve enough inline budget for streamed continuations, including the
+ * close fence we may need to append once overflow is detected mid-code block.
+ */
+export function getSlackStreamingContinuationBudget(): {
+  maxChars: number;
+  maxLines: number;
+} {
+  return reserveInlineBudgetForSuffix(
+    `${STREAMING_FENCE_CLOSE_GUARD}${CONTINUED_MARKER}`,
+  );
+}
+
 /** Normalize text for Slack and wrap it as a PostableMessage with optional file attachments. */
 export function buildSlackOutputMessage(
   text: string,

packages/junior/tests/integration/slack/streaming-reply-behavior.test.ts

@@ -3,6 +3,7 @@ import { describe, expect, it } from "vitest";
 import {
   getSlackContinuationMarker,
   getSlackInterruptionMarker,
+  slackOutputPolicy,
 } from "@/chat/slack/output";
 import { createTestChatRuntime } from "../../fixtures/chat-runtime";
 import {
@@ -238,6 +239,35 @@ describe("Slack behavior: streaming replies", () => {
     );
   });
 
+  it("normalizes raw non-streamed fallback replies before posting", async () => {
+    const { slackRuntime } = createTestChatRuntime({
+      services: {
+        replyExecutor: {
+          generateAssistantReply: async () => ({
+            text: "\r\n\t  \r\n",
+            diagnostics: makeDiagnostics(),
+          }),
+        },
+      },
+    });
+
+    const thread = createTestThread({ id: "slack:C_STREAM:1700006002.750" });
+    await slackRuntime.handleNewMention(
+      thread,
+      createTestMessage({
+        id: "m-stream-whitespace-fallback",
+        text: "<@U_APP> whitespace",
+        isMention: true,
+        threadId: thread.id,
+      }),
+    );
+
+    expect(thread.postKinds).toEqual(["value"]);
+    expect(toPostedText(thread.posts[0])).toBe(
+      "I couldn't produce a response.",
+    );
+  });
+
   it("keeps trailing ack-like text once streaming has started", async () => {
     const { slackRuntime } = createTestChatRuntime({
       services: {
@@ -398,6 +428,53 @@ describe("Slack behavior: streaming replies", () => {
     expect(toPostedText(thread.posts[1])).toMatch(/^```ts\nconst value/);
   });
 
+  it("does not garble streamed fence continuations near the budget boundary", async () => {
+    const firstDelta =
+      "```\n" +
+      "a".repeat(
+        slackOutputPolicy.maxInlineChars -
+          getSlackContinuationMarker().length -
+          1 -
+          "```\n".length,
+      );
+    const tail = "bcdef\n```";
+    const fullReply = `${firstDelta}${tail}`;
+    const { slackRuntime } = createTestChatRuntime({
+      services: {
+        replyExecutor: {
+          generateAssistantReply: async (_prompt, context) => {
+            await context?.onTextDelta?.(firstDelta);
+            await context?.onTextDelta?.(tail);
+            return {
+              text: fullReply,
+              diagnostics: makeDiagnostics(),
+            };
+          },
+        },
+      },
+    });
+
+    const thread = createTestThread({ id: "slack:C_STREAM:1700006005.750" });
+    await slackRuntime.handleNewMention(
+      thread,
+      createTestMessage({
+        id: "m-stream-6-code-boundary",
+        text: "<@U_APP> show edge code",
+        isMention: true,
+        threadId: thread.id,
+      }),
+    );
+
+    expect(thread.postKinds).toEqual(["stream", "value"]);
+    const firstPost = String(thread.posts[0]);
+    const secondPost = toPostedText(thread.posts[1]);
+    const continuationSuffix = `\n\`\`\`${getSlackContinuationMarker()}`;
+
+    expect(firstPost.endsWith(continuationSuffix)).toBe(true);
+    expect(secondPost.startsWith("```\n")).toBe(true);
+    expect(secondPost).toContain("bcdef\n```");
+  });
+
   it("posts an interruption notice when a streamed reply ends in provider error", async () => {
     const { slackRuntime } = createTestChatRuntime({
       services: {