@frockbot/plugin-shell 0.3.12 → 0.3.13

package/src/client/index.test.ts

@@ -1526,16 +1526,95 @@ describe("active durable Turn projection", () => {
       ],
     );
 
-    expect(state.messages[1]?.sends).toEqual([
+    // One message per send, in the order they were sent, and nothing merged:
+    // the last line is the Turn's own, and it carries no send at all.
+    expect(
+      state.messages.slice(1).map((message) => [message.id, message.sends]),
+    ).toEqual([
+      [
+        "run-send:send:0",
+        [{ kind: "payload", payload: { type: "text", text: "On it." } }],
+      ],
+      [
+        "run-send:send:1",
+        [
+          {
+            kind: "payload",
+            payload: {
+              type: "widget",
+              widget: { prompt: "Which day?", options: ["Tue"] },
+            },
+          },
+        ],
+      ],
+      ["run-send:send:2", [{ kind: "unsupported" }]],
+      ["run-send:assistant", []],
+    ]);
+  });
+
+  test("a second send is a new bubble, and never rewrites the first", () => {
+    const state: Pick<
+      FrockBotWebData,
+      "messages" | "activeRunId" | "activeRun"
+    > = { messages: [] };
+    const run = (
+      events: ClientRun["events"],
+      status: ClientRun["status"] = "running",
+    ): ClientRun => ({
+      runId: "run-stack",
+      input: "Book it",
+      admittedAt: "2026-09-04T00:00:00.000Z",
+      status,
+      events,
+    });
+
+    // The acknowledgement arrives first, on its own.
+    projectDurableRuns(state, [], [
+      run([
+        { type: "send/to-user", payload: { type: "text", text: "On it." } },
+      ]),
+    ] as ClientRun[]);
+    const acknowledgement = state.messages[1];
+    expect(acknowledgement?.sends).toEqual([
       { kind: "payload", payload: { type: "text", text: "On it." } },
-      {
-        kind: "payload",
-        payload: {
-          type: "widget",
-          widget: { prompt: "Which day?", options: ["Tue"] },
-        },
-      },
-      { kind: "unsupported" },
+    ]);
+
+    // The result follows in the same Turn. It appends: the first bubble is
+    // still the first bubble, still saying what it said.
+    projectDurableRuns(state, [], [
+      run(
+        [
+          {
+            type: "send/to-user",
+            payload: { type: "text", text: "On it." },
+          },
+          { type: "send/to-user", payload: { type: "text", text: "Booked." } },
+        ],
+        "completed",
+      ),
+    ] as ClientRun[]);
+
+    expect(
+      state.messages
+        .filter((message) => message.sends.length > 0)
+        .map((message) => [message.id, message.sends]),
+    ).toEqual([
+      [
+        "run-stack:send:0",
+        [{ kind: "payload", payload: { type: "text", text: "On it." } }],
+      ],
+      [
+        "run-stack:send:1",
+        [{ kind: "payload", payload: { type: "text", text: "Booked." } }],
+      ],
+    ]);
+    // The Turn's lines stay together and in order behind the prompt that
+    // started it, so a reload draws the thread that was watched being written.
+    expect(state.messages.map((message) => message.id)).toEqual([
+      "run-stack:user",
+      "run-stack:send:0",
+      "run-stack:send:1",
+      "run-stack:assistant",
     ]);
   });
 
@@ -1561,8 +1640,8 @@ describe("active durable Turn projection", () => {
       ],
     );
 
-    expect(state.messages[1]?.text).toBe("");
     expect(state.messages[1]?.sends).toHaveLength(1);
+    expect(state.messages[2]?.text).toBe("");
   });
 
   test("a Turn that sent nothing still draws the model's text", () => {
@@ -1712,8 +1791,8 @@ describe("active durable Turn projection", () => {
         },
       ],
     );
-    expect(state.messages[1]).toMatchObject({ text: "", status: "streaming" });
     expect(state.messages[1]?.sends).toHaveLength(1);
+    expect(state.messages[2]).toMatchObject({ text: "", status: "streaming" });
   });
 
   test("projects reconciliation-required recovery state", () => {
@@ -3215,11 +3294,14 @@ describe("a message sent while a Turn is running", () => {
     expect(state.messages.every((message) => !message.pending)).toBe(true);
     expect(state.activeRunId).toBe("run-2");
     expect(state.runningRunId).toBe("run-2");
-    // The superseded Turn keeps the quiet treatment a stopped one gets.
-    expect(state.messages[1]).toMatchObject({
-      status: "aborted",
-      notice: "Interrupted by your next message.",
-    });
+    // The superseded Turn is left unlabelled: the message that replaced it is
+    // right underneath, and it says why the Turn ends there better than a
+    // notice of ours would.
+    expect(state.messages[1]).toMatchObject({ status: "aborted" });
+    expect(state.messages[1]?.notice).toBeUndefined();
+    expect(state.messages.some((message) => message.notice !== undefined)).toBe(
+      false,
+    );
   });
 
   test("a reload reconstructs the greyed state from durable runs alone", () => {
@@ -3254,6 +3336,11 @@ describe("a message sent while a Turn is running", () => {
       text: "second",
       pending: true,
     });
+    // The durable record still says why the Turn ended; the transcript does
+    // not repeat it at the reader.
+    expect(
+      reloaded.messages.some((message) => message.notice !== undefined),
+    ).toBe(false);
     expect(reloaded.runningRunId).toBeUndefined();
     expect(reloaded.activeRunId).toBe("run-2");
   });

package/src/client/index.ts

@@ -58,6 +58,7 @@ import {
 import { MCP_OAUTH_CONNECTION_TYPE_ID } from "@frockbot/plugin-mcp/agent";
 import { decodeStartConnectionResultV1 } from "@frockbot/connection-core";
 import { decodeClientSkillCatalogV1 } from "../skill-protocol.js";
+import { knownFailureCopyV1 } from "../run-failure-copy.js";
 import {
   ClientTurnRefusedErrorV1,
   type ClientTurnRefusalReasonV1,
@@ -293,13 +294,28 @@ function turnRefusalCopyV1(reason: ClientTurnRefusalReasonV1): string {
  * The Bot's voice is its sends. When a Turn delivered anything to the User the
  * model's own assistant text is scratch space and the thread does not draw it
  * (issue 153): drawing both is how a one-word reply arrived twice, once as the
- * model's text and once as the bubble that was actually delivered.
+ * model's text and once as the bubble that was actually delivered — the Turn's
+ * derived text is the last text send when the model wrote no message of its
+ * own (`backend-runner.ts`'s `lastSentTextV1`), so it is literally that copy.
  *
  * A running Turn has no `responseText` yet — that is written only at
  * settlement — so it draws the words it has written so far. They occupy the
- * same bubble the settled answer will, and the same send gate applies to
- * both: a Turn that has already delivered a bubble streams nothing into a
- * second one.
+ * same bubble the settled answer will, and that bubble is the Turn's own line,
+ * which follows the sends rather than replacing any of them.
+ *
+ * The gate is absolute, and it has to be. Relaxing it to "suppress only text
+ * that duplicates a send" looked safer and was not: the model's *last* step
+ * routinely writes something of its own after the step that spoke — the e2e
+ * that pins this sends "pong" through the tool and then answers again in text —
+ * and comparing the two drew both. Two bubbles for one reply is the exact
+ * regression issue 153 named.
+ *
+ * So a Turn that sent anything is drawn entirely from its sends, and text the
+ * model wrote beside them is scratch space. That is what makes the promotion in
+ * `promoteAssistantTextToSendV1` the right shape: an acknowledgement reaches
+ * the person by *becoming* a send — and under the per-send projection it is
+ * then its own bubble, in the order it was journaled — rather than being drawn
+ * as text next to one.
  */
 function visibleAssistantText(run: ClientRun, fallback = ""): string {
   if (sendsFrom(run.events).length > 0) return "";
@@ -315,6 +331,33 @@ function isTerminalRun(run: ClientRun): boolean {
   );
 }
 
+/**
+ * One message per `send_to_user`, in the order the Bot sent them.
+ *
+ * A Turn is not one bubble. The Bot acknowledges, works, and reports back,
+ * and each of those is a message in the conversation exactly as it would be
+ * from a person (issue 153). The order is the durable order of the run's
+ * events, so the thread a reload draws is the thread that was watched being
+ * written, and a bubble is never edited once it is in the transcript: a later
+ * send appends, it does not replace.
+ */
+function sendMessages(run: ClientRun): WebChatMessage[] {
+  return sendsFrom(run.events).map((send, index) => ({
+    id: `${run.runId}:send:${index}`,
+    runId: run.runId,
+    role: "assistant" as const,
+    text: "",
+    status: "completed" as const,
+    tools: [],
+    sends: [send],
+  }));
+}
+
+/**
+ * The Turn's own line: the model's words, why the Turn ended where it did,
+ * the tools it ran and the subagents it dispatched. It closes the run, under
+ * whatever the Turn had already sent.
+ */
 function assistantMessage(
   run: ClientRun,
   notification: ClientNotificationIntent | undefined,
@@ -332,22 +375,23 @@ function assistantMessage(
       // message is the whole of what the thread says about it.
       ...(run.queued ? { pending: true } : {}),
       tools: toolsFrom(run.events),
-      sends: sendsFrom(run.events),
+      sends: [],
       tasks: tasksFrom(run.events),
     };
   }
   if (run.status === "superseded") {
-    // The same quiet treatment a stopped Turn gets. It keeps everything it
-    // already sent; the line only says why it ends where it does.
+    // Quieter than a stopped Turn: it keeps everything it already sent and
+    // carries no notice at all. The message that superseded it is sitting
+    // right underneath, in the person's own words, and it explains the ending
+    // better than a line of ours would (ADR 0024).
     return {
       id: `${run.runId}:assistant`,
       runId: run.runId,
       role: "assistant",
       text: visibleAssistantText(run),
-      notice: "Interrupted by your next message.",
       status: "aborted",
       tools: toolsFrom(run.events),
-      sends: sendsFrom(run.events),
+      sends: [],
       tasks: tasksFrom(run.events),
     };
   }
@@ -367,7 +411,7 @@ function assistantMessage(
       notice: "This reply stopped partway. Try again to continue it.",
       status: "reconciliation-required",
       tools: toolsFrom(run.events),
-      sends: sendsFrom(run.events),
+      sends: [],
       tasks: tasksFrom(run.events),
     };
   }
@@ -380,7 +424,7 @@ function assistantMessage(
       notice: "You stopped this.",
       status: "aborted",
       tools: toolsFrom(run.events),
-      sends: sendsFrom(run.events),
+      sends: [],
       tasks: tasksFrom(run.events),
     };
   }
@@ -394,14 +438,18 @@ function assistantMessage(
       runId: run.runId,
       role: "assistant",
       text: run.responseText,
-      // The same sentence the reply-less failure gets. The durable failure
-      // text is a provider's, not the product's — `Bot turn ended with
-      // outcome model-error`, a status code, once a run UUID — and under a
-      // bubble it reads as part of what the Bot was saying.
-      notice: "This Bot couldn't finish its reply. Try again.",
+      // The durable failure text is a provider's, not the product's — `Bot
+      // turn ended with outcome model-error`, a status code, once a run UUID —
+      // and under a bubble it reads as part of what the Bot was saying. By the
+      // time it reaches here it is already the sentence for a person: the
+      // projection maps it through `runFailureCopyV1` before it crosses the
+      // wire, so this keeps whatever that chose — the model-deadline copy says
+      // something the outcome alone cannot — and falls back to the same line a
+      // reply-less failure gets.
+      notice: knownFailureCopyV1(run.failure),
       status: "error",
       tools: toolsFrom(run.events),
-      sends: sendsFrom(run.events),
+      sends: [],
       tasks: tasksFrom(run.events),
     };
   }
@@ -416,11 +464,11 @@ function assistantMessage(
     // Why the Turn ends there, under whatever it had already said — never as
     // the bubble's own text, which reads as the Bot saying it.
     ...(run.status === "failed"
-      ? { notice: "This Bot couldn't finish its reply. Try again." }
+      ? { notice: knownFailureCopyV1(run.failure) }
       : {}),
     status: run.status === "failed" ? "error" : "completed",
     tools: toolsFrom(run.events),
-    sends: sendsFrom(run.events),
+    sends: [],
     tasks: tasksFrom(run.events),
   };
 }
@@ -521,16 +569,12 @@ export function projectDurableRuns(
     if (userIndex >= 0) state.messages[userIndex] = user;
     else state.messages.push(user);
 
-    const assistantIndex = state.messages.findIndex(
-      (message) => message.runId === run.runId && message.role === "assistant",
+    replaceTurnMessages(
+      state.messages,
+      run.runId,
+      [...sendMessages(run), assistantMessage(run, notification)],
+      run.admittedAt,
     );
-    const assistant = assistantMessage(run, notification);
-    const assistantAt =
-      run.admittedAt ??
-      (assistantIndex >= 0 ? state.messages[assistantIndex]?.at : undefined);
-    if (assistantAt) assistant.at = assistantAt;
-    if (assistantIndex >= 0) state.messages[assistantIndex] = assistant;
-    else state.messages.push(assistant);
 
     activeRun = activeRunView(run) ?? activeRun;
     if (run.status === "running" || run.status === "reconciliation-required") {
@@ -2638,19 +2682,24 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
           message.runId = result.runId;
           message.id = `${result.runId}:${message.role}`;
         }
-        replaceMessage(web.value.messages, result.runId, {
-          id: `${result.runId}:assistant`,
+        // Projected exactly as the durable read projects it, from the same
+        // events: one bubble per send, in order, and the model's own text
+        // after them (issue 153). The POST's copy of a Turn and the transcript
+        // read must draw the same thread, or the reply rearranges itself on
+        // the next reload.
+        const settled: ClientRun = {
           runId: result.runId,
-          role: "assistant",
-          // The same rule the durable projection follows: a Turn that
-          // delivered something speaks through its sends, not through the
-          // model's own text (issue 153).
-          text: sendsFrom(result.events).length > 0 ? "" : result.text,
-          at: optimisticAt,
+          input: text,
           status: "completed",
-          tools: toolsFrom(result.events),
-          sends: sendsFrom(result.events),
-        });
+          responseText: result.text,
+          events: result.events,
+        };
+        replaceTurnMessages(
+          web.value.messages,
+          result.runId,
+          [...sendMessages(settled), assistantMessage(settled, undefined)],
+          optimisticAt,
+        );
         try {
           await deliverNotifications(botId, generation);
         } catch (error) {
@@ -2709,16 +2758,23 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
               message.runId === pendingRunId && message.role === "user",
           )?.at ?? optimisticAt,
         );
-        replaceMessage(web.value.messages, pendingRunId, {
-          id: `${pendingRunId}:assistant`,
-          runId: pendingRunId,
-          role: "assistant",
-          text: "Checking whether your message went through…",
-          at: placeholderAt,
-          status: "interrupted",
-          tools: [],
-          sends: [],
-        });
+        replaceTurnMessages(
+          web.value.messages,
+          pendingRunId,
+          [
+            {
+              id: `${pendingRunId}:assistant`,
+              runId: pendingRunId,
+              role: "assistant",
+              text: "Checking whether your message went through…",
+              at: placeholderAt,
+              status: "interrupted",
+              tools: [],
+              sends: [],
+            },
+          ],
+          placeholderAt,
+        );
         if (aborted) {
           web.value.error = undefined;
         } else {
@@ -2744,17 +2800,24 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
         // have to improvise — and with the Turn no longer running, so Stop
         // stops standing for a Turn nobody is executing.
         if (disposition === "unreachable") {
-          replaceMessage(web.value.messages, pendingRunId, {
-            id: `${pendingRunId}:assistant`,
-            runId: pendingRunId,
-            role: "assistant",
-            text: UNREACHABLE_BOT_MESSAGE_V1,
-            at: placeholderAt,
-            status: "error",
-            retry: "resend",
-            tools: [],
-            sends: [],
-          });
+          replaceTurnMessages(
+            web.value.messages,
+            pendingRunId,
+            [
+              {
+                id: `${pendingRunId}:assistant`,
+                runId: pendingRunId,
+                role: "assistant",
+                text: UNREACHABLE_BOT_MESSAGE_V1,
+                at: placeholderAt,
+                status: "error",
+                retry: "resend",
+                tools: [],
+                sends: [],
+              },
+            ],
+            placeholderAt,
+          );
           // The bubble is the report, and it is the one carrying the Retry.
           // Saying the same sentence again in the banner above it is what the
           // thread already looked like when it was broken — the same string
@@ -2774,19 +2837,26 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
           // retry, and one system line says so.
           const notAdmitted =
             "Your message didn't go through. Try sending it again.";
-          replaceMessage(web.value.messages, pendingRunId, {
-            id: `${pendingRunId}:assistant`,
-            runId: pendingRunId,
-            role: "system",
-            text: notAdmitted,
-            at: placeholderAt,
-            status: "error",
-            // The same affordance an unreachable send gets: the draft is back
-            // in the composer, and this sends it again.
-            retry: "resend",
-            tools: [],
-            sends: [],
-          });
+          replaceTurnMessages(
+            web.value.messages,
+            pendingRunId,
+            [
+              {
+                id: `${pendingRunId}:assistant`,
+                runId: pendingRunId,
+                role: "system",
+                text: notAdmitted,
+                at: placeholderAt,
+                status: "error",
+                // The same affordance an unreachable send gets: the draft is
+                // back in the composer, and this sends it again.
+                retry: "resend",
+                tools: [],
+                sends: [],
+              },
+            ],
+            placeholderAt,
+          );
           return { accepted: false, error: notAdmitted };
         }
         return { accepted: true, runId: pendingRunId };
@@ -3081,15 +3151,46 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
   ];
 };
 
-function replaceMessage(
+/**
+ * Puts a Turn's Bot-side lines in the thread, in order, in one place.
+ *
+ * A Turn is one user message and then however many the Bot sent, so a merge
+ * cannot key one bubble by run id and overwrite it — that is exactly how a
+ * second `send_to_user` used to replace the first. Every Bot-side line the
+ * run already has is lifted out and the new ones go back at the same
+ * position, which keeps the sends in their durable order and keeps the whole
+ * Turn together between the Turn before it and the Turn after it.
+ *
+ * Where a line already carried a timestamp and the caller offers none, the
+ * one it had is kept: the thread sorts by time and a line must not jump.
+ */
+function replaceTurnMessages(
   messages: WebChatMessage[],
   runId: string,
-  replacement: WebChatMessage,
+  replacements: WebChatMessage[],
+  at?: string,
 ): void {
-  const index = messages.findIndex(
-    (message) => message.runId === runId && message.role === "assistant",
-  );
-  if (index >= 0) messages[index] = replacement;
+  let start = -1;
+  let existingAt: string | undefined;
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (!message || message.runId !== runId || message.role !== "assistant")
+      continue;
+    existingAt = message.at ?? existingAt;
+    start = index;
+    messages.splice(index, 1);
+  }
+  if (start < 0) {
+    // No Bot-side line yet: it belongs directly after this Turn's prompt, so
+    // an older Turn's reply can never come between them.
+    const userIndex = messages.findIndex(
+      (message) => message.runId === runId && message.role === "user",
+    );
+    start = userIndex >= 0 ? userIndex + 1 : messages.length;
+  }
+  const stamp = at ?? existingAt;
+  if (stamp) for (const message of replacements) message.at = stamp;
+  messages.splice(start, 0, ...replacements);
 }
 
 /** Takes back both optimistic lines of a send the Bot never admitted. */

package/src/client/styles.css

@@ -360,11 +360,13 @@
  * notices and sends stack inside it, so a one-word reply is a bubble the width
  * of its word rather than a sliver of a shared row.
  *
- * The avatar is not in that column. While the Bot is working it sits on its
- * own row underneath, so the trail streaming off its right has the width of
- * the transcript to run through rather than the gutter beside a bubble. Every
- * reply here is from the same Bot — there are no group conversations — so a
- * sheep on every settled line said nothing and cost the column its left edge.
+ * The avatar is not in that column, and not in the article at all: while the
+ * Bot is working it sits on its own row at the very end of the thread, so the
+ * trail streaming off its right has the width of the transcript to run through
+ * rather than the gutter beside a bubble, and a message sent mid-Turn lands
+ * above it. Every reply here is from the same Bot — there are no group
+ * conversations — so a sheep on every settled line said nothing and cost the
+ * column its left edge.
  */
 .message-assistant {
   flex-direction: column;
@@ -383,11 +385,16 @@
 /*
  * The working row. Its height is the trail's canvas: tall enough for the
  * wobble to be visible, short enough that it reads as one line of the thread.
+ * It is the thread's last child, so it takes the same top margin every message
+ * has and adds no width of its own — the bubbles above never move sideways
+ * when it appears or goes.
  */
 .bot-working {
   display: flex;
+  width: 100%;
   height: 44px;
   align-items: center;
+  margin-top: 6px;
   gap: 0;
 }
 
@@ -461,62 +468,6 @@
   }
 }
 
-@keyframes frock-halo {
-  0%,
-  100% {
-    opacity: 0;
-    transform: scale(0.94);
-  }
-
-  50% {
-    opacity: 1;
-    transform: scale(1.06);
-  }
-}
-
-/*
- * The bubble a Turn has before it has words: three dots that say the Bot is
- * working, where the reply itself will appear.
- */
-.message-working {
-  display: flex;
-  align-items: center;
-  min-height: 20px;
-}
-
-.working-dots {
-  display: inline-flex;
-  gap: 4px;
-}
-
-.working-dots i {
-  width: 6px;
-  height: 6px;
-  border-radius: 50%;
-  background: var(--frock-text-muted);
-  animation: frock-working-dot 1.2s ease-in-out infinite;
-}
-
-.working-dots i:nth-child(2) {
-  animation-delay: 0.15s;
-}
-
-.working-dots i:nth-child(3) {
-  animation-delay: 0.3s;
-}
-
-@keyframes frock-working-dot {
-  0%,
-  60%,
-  100% {
-    opacity: 0.3;
-  }
-
-  30% {
-    opacity: 1;
-  }
-}
-
 /*
  * A bubble runs nearly the width of the transcript, leaving one clear margin
  * on the side it is not anchored to: the Bot's at the end, the User's at the