@frockbot/plugin-shell 0.3.11 → 0.3.13

package/src/client/index.ts

@@ -1,7 +1,10 @@
 /// <reference path="../env.d.ts" />
 
 import {
+  clientFailureDetailV1,
   decodeExternalAuthorizationUrl,
+  presentClientFailureV1,
+  serverRefusalMessageV1,
   type AgentTransport,
   type ClientAnnouncement,
   type ClientNotificationIntent,
@@ -11,6 +14,8 @@ import {
   type ClientTurnEvent,
 } from "@frockbot/client-core";
 import { clientSurfaceRegistryKey } from "@frockbot/client-core";
+import { COMPACTED_ANNOUNCEMENT_TEXT_V1 } from "../compaction.js";
+import { readViewerFocusV1, shouldNotifyForBotV1 } from "../focus.js";
 // Connection mutations use the provider-neutral hosted command contract.
 import type {
   ConnectionCommandReceiptV1,
@@ -53,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,
@@ -86,6 +92,7 @@ import {
   type WebTaskChip,
   type WebToolActivity,
 } from "../shared.js";
+import { TranscriptCache } from "./transcript-cache.js";
 import FrockBotApp from "./FrockBotApp.vue";
 import PackageEntryTrigger from "./PackageEntryTrigger.vue";
 import PackageIframeSettings from "./PackageIframeSettings.vue";
@@ -251,6 +258,11 @@ function activeRunView(run: ClientRun): WebActiveRun | undefined {
     return {
       runId: run.runId,
       status: run.status,
+      // Never the backend's own sentence. What arrived here read
+      // `Model request "1c7dd68e-…" has no durable provider outcome:` — a
+      // UUID and two internal nouns, in the one place a User is told what
+      // happened to their reply. The raw text stays on the run for the
+      // console; the banner says what it means and offers the one action.
       message: run.stopRequestedAt
         ? "Stopping…"
         : "Something went wrong mid-reply. Try again to pick it up.",
@@ -282,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 "";
@@ -304,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,
@@ -321,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),
     };
   }
@@ -345,10 +400,18 @@ function assistantMessage(
       id: `${run.runId}:assistant`,
       runId: run.runId,
       role: "assistant",
-      text: "This reply stopped partway. Try again to continue it.",
+      /*
+       * A failure is not something the Bot said. The bubble holds the text
+       * the model actually produced — often none — and the notice under it
+       * says why the Turn ends there: what arrived here read `Model request
+       * "1c7dd68e-…" has no durable provider outcome`, in a bubble styled
+       * exactly like the Bot speaking.
+       */
+      text: visibleAssistantText(run),
+      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),
     };
   }
@@ -361,7 +424,7 @@ function assistantMessage(
       notice: "You stopped this.",
       status: "aborted",
       tools: toolsFrom(run.events),
-      sends: sendsFrom(run.events),
+      sends: [],
       tasks: tasksFrom(run.events),
     };
   }
@@ -375,10 +438,18 @@ function assistantMessage(
       runId: run.runId,
       role: "assistant",
       text: run.responseText,
-      notice: run.failure ?? "Agent request failed.",
+      // 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),
     };
   }
@@ -388,11 +459,16 @@ function assistantMessage(
     role: "assistant",
     text:
       run.status === "failed"
-        ? "This Bot couldn't finish its reply. Try again."
+        ? visibleAssistantText(run)
         : visibleAssistantText(run, notification?.body ?? ""),
+    // 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: knownFailureCopyV1(run.failure) }
+      : {}),
     status: run.status === "failed" ? "error" : "completed",
     tools: toolsFrom(run.events),
-    sends: sendsFrom(run.events),
+    sends: [],
     tasks: tasksFrom(run.events),
   };
 }
@@ -411,7 +487,10 @@ export function projectAnnouncements(
       id: announcement.announcementId,
       runId: announcement.announcementId,
       role: "system",
-      text: `Renamed to ${announcement.to} by ${announcement.namedBy}`,
+      text:
+        announcement.type === "conversation/compacted"
+          ? COMPACTED_ANNOUNCEMENT_TEXT_V1
+          : `Renamed to ${announcement.to} by ${announcement.namedBy}`,
       at: announcement.at,
       status: "completed",
       tools: [],
@@ -420,9 +499,32 @@ export function projectAnnouncements(
     const index = messages.findIndex(
       (candidate) => candidate.id === announcement.announcementId,
     );
-    if (index >= 0) messages[index] = message;
-    else messages.push(message);
+    // Removed before it is placed, so a marker that already sits in the thread
+    // is re-seated rather than frozen wherever the first poll put it.
+    if (index >= 0) messages.splice(index, 1);
+    messages.splice(announcementIndex(messages, message.at ?? ""), 0, message);
+  }
+}
+
+/**
+ * Where a system line belongs among the Turns.
+ *
+ * Only the user message of a Turn carries a timestamp; everything the Bot
+ * wrote for that Turn follows it untimed. So an untimed message inherits the
+ * last timestamp seen, and the line is placed before the first message that is
+ * genuinely later than it. A marker for a range that has scrolled out of the
+ * transcript sorts before everything, which puts it at the top of what remains.
+ */
+function announcementIndex(
+  messages: readonly WebChatMessage[],
+  at: string,
+): number {
+  let seen = "";
+  for (const [index, candidate] of messages.entries()) {
+    if (candidate.at) seen = candidate.at;
+    if (seen > at) return index;
   }
+  return messages.length;
 }
 
 export function projectDurableRuns(
@@ -467,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") {
@@ -885,6 +983,26 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
    * epoch is bumped at the boundary so those answers are dropped.
    */
   let conversationGeneration = 0;
+  /*
+   * The conversations this client is still holding.
+   *
+   * Switching Bots used to be a blank thread and a read; the last few are now
+   * redrawn from memory and read back behind the paint. `transcriptEpochs`
+   * names the conversation each entry belongs to: the backend does not tell a
+   * client its Session id, but the client is the one that ends a conversation,
+   * so counting that action locally is the same boundary (ADR 0027).
+   */
+  const transcripts = new TranscriptCache();
+  const transcriptEpochs = new Map<string, number>();
+  const conversationKeyFor = (botId: string): string =>
+    `${botId}#${transcriptEpochs.get(botId) ?? 0}`;
+  /*
+   * The Bot whose first channel reset is already answered by the cache. A
+   * socket opening emits an untopiced invalidation meaning "read everything";
+   * for a transcript restored moments ago that read is the reload the User
+   * asked us to stop doing. A real `runs` notice is never suppressed.
+   */
+  let restoredWithoutRead: string | undefined;
   let userSettingsGeneration = 0;
   let pluginCatalogGeneration = 0;
   let packageCatalogGeneration = 0;
@@ -1028,11 +1146,10 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
         if (isTerminalRun(run)) return "admitted";
       } catch (error) {
         if (signal.aborted) return "detached";
-        reconciliationError = `${
-          error instanceof Error
-            ? error.message
-            : "Couldn't check on your message."
-        } Retrying…`;
+        reconciliationError = `${presentClientFailureV1(
+          error,
+          "check on your message",
+        )} Retrying…`;
         web.value.settingsError = reconciliationError;
       }
       const delayMs = uncertainAdmissionDelayMsV1(attempt);
@@ -1084,9 +1201,10 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
         if (isTerminalRun(run)) return;
       } catch (error) {
         if (signal.aborted) return;
-        observationError = `${
-          error instanceof Error ? error.message : "Couldn't load that reply."
-        } Retrying…`;
+        observationError = `${presentClientFailureV1(
+          error,
+          "load that reply",
+        )} Retrying…`;
         web.value.settingsError = observationError;
       }
       await waitForRunLookup(delayMs, signal);
@@ -1141,7 +1259,13 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
         web.value.settingsError = "A completed Bot result is waiting to load";
         continue;
       }
-      if (document.hidden) {
+      // The open Bot is only *read* while the tab is visible and the window
+      // holds focus; `document.hidden` alone called a visible tab behind
+      // another window "open", and the reply that landed there was never
+      // heard about. One definition, shared with the sidebar's badge.
+      if (
+        shouldNotifyForBotV1(readViewerFocusV1(web.value.activeBotId), botId)
+      ) {
         // One seam: the desktop or mobile notifications Package when the shell
         // exposes it, the web API when it does not.
         const delivery = await showClientNotificationV1({
@@ -1295,6 +1419,16 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
     connectionsAvailable: ctx.transport.connectionsAvailable !== false,
     activeBotId: undefined,
     composerContext: undefined,
+    transcripts: {
+      rememberViewport: (botId, viewport) =>
+        transcripts.rememberViewport(botId, viewport),
+      viewportFor: (botId) => transcripts.viewportFor(botId),
+      forget: (botId) => {
+        transcripts.forget(botId);
+        if (botId === undefined || botId === restoredWithoutRead)
+          restoredWithoutRead = undefined;
+      },
+    },
     messages: [],
     pluginCatalog: [],
     packageCatalog: [],
@@ -1326,14 +1460,33 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
       admissionObserver?.abort();
       runObserver?.abort();
       selectionGeneration += 1;
+      // The conversation being left is kept, so coming back to it is a paint
+      // and not a reload. The thread writes its scroll position onto this
+      // entry once Vue has flushed, while the DOM still holds it.
+      const leaving = web.value.activeBotId;
+      if (leaving) {
+        transcripts.save(leaving, {
+          conversationKey: conversationKeyFor(leaving),
+          messages: web.value.messages.map((message) => toRaw(message)),
+          ...(web.value.activeRun ? { activeRun: web.value.activeRun } : {}),
+          ...(web.value.activeRunId
+            ? { activeRunId: web.value.activeRunId }
+            : {}),
+          ...(web.value.runningRunId
+            ? { runningRunId: web.value.runningRunId }
+            : {}),
+        });
+      }
+      const restored = transcripts.take(botId, conversationKeyFor(botId));
+      restoredWithoutRead = restored && !restored.stale ? botId : undefined;
       web.value.activeBotId = botId;
       web.value.composerContext = botId;
       web.value.botSettings = undefined;
       web.value.modelReady = false;
-      web.value.messages = [];
-      web.value.activeRun = undefined;
-      web.value.activeRunId = undefined;
-      web.value.runningRunId = undefined;
+      web.value.messages = restored?.messages ?? [];
+      web.value.activeRun = restored?.activeRun;
+      web.value.activeRunId = restored?.activeRunId;
+      web.value.runningRunId = restored?.runningRunId;
       web.value.skillCatalog = [];
       web.value.approvals = [];
       web.value.tasks = [];
@@ -1380,6 +1533,11 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
       // Reads already in flight answer with the conversation that just ended;
       // the epoch drops them instead of letting them redraw it.
       conversationGeneration += 1;
+      // The conversation just ended keeps none of this Bot's cache: its key
+      // moves with it, and the transcript behind it is not this one.
+      transcriptEpochs.set(botId, (transcriptEpochs.get(botId) ?? 0) + 1);
+      transcripts.forget(botId);
+      restoredWithoutRead = undefined;
       runObserver?.abort();
       runObserver = undefined;
       web.value.messages = [];
@@ -1793,8 +1951,9 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
           return;
         updateSettingsLoadError(
           "bot",
-          error instanceof Error ? error.message : "Could not load settings",
+          presentClientFailureV1(error, "load this Bot's settings"),
         );
+        console.debug("bot settings load failed", clientFailureDetailV1(error));
       }
     },
     async saveBotProfile(profile: BotProfile): Promise<void> {
@@ -1909,7 +2068,11 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
         if (generation !== userSettingsGeneration) return;
         updateSettingsLoadError(
           "user",
-          error instanceof Error ? error.message : "Could not load settings",
+          presentClientFailureV1(error, "load your settings"),
+        );
+        console.debug(
+          "user settings load failed",
+          clientFailureDetailV1(error),
         );
       }
     },
@@ -1971,7 +2134,11 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
         if (catalogGeneration !== pluginCatalogGeneration) return;
         updateSettingsLoadError(
           "catalog",
-          error instanceof Error ? error.message : "Could not load Plugins",
+          presentClientFailureV1(error, "load your plugins"),
+        );
+        console.debug(
+          "plugin catalog load failed",
+          clientFailureDetailV1(error),
         );
       }
     },
@@ -2088,18 +2255,21 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
         // fault, and the raw server sentence means nothing to a person — so it
         // is translated here and the surface renders it instead of the
         // "nothing matched your search" empty state.
-        const raw =
-          error instanceof Error ? error.message : "Could not load the Catalog";
+        // The one server sentence worth reading is the one that says there is
+        // nothing to read: everything else becomes the shared failure line,
+        // because a raw fault text means nothing to the person looking at it.
+        const detail = clientFailureDetailV1(error);
         web.value.packageCatalog = [];
         web.value.packageCatalogGeneration = undefined;
         updateSettingsLoadError(
           "package-catalog",
           /catalog generation was not found|Package Catalog is not configured/.test(
-            raw,
+            detail,
           )
             ? "No plugins are published for this deployment yet."
-            : `Plugins could not be loaded: ${raw}`,
+            : presentClientFailureV1(error, "load the plugin catalog"),
         );
+        console.debug("package catalog load failed", detail);
       }
     },
     async loadCatalogEntry(
@@ -2512,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) {
@@ -2532,10 +2707,10 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
             generation === selectionGeneration &&
             web.value.activeBotId === botId
           )
-            web.value.settingsError =
-              error instanceof Error
-                ? error.message
-                : "Notification delivery failed";
+            web.value.settingsError = presentClientFailureV1(
+              error,
+              "show this Bot's notification",
+            );
         }
         return { accepted: true, runId: result.runId };
       } catch (error) {
@@ -2562,10 +2737,12 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
         // draft back rather than the thread pretending it was sent.
         if (isCertainSendRefusalV1(error)) {
           removeMessages(web.value.messages, pendingRunId);
+          // A refusal's own sentence is the one the person needs — the send
+          // that was over the size limit is answered with the limit. Only a
+          // refusal carries one; anything else falls back to the shared line.
           const refusal =
-            error instanceof Error && error.message
-              ? error.message
-              : "That message didn't go through. Try sending it again.";
+            serverRefusalMessageV1(error) ??
+            presentClientFailureV1(error, "send that message");
           web.value.error = refusal;
           return { accepted: false, error: refusal };
         }
@@ -2581,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 {
@@ -2616,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
@@ -2638,22 +2829,35 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
           return { accepted: false, error: UNREACHABLE_BOT_MESSAGE_V1 };
         }
         if (disposition === "not-admitted") {
-          replaceMessage(web.value.messages, pendingRunId, {
-            id: `${pendingRunId}:assistant`,
-            runId: pendingRunId,
-            role: "assistant",
-            text: "Your message didn't go through. Try sending it again.",
-            at: placeholderAt,
-            status: "error",
-            tools: [],
-            sends: [],
-          });
-          web.value.error =
+          // One affordance, not two. This used to be an assistant bubble
+          // *and* a banner, both reading "Turn was not admitted." — the Bot
+          // appearing to say a word the product does not use to a User whose
+          // typing had already been thrown away. The draft comes back to the
+          // composer (`FrockBotApp.sendMessage`), so sending again is the
+          // retry, and one system line says so.
+          const notAdmitted =
             "Your message didn't go through. Try sending it again.";
-          return {
-            accepted: false,
-            error: "Your message didn't go through. Try sending it again.",
-          };
+          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 };
       } finally {
@@ -2691,16 +2895,18 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
       try {
         await ctx.transport.reconcileRun(botId, runId);
       } catch (error) {
-        web.value.settingsError =
-          error instanceof Error ? error.message : "Couldn't retry that.";
+        web.value.settingsError = presentClientFailureV1(
+          error,
+          "pick that reply back up",
+        );
       }
       try {
         await deliverNotifications(botId);
       } catch (error) {
-        web.value.settingsError =
-          error instanceof Error
-            ? error.message
-            : "Couldn't refresh this reply.";
+        web.value.settingsError = presentClientFailureV1(
+          error,
+          "refresh that reply",
+        );
       }
     },
     async stopRun(): Promise<void> {
@@ -2873,6 +3079,14 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
             web.value.activeBotId !== botId
           )
             return;
+          // An untopiced reset on a transcript this switch restored from
+          // memory is the reload the cache exists to avoid. It is answered
+          // once and only once: the next reset reads like any other.
+          if (topic === undefined && restoredWithoutRead === botId) {
+            restoredWithoutRead = undefined;
+            return;
+          }
+          restoredWithoutRead = undefined;
           await deliverNotifications(botId, generation);
         },
         status() {
@@ -2937,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. */