@frockbot/plugin-shell 0.3.7 → 0.3.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/plugin-shell",
-  "version": "0.3.7",
+  "version": "0.3.8",
   "private": false,
   "type": "module",
   "exports": {
@@ -47,41 +47,41 @@
   },
   "dependencies": {
     "@cordisjs/plugin-webui": "0.8.2",
-    "@frockbot/agent-runtime": "0.3.7",
-    "@frockbot/application-foundation": "0.3.7",
-    "@frockbot/catalog-core": "0.3.7",
-    "@frockbot/client-core": "0.3.7",
-    "@frockbot/client-ui": "0.3.7",
-    "@frockbot/computer-core": "0.3.7",
-    "@frockbot/computer-host-protocol": "0.3.7",
-    "@frockbot/configuration-core": "0.3.7",
-    "@frockbot/connection-core": "0.3.7",
-    "@frockbot/kernel-agent-loop": "0.3.7",
-    "@frockbot/kernel-composition": "0.3.7",
-    "@frockbot/kernel-contracts": "0.3.7",
-    "@frockbot/kernel-do": "0.3.7",
-    "@frockbot/machine-protocol": "0.3.7",
-    "@frockbot/plugin-applets": "0.3.7",
-    "@frockbot/plugin-authoring": "0.3.7",
-    "@frockbot/plugin-bot-template": "0.3.7",
-    "@frockbot/plugin-computer": "0.3.7",
-    "@frockbot/plugin-flock": "0.3.7",
-    "@frockbot/plugin-image": "0.3.7",
-    "@frockbot/plugin-machine-messages": "0.3.7",
-    "@frockbot/plugin-mcp": "0.3.7",
-    "@frockbot/plugin-memory": "0.3.7",
-    "@frockbot/plugin-package-catalog": "0.3.7",
-    "@frockbot/plugin-routines": "0.3.7",
-    "@frockbot/plugin-skills": "0.3.7",
-    "@frockbot/plugin-subagents": "0.3.7",
-    "@frockbot/plugin-user-machine": "0.3.7",
-    "@frockbot/protocol": "0.3.7",
+    "@frockbot/agent-runtime": "0.3.8",
+    "@frockbot/application-foundation": "0.3.8",
+    "@frockbot/catalog-core": "0.3.8",
+    "@frockbot/client-core": "0.3.8",
+    "@frockbot/client-ui": "0.3.8",
+    "@frockbot/computer-core": "0.3.8",
+    "@frockbot/computer-host-protocol": "0.3.8",
+    "@frockbot/configuration-core": "0.3.8",
+    "@frockbot/connection-core": "0.3.8",
+    "@frockbot/kernel-agent-loop": "0.3.8",
+    "@frockbot/kernel-composition": "0.3.8",
+    "@frockbot/kernel-contracts": "0.3.8",
+    "@frockbot/kernel-do": "0.3.8",
+    "@frockbot/machine-protocol": "0.3.8",
+    "@frockbot/plugin-applets": "0.3.8",
+    "@frockbot/plugin-authoring": "0.3.8",
+    "@frockbot/plugin-bot-template": "0.3.8",
+    "@frockbot/plugin-computer": "0.3.8",
+    "@frockbot/plugin-flock": "0.3.8",
+    "@frockbot/plugin-image": "0.3.8",
+    "@frockbot/plugin-machine-messages": "0.3.8",
+    "@frockbot/plugin-mcp": "0.3.8",
+    "@frockbot/plugin-memory": "0.3.8",
+    "@frockbot/plugin-package-catalog": "0.3.8",
+    "@frockbot/plugin-routines": "0.3.8",
+    "@frockbot/plugin-skills": "0.3.8",
+    "@frockbot/plugin-subagents": "0.3.8",
+    "@frockbot/plugin-user-machine": "0.3.8",
+    "@frockbot/protocol": "0.3.8",
     "cordis": "4.0.0-rc.8",
     "vue": "3.5.41"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "latest",
-    "@frockbot/plugin-tools": "0.3.7",
+    "@frockbot/plugin-tools": "0.3.8",
     "@types/bun": "1.3.6",
     "@types/node": "26.2.0",
     "@vitejs/plugin-vue": "6.0.8",

package/src/backend.ts

@@ -437,6 +437,7 @@ import {
   optionalSidebarMessagePreviewV1,
   optionalUnreadStateV1,
   projectBotUnreadViewV1,
+  sidebarMessagePreviewFromRunsV1,
   SIDEBAR_PREVIEW_KEY,
   unreadReceiptKeyV1,
   UNREAD_COUNT_CAP,
@@ -444,6 +445,8 @@ import {
   type BotUnreadCommandV1,
   type BotUnreadReceiptV1,
   type BotUnreadViewV1,
+  type SidebarMessagePreviewV1,
+  type SidebarPreviewRunV1,
 } from "./unread.js";
 import { defineBotBackendContribution } from "@frockbot/kernel-contracts/contributions";
 
@@ -5254,7 +5257,6 @@ export class ShellBotBackendContribution {
         ]),
     );
     const state = optionalUnreadStateV1(storedState);
-    const preview = optionalSidebarMessagePreviewV1(storedPreview);
     const index = await this.authority.listRunIndex({
       limit: UNREAD_COUNT_CAP + 1,
     });
@@ -5262,10 +5264,41 @@ export class ShellBotBackendContribution {
       identity.botId,
       state,
       index.map((entry) => entry.cursor),
-      preview,
+      await this.sidebarPreview(storedPreview, index),
     );
   }
 
+  /**
+   * How many stored runs a read will open to recover a missing preview. The
+   * newest settled chat Turn is almost always the first entry; the bound is
+   * what keeps a Bot whose recent Turns are all automations from turning one
+   * sidebar read into a scan of its whole history.
+   */
+  private static readonly SIDEBAR_PREVIEW_BACKFILL_RUNS_V1 = 5;
+
+  /**
+   * The preview record, or the same line derived from the runs when there is
+   * none. A Bot whose Turns settled before the preview projection existed has
+   * a full transcript and no record, and the row read "No messages yet" over
+   * it. A read never writes what it derives: the next settlement stores it.
+   */
+  private async sidebarPreview(
+    storedPreview: unknown,
+    index: readonly { runId: string }[],
+  ): Promise<SidebarMessagePreviewV1 | undefined> {
+    const stored = optionalSidebarMessagePreviewV1(storedPreview);
+    if (stored) return stored;
+    const runs: SidebarPreviewRunV1[] = [];
+    for (const entry of index.slice(
+      0,
+      ShellBotBackendContribution.SIDEBAR_PREVIEW_BACKFILL_RUNS_V1,
+    )) {
+      const run = await this.authority.readRun(entry.runId);
+      if (run) runs.push(run);
+    }
+    return sidebarMessagePreviewFromRunsV1(runs);
+  }
+
   /**
    * `bot/mark-read` and `bot/mark-unread`. Idempotent on the command id and
    * monotonic in the cursor, so a replay or an out-of-order delivery can only
@@ -5294,9 +5327,7 @@ export class ShellBotBackendContribution {
         }
         return {
           state: optionalUnreadStateV1(existing.state),
-          preview: optionalSidebarMessagePreviewV1(
-            await transaction.get<unknown>(SIDEBAR_PREVIEW_KEY),
-          ),
+          preview: await transaction.get<unknown>(SIDEBAR_PREVIEW_KEY),
         };
       }
       const current = optionalUnreadStateV1(
@@ -5320,9 +5351,7 @@ export class ShellBotBackendContribution {
       });
       return {
         state: next,
-        preview: optionalSidebarMessagePreviewV1(
-          await transaction.get<unknown>(SIDEBAR_PREVIEW_KEY),
-        ),
+        preview: await transaction.get<unknown>(SIDEBAR_PREVIEW_KEY),
       };
     });
     const index = await this.authority.listRunIndex({
@@ -5336,7 +5365,10 @@ export class ShellBotBackendContribution {
         identity.botId,
         stored.state,
         index.map((entry) => entry.cursor),
-        stored.preview,
+        // The open Bot is the one that gets marked read, so this receipt is
+        // the sidebar row it renders from: it owes the same derived preview
+        // the fan-out gives every other Bot.
+        await this.sidebarPreview(stored.preview, index),
       ),
     };
   }

package/src/client/FrockBotApp.vue

@@ -26,6 +26,12 @@ import {
   type WebToolActivity,
 } from "../shared.js";
 import { ComposerDraftStore } from "./composer-draft.js";
+import {
+  TURN_TEXT_MAX_CHARACTERS_V1,
+  turnTextCounterVisibleV1,
+  turnTextRemainingV1,
+  turnTextTooLongV1,
+} from "./turn-limits.js";
 import SendPayloadView from "./SendPayloadView.vue";
 import AppletCanvas from "./AppletCanvas.vue";
 import PackageIframeHost from "./PackageIframeHost.vue";
@@ -305,12 +311,31 @@ const composerPlaceholder = computed(() => {
   if (!state.value.modelReady) return state.value.modelLabel;
   return botName.value ? `Message ${botName.value}` : "Message";
 });
+/*
+ * The send route's size rule, enforced where the person can still do something
+ * about it. Past the limit the server answers 413 and nothing is sent, so the
+ * composer says how much is left before the button closes rather than letting
+ * a long message make the round trip to be refused.
+ */
+const draftText = computed(() => draft.value.trim());
+const draftTooLong = computed(() => turnTextTooLongV1(draftText.value));
+const draftCounterVisible = computed(() =>
+  turnTextCounterVisibleV1(draftText.value),
+);
+const draftCounterLabel = computed(() => {
+  const remaining = turnTextRemainingV1(draftText.value);
+  const count = Math.abs(remaining).toLocaleString("en-US");
+  return remaining < 0
+    ? `${count} characters over the ${TURN_TEXT_MAX_CHARACTERS_V1.toLocaleString("en-US")} limit`
+    : `${count} characters left`;
+});
 const canSend = computed(
   () =>
     state.value.connection === "ready" &&
     state.value.modelReady &&
     Boolean(state.value.activeBotId) &&
-    draft.value.trim().length > 0,
+    draftText.value.length > 0 &&
+    !draftTooLong.value,
 );
 /**
  * Stop takes the button only while there is nothing to send. The moment the
@@ -937,6 +962,20 @@ function handleComposerKeydown(event: KeyboardEvent): void {
                 <p v-if="message.notice" class="message-notice">
                   {{ message.notice }}
                 </p>
+                <!--
+                  The way out of an ending the person cannot otherwise act on:
+                  the client could not reach the Bot, their text is back in the
+                  composer, and this sends it again.
+                -->
+                <button
+                  v-if="message.retry === 'resend'"
+                  type="button"
+                  class="message-retry"
+                  :disabled="!canSend"
+                  @click="sendMessage()"
+                >
+                  Retry
+                </button>
                 <template v-for="tool in message.tools" :key="tool.id">
                   <PackageIframeHost
                     v-for="entry in iframeEntriesFor(tool)"
@@ -1188,6 +1227,19 @@ function handleComposerKeydown(event: KeyboardEvent): void {
               @click="refreshSkillPopover"
               @blur="closeSkillPopover"
             />
+            <!--
+              Silent until the budget is nearly spent, then it says how much is
+              left — and, past the limit, how much has to go before the send
+              button opens again.
+            -->
+            <p
+              v-if="draftCounterVisible"
+              class="composer-counter"
+              :class="{ 'composer-counter-over': draftTooLong }"
+              aria-live="polite"
+            >
+              {{ draftCounterLabel }}
+            </p>
           </div>
           <!--
             Start a new conversation. Sits beside the composer because that is

package/src/client/index.test.ts

@@ -26,6 +26,10 @@ const {
   shellClientPlugin,
 } = await import("./index.js");
 import type { FrockBotWebData } from "../shared.js";
+import {
+  UNCERTAIN_ADMISSION_MAX_ATTEMPTS_V1,
+  UNREACHABLE_BOT_MESSAGE_V1,
+} from "./uncertain-admission.js";
 import type { Ref } from "vue";
 
 const originalLocalStorage = Object.getOwnPropertyDescriptor(
@@ -2152,6 +2156,134 @@ describe("uncertain Turn admission", () => {
     });
   });
 
+  test("refuses a send the server answered 4xx, keeping the draft and the thread clean", async () => {
+    Object.defineProperty(globalThis, "window", {
+      configurable: true,
+      value: { location: { href: "https://app.example/?bot=primary" } },
+    });
+    let provided: Ref<FrockBotWebData> | undefined;
+    let lookups = 0;
+    const tooLong =
+      "Your message is too long. Keep it under 32,000 characters.";
+    await shellClientPlugin({
+      transport: {
+        // What the transport throws for a 413: the answer was read, so the
+        // status rides on the error beside the sentence the person should see.
+        turn: () =>
+          Promise.reject(Object.assign(new Error(tooLong), { status: 413 })),
+        lookupRun: () => {
+          lookups += 1;
+          return Promise.resolve(undefined);
+        },
+        fenceRunAdmission: () => Promise.resolve(undefined),
+      },
+      slot: () => () => {},
+      inject: () => {
+        throw new Error("unexpected client provider injection");
+      },
+      provide: (_key, value) => {
+        provided = value as Ref<FrockBotWebData>;
+        return () => {};
+      },
+    });
+    if (!provided) throw new Error("shell data was not provided");
+    provided.value.activeBotId = "primary";
+    provided.value.composerContext = "primary";
+
+    const result = await provided.value.sendPrompt("x".repeat(120_000));
+
+    // A refusal, so the composer keeps the draft — and the thread shows
+    // neither the message that was never sent nor a placeholder about it.
+    expect(result).toEqual({ accepted: false, error: tooLong });
+    expect(provided.value.error).toBe(tooLong);
+    expect(provided.value.messages).toEqual([]);
+    expect(provided.value.activeRun).toBeUndefined();
+    expect(provided.value.activeRunId).toBeUndefined();
+    expect(provided.value.runningRunId).toBeUndefined();
+    // Nothing to reconcile: the Turn was refused, not lost.
+    expect(lookups).toBe(0);
+  });
+
+  test("settles an unreachable backend after the retry bound, under the message it reports on", async () => {
+    Object.defineProperty(globalThis, "window", {
+      configurable: true,
+      value: { location: { href: "https://app.example/?bot=primary" } },
+    });
+    // The bound is spent by waiting, and this test is about how the wait ends
+    // rather than about how long each one is.
+    const originalSetTimeout = globalThis.setTimeout;
+    Object.defineProperty(globalThis, "setTimeout", {
+      configurable: true,
+      writable: true,
+      value: ((callback: () => void) => {
+        queueMicrotask(callback);
+        return 0 as unknown as ReturnType<typeof originalSetTimeout>;
+      }) as unknown as typeof originalSetTimeout,
+    });
+    let provided: Ref<FrockBotWebData> | undefined;
+    let lookups = 0;
+    try {
+      await shellClientPlugin({
+        transport: {
+          // No status: the answer never arrived, so admission is genuinely
+          // unknown and reconciliation is right to start.
+          turn: () => Promise.reject(new TypeError("Failed to fetch")),
+          lookupRun: () => {
+            lookups += 1;
+            return Promise.reject(new TypeError("Failed to fetch"));
+          },
+          fenceRunAdmission: () =>
+            Promise.reject(new TypeError("Failed to fetch")),
+        },
+        slot: () => () => {},
+        inject: () => {
+          throw new Error("unexpected client provider injection");
+        },
+        provide: (_key, value) => {
+          provided = value as Ref<FrockBotWebData>;
+          return () => {};
+        },
+      });
+      if (!provided) throw new Error("shell data was not provided");
+      provided.value.activeBotId = "primary";
+      provided.value.composerContext = "primary";
+
+      const result = await provided.value.sendPrompt("are you there");
+
+      expect(lookups).toBe(UNCERTAIN_ADMISSION_MAX_ATTEMPTS_V1);
+      expect(result).toEqual({
+        accepted: false,
+        error: UNREACHABLE_BOT_MESSAGE_V1,
+      });
+      const [user, placeholder] = provided.value.messages;
+      expect(user).toMatchObject({ role: "user", text: "are you there" });
+      expect(placeholder).toMatchObject({
+        role: "assistant",
+        text: UNREACHABLE_BOT_MESSAGE_V1,
+        status: "error",
+        retry: "resend",
+      });
+      // Strictly after the message it reports on, so the thread's ordering by
+      // time cannot lift it above that message.
+      expect((placeholder?.at ?? "") > (user?.at ?? "")).toBe(true);
+      // Nothing is running any more, so no Stop stands for it, and the banner
+      // stops saying the client is still checking. It does not repeat the
+      // bubble's sentence either: the bubble is the report, and it is the one
+      // carrying the Retry.
+      expect(provided.value.error).toBeUndefined();
+      expect(provided.value.settingsError).toBeUndefined();
+      expect(provided.value.activeRun).toBeUndefined();
+      expect(provided.value.activeRunId).toBeUndefined();
+      expect(provided.value.runningRunId).toBeUndefined();
+    } finally {
+      Object.defineProperty(globalThis, "setTimeout", {
+        configurable: true,
+        writable: true,
+        value: originalSetTimeout,
+      });
+    }
+  });
+
   test("detaches a rejected Turn without starting a stale observer after Bot switch", async () => {
     Object.defineProperty(globalThis, "window", {
       configurable: true,

package/src/client/index.ts

@@ -62,6 +62,12 @@ import {
   decodeApprovalDecisionReceiptV1,
   decodeApprovalListViewV1,
 } from "../approvals.js";
+import {
+  isCertainSendRefusalV1,
+  momentAfterV1,
+  uncertainAdmissionDelayMsV1,
+  UNREACHABLE_BOT_MESSAGE_V1,
+} from "./uncertain-admission.js";
 import {
   decodeTaskListViewV1,
   decodeTaskViewV1,
@@ -976,7 +982,7 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
     botId: string,
     runId: string,
     signal: AbortSignal,
-  ): Promise<"admitted" | "not-admitted" | "detached"> {
+  ): Promise<"admitted" | "not-admitted" | "detached" | "unreachable"> {
     web.value.activeRun = {
       runId,
       status: "running",
@@ -986,7 +992,6 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
     if (!ctx.transport.lookupRun || !ctx.transport.fenceRunAdmission) {
       return "detached";
     }
-    let delayMs = 250;
     let reconciliationError: string | undefined;
     const clearReconciliationError = () => {
       if (web.value.settingsError === reconciliationError) {
@@ -994,7 +999,7 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
       }
       reconciliationError = undefined;
     };
-    while (!signal.aborted) {
+    for (let attempt = 1; !signal.aborted; attempt += 1) {
       try {
         const observed = await observeWhileAttached(
           ctx.transport.lookupRun(botId, runId),
@@ -1024,8 +1029,16 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
         } Retrying…`;
         web.value.settingsError = reconciliationError;
       }
+      const delayMs = uncertainAdmissionDelayMsV1(attempt);
+      // The bound is spent. Asking again would only keep a placeholder
+      // spinning over a backend this tab cannot reach, so the caller settles
+      // the Turn and says so in the thread.
+      if (delayMs === undefined) {
+        clearReconciliationError();
+        web.value.activeRun = undefined;
+        return "unreachable";
+      }
       await waitForRunLookup(delayMs, signal);
-      delayMs = Math.min(delayMs * 2, 5_000);
     }
     return "detached";
   }
@@ -2534,14 +2547,39 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
           web.value.error = refusal;
           return { accepted: false, error: refusal };
         }
+        // Every other 4xx is a refusal too, and the answer already says why —
+        // a message over the size limit is answered 413 with the sentence the
+        // person needs. Only 5xx and a lost connection leave admission in
+        // doubt, so anything else here is settled: no optimistic bubbles, no
+        // "checking" placeholder, no reconciliation, and the composer gets the
+        // draft back rather than the thread pretending it was sent.
+        if (isCertainSendRefusalV1(error)) {
+          removeMessages(web.value.messages, pendingRunId);
+          const refusal =
+            error instanceof Error && error.message
+              ? error.message
+              : "That message didn't go through. Try sending it again.";
+          web.value.error = refusal;
+          return { accepted: false, error: refusal };
+        }
         const aborted =
           error instanceof DOMException && error.name === "AbortError";
+        // Strictly after the message it reports on. The thread orders by time,
+        // and the durable projection gives the user's line the run's later
+        // `admittedAt`, so a placeholder carrying the moment the send began
+        // sorted above the message it belongs to.
+        const placeholderAt = momentAfterV1(
+          web.value.messages.find(
+            (message) =>
+              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: optimisticAt,
+          at: placeholderAt,
           status: "interrupted",
           tools: [],
           sends: [],
@@ -2554,7 +2592,8 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
         }
         const observer = new AbortController();
         admissionObserver = observer;
-        let disposition: "admitted" | "not-admitted" | "detached";
+        let disposition:
+          "admitted" | "not-admitted" | "detached" | "unreachable";
         try {
           disposition = await reconcileUncertainAdmission(
             botId,
@@ -2564,13 +2603,40 @@ export const shellClientPlugin: ClientPlugin = (ctx) => {
         } finally {
           if (admissionObserver === observer) admissionObserver = undefined;
         }
+        // The reconciliation ran out of attempts: this tab cannot reach the
+        // backend at all. That is the app's own failure and it says so, in
+        // place of the placeholder, with the Retry the person would otherwise
+        // 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: [],
+          });
+          // 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
+          // three times over — so the banner is cleared rather than set.
+          web.value.error = undefined;
+          web.value.activeRun = undefined;
+          web.value.activeRunId = undefined;
+          web.value.runningRunId = undefined;
+          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: optimisticAt,
+            at: placeholderAt,
             status: "error",
             tools: [],
             sends: [],

package/src/client/styles.css

@@ -301,6 +301,28 @@
   font-size: var(--frock-text-xs);
 }
 
+/*
+ * The way back from an ending the thread cannot recover on its own: the client
+ * gave up reaching the Bot, and the draft it handed back is one click from
+ * being sent again.
+ */
+.message-retry {
+  align-self: flex-start;
+  margin-top: 4px;
+  padding: 4px 10px;
+  border: 1px solid var(--frock-danger-border);
+  border-radius: var(--frock-radius-control);
+  color: var(--frock-danger-text);
+  background: transparent;
+  font-size: var(--frock-text-xs);
+  cursor: pointer;
+}
+
+.message-retry:disabled {
+  opacity: 0.6;
+  cursor: default;
+}
+
 /*
  * An assistant Turn is its avatar and, beside it, one column holding
  * everything the Turn produced. The row has exactly two children: bubbles,
@@ -720,6 +742,18 @@
   gap: 6px;
 }
 
+/* Only ever on screen near the limit, so it sits under the text it counts. */
+.composer-counter {
+  margin: 0;
+  align-self: flex-end;
+  color: var(--frock-text-muted);
+  font-size: var(--frock-text-xs);
+}
+
+.composer-counter-over {
+  color: var(--frock-danger-text);
+}
+
 .skill-chips {
   display: flex;
   margin: 0;

package/src/client/turn-limits.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, test } from "bun:test";
+import {
+  TURN_TEXT_COUNTER_FROM_V1,
+  TURN_TEXT_MAX_CHARACTERS_V1,
+  turnTextCounterVisibleV1,
+  turnTextRemainingV1,
+  turnTextTooLongV1,
+} from "./turn-limits.js";
+
+describe("the composer's copy of the send limit", () => {
+  test("mirrors the number the send route refuses on", () => {
+    // The gateway's `TURN_TEXT_MAX_CHARACTERS_V1`. Pinned here because the two
+    // are only equal by intent: the client cannot import the Worker's module.
+    expect(TURN_TEXT_MAX_CHARACTERS_V1).toBe(32_000);
+  });
+
+  test("is quiet until the budget is nearly spent", () => {
+    expect(turnTextCounterVisibleV1("a short message")).toBe(false);
+    expect(
+      turnTextCounterVisibleV1("x".repeat(TURN_TEXT_COUNTER_FROM_V1)),
+    ).toBe(true);
+  });
+
+  test("counts down, then counts the overflow", () => {
+    expect(turnTextRemainingV1("x".repeat(TURN_TEXT_MAX_CHARACTERS_V1))).toBe(
+      0,
+    );
+    expect(
+      turnTextRemainingV1("x".repeat(TURN_TEXT_MAX_CHARACTERS_V1 + 5)),
+    ).toBe(-5);
+  });
+
+  test("refuses only past the limit, never at it", () => {
+    expect(turnTextTooLongV1("x".repeat(TURN_TEXT_MAX_CHARACTERS_V1))).toBe(
+      false,
+    );
+    expect(turnTextTooLongV1("x".repeat(TURN_TEXT_MAX_CHARACTERS_V1 + 1))).toBe(
+      true,
+    );
+  });
+});

package/src/client/turn-limits.ts

@@ -0,0 +1,40 @@
+/**
+ * The composer's copy of the send route's size rule.
+ *
+ * The gateway refuses an oversized Turn with 413 before it ever reaches a Bot
+ * (`TURN_TEXT_MAX_CHARACTERS_V1` in the Cloudflare application's
+ * `request-body.ts`). A refusal the person could have seen coming is a bad
+ * refusal, so the composer enforces the same number: it counts down as the
+ * limit comes into reach and refuses to send past it, and the server's rule
+ * stays the authority for anything that reaches it another way.
+ *
+ * One constant rather than a literal at each use, because a limit written
+ * twice is a limit that drifts.
+ */
+export const TURN_TEXT_MAX_CHARACTERS_V1 = 32_000;
+
+/**
+ * Where the counter appears.
+ *
+ * A character count beside a half-written sentence is noise; it is only news
+ * as the budget runs out. The last tenth is where a person can still act on
+ * it — trim a paragraph, split the message — before the send button closes.
+ */
+export const TURN_TEXT_COUNTER_FROM_V1 = Math.floor(
+  TURN_TEXT_MAX_CHARACTERS_V1 * 0.9,
+);
+
+/** How much of the budget is left; negative once the draft is over it. */
+export function turnTextRemainingV1(text: string): number {
+  return TURN_TEXT_MAX_CHARACTERS_V1 - text.length;
+}
+
+/** True once the draft is longer than the send route would accept. */
+export function turnTextTooLongV1(text: string): boolean {
+  return turnTextRemainingV1(text) < 0;
+}
+
+/** True once the count is worth showing. */
+export function turnTextCounterVisibleV1(text: string): boolean {
+  return text.length >= TURN_TEXT_COUNTER_FROM_V1;
+}

package/src/client/uncertain-admission.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, test } from "bun:test";
+import {
+  isCertainSendRefusalV1,
+  momentAfterV1,
+  uncertainAdmissionDelayMsV1,
+  UNCERTAIN_ADMISSION_MAX_ATTEMPTS_V1,
+  UNREACHABLE_BOT_MESSAGE_V1,
+} from "./uncertain-admission.js";
+
+describe("telling a refusal from a doubt", () => {
+  test("a 4xx is certain and a 5xx is not", () => {
+    const refused = Object.assign(new Error("Your message is too long."), {
+      status: 413,
+    });
+    const failed = Object.assign(new Error("Agent request failed"), {
+      status: 500,
+    });
+    expect(isCertainSendRefusalV1(refused)).toBe(true);
+    expect(isCertainSendRefusalV1(failed)).toBe(false);
+  });
+
+  test("an error with no status is a doubt", () => {
+    // What a dropped connection throws: no answer was read, so nothing about
+    // the send is settled.
+    expect(isCertainSendRefusalV1(new TypeError("Failed to fetch"))).toBe(
+      false,
+    );
+    expect(isCertainSendRefusalV1(undefined)).toBe(false);
+    expect(isCertainSendRefusalV1({ status: "413" })).toBe(false);
+  });
+});
+
+describe("the admission retry bound", () => {
+  test("backs off and then stops asking", () => {
+    const delays = Array.from(
+      { length: UNCERTAIN_ADMISSION_MAX_ATTEMPTS_V1 },
+      (_unused, index) => uncertainAdmissionDelayMsV1(index + 1),
+    );
+    // Five waits between six attempts, doubling; the sixth attempt is the last
+    // one, so it is followed by no wait at all.
+    expect(delays).toEqual([250, 500, 1_000, 2_000, 4_000, undefined]);
+  });
+
+  test("never waits past the ceiling", () => {
+    expect(uncertainAdmissionDelayMsV1(1)).toBe(250);
+    for (let attempt = 1; attempt <= 20; attempt += 1) {
+      const delay = uncertainAdmissionDelayMsV1(attempt);
+      if (delay === undefined) continue;
+      expect(delay).toBeLessThanOrEqual(5_000);
+    }
+  });
+
+  test("the terminal copy names the app's own failure", () => {
+    expect(UNREACHABLE_BOT_MESSAGE_V1).toContain("Couldn't reach the Bot");
+  });
+});
+
+describe("placing a line after the one it reports on", () => {
+  test("is strictly later, and stays sortable as a string", () => {
+    const at = "2026-09-01T00:01:00.000Z";
+    const after = momentAfterV1(at);
+    expect(after > at).toBe(true);
+    expect(after).toBe("2026-09-01T00:01:00.001Z");
+  });
+
+  test("leaves a timestamp it cannot read alone", () => {
+    expect(momentAfterV1("not a time")).toBe("not a time");
+  });
+});

package/src/client/uncertain-admission.ts

@@ -0,0 +1,78 @@
+/**
+ * What a send means when the answer was not a Turn.
+ *
+ * There are two of those and they are not alike. A 4xx is the server having
+ * read the request and decided against it: the Turn does not exist, will not
+ * exist, and the answer says why. Everything else — a 5xx, a socket that
+ * closed, a browser that lost the network — leaves admission genuinely
+ * unknown, and only that case is worth reconciling.
+ *
+ * Telling them apart is the whole point. Treating a 413 as unknown drew the
+ * person's oversized draft into the thread as though it had been sent, then
+ * polled for a run that was never admitted.
+ */
+
+/**
+ * True when the transport's error carries a 4xx: a refusal, not a doubt.
+ *
+ * Duck-typed on `status` rather than on an error class, because the transport
+ * is an interface with more than one implementation and a plain `Error` with a
+ * status is all any of them can be relied on to throw.
+ */
+export function isCertainSendRefusalV1(error: unknown): boolean {
+  if (typeof error !== "object" || error === null) return false;
+  if (!("status" in error)) return false;
+  const status = error.status;
+  return typeof status === "number" && status >= 400 && status < 500;
+}
+
+/**
+ * How many times admission reconciliation asks before it stops asking.
+ *
+ * A bound rather than an ever-retrying loop: a backend the tab cannot reach
+ * does not become reachable by being asked a thousand times, and the person
+ * watching a placeholder deserves an answer inside a few seconds. Six attempts
+ * over the schedule below spans roughly eight seconds, which covers a Worker
+ * cold start and a brief network blip without outliving anybody's patience.
+ */
+export const UNCERTAIN_ADMISSION_MAX_ATTEMPTS_V1 = 6;
+
+const FIRST_DELAY_MS_V1 = 250;
+const MAX_DELAY_MS_V1 = 5_000;
+
+/**
+ * How long to wait before attempt `attempt + 1`, or `undefined` once the bound
+ * is spent and the client should settle instead of asking again.
+ */
+export function uncertainAdmissionDelayMsV1(
+  attempt: number,
+): number | undefined {
+  if (attempt >= UNCERTAIN_ADMISSION_MAX_ATTEMPTS_V1) return undefined;
+  return Math.min(FIRST_DELAY_MS_V1 * 2 ** (attempt - 1), MAX_DELAY_MS_V1);
+}
+
+/**
+ * What the thread says when the client gave up reaching the backend.
+ *
+ * Naming the app's own failure, because nothing else in the product did: every
+ * other line blames the message or the Bot, and a person whose wifi dropped
+ * was told their message "didn't go through" as though the Bot had refused it.
+ */
+export const UNREACHABLE_BOT_MESSAGE_V1 =
+  "Couldn't reach the Bot. Check your connection and try again.";
+
+/**
+ * A timestamp one millisecond after `at`.
+ *
+ * The thread sorts by time, so a line that belongs under another needs a time
+ * of its own: the placeholder used to carry the moment the send *began*, which
+ * put it above the message it was reporting on the instant the durable
+ * projection gave that message its later `admittedAt`.
+ */
+export function momentAfterV1(at: string): string {
+  const moment = new Date(at).getTime();
+  // An unparsable timestamp is not worth inventing an order for; the thread's
+  // insertion order still holds the line where it was put.
+  if (!Number.isFinite(moment)) return at;
+  return new Date(moment + 1).toISOString();
+}

package/src/debug-protocol.test.ts

@@ -3,6 +3,7 @@ import {
   BOT_DEBUG_RUN_LIMIT_V1,
   boundDebugEventsV1,
   decodeBotDebugQueryV1,
+  isBotDebugQueryRefusalV1,
 } from "./debug-protocol.js";
 
 describe("debug query", () => {
@@ -36,13 +37,48 @@ describe("debug query", () => {
     ).toThrow("debug query has invalid fields");
   });
 
-  test("rejects a limit past the page bound", () => {
+  test("rejects a limit past the page bound, in words that name the range", () => {
     expect(() =>
       decodeBotDebugQueryV1({
         schemaVersion: 1,
         limit: BOT_DEBUG_RUN_LIMIT_V1 + 1,
       }),
-    ).toThrow("debug query limit is invalid");
+    ).toThrow(
+      `debug query limit must be a whole number from 1 to ${BOT_DEBUG_RUN_LIMIT_V1}`,
+    );
+  });
+
+  // The refusal rides on the error's name, which is all a Durable Object RPC
+  // preserves: a bad query has to arrive at the gateway as a 400 and not as
+  // an uncaught failure in the Bot's isolate.
+  test("refuses a bad query as a refusal, not as an ordinary failure", () => {
+    for (const input of [
+      { schemaVersion: 1, limit: 0 },
+      { schemaVersion: 1, limit: BOT_DEBUG_RUN_LIMIT_V1 + 1 },
+      { schemaVersion: 1, limit: 1.5 },
+      { schemaVersion: 1, limit: Number.NaN },
+      { schemaVersion: 1, sql: "select 1" },
+      { schemaVersion: 2 },
+      "not a query",
+    ]) {
+      let refusal: unknown;
+      try {
+        decodeBotDebugQueryV1(input);
+      } catch (error) {
+        refusal = error;
+      }
+      expect(isBotDebugQueryRefusalV1(refusal)).toBe(true);
+    }
+  });
+
+  test("accepts both ends of the allowed range", () => {
+    expect(decodeBotDebugQueryV1({ schemaVersion: 1, limit: 1 }).limit).toBe(1);
+    expect(
+      decodeBotDebugQueryV1({
+        schemaVersion: 1,
+        limit: BOT_DEBUG_RUN_LIMIT_V1,
+      }).limit,
+    ).toBe(BOT_DEBUG_RUN_LIMIT_V1);
   });
 
   test("rejects a wrong schema version", () => {

package/src/debug-protocol.ts

@@ -90,21 +90,50 @@ export interface BotDebugSnapshotV1 {
   nextCursor?: string;
 }
 
+/**
+ * A debug query the caller got wrong: an unknown field, a `limit` past the cap.
+ * The request is what is bad, not the Bot, so the surface owes a 400 rather
+ * than an uncaught failure in the isolate. The name is what carries that
+ * across the Durable Object RPC boundary — which keeps an error's `name` and
+ * `message` and drops everything else — exactly as `BotTurnRefusedError` does
+ * for a refused admission.
+ */
+export class BotDebugQueryRefusedErrorV1 extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "BotDebugQueryRefusedErrorV1";
+  }
+}
+
+/** Whether an error — including one that has crossed RPC — is that refusal. */
+export function isBotDebugQueryRefusalV1(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "name" in error &&
+    String((error as { name: unknown }).name) === "BotDebugQueryRefusedErrorV1"
+  );
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 function boundedString(value: unknown, maximum: number, field: string): string {
   if (typeof value !== "string" || value.length < 1 || value.length > maximum) {
-    throw new Error(`debug query ${field} is invalid`);
+    throw new BotDebugQueryRefusedErrorV1(`debug query ${field} is invalid`);
   }
   return value;
 }
 
 export function decodeBotDebugQueryV1(input: unknown): BotDebugQueryV1 {
-  if (!isRecord(input)) throw new Error("debug query is invalid");
+  if (!isRecord(input)) {
+    throw new BotDebugQueryRefusedErrorV1("debug query is invalid");
+  }
   if (input.schemaVersion !== 1) {
-    throw new Error("debug query schemaVersion is invalid");
+    throw new BotDebugQueryRefusedErrorV1(
+      "debug query schemaVersion is invalid",
+    );
   }
   const allowed = new Set([
     "schemaVersion",
@@ -114,7 +143,7 @@ export function decodeBotDebugQueryV1(input: unknown): BotDebugQueryV1 {
     "events",
   ]);
   if (!Object.keys(input).every((key) => allowed.has(key))) {
-    throw new Error("debug query has invalid fields");
+    throw new BotDebugQueryRefusedErrorV1("debug query has invalid fields");
   }
   const query: BotDebugQueryV1 = { schemaVersion: 1 };
   if (input.runId !== undefined) {
@@ -129,13 +158,17 @@ export function decodeBotDebugQueryV1(input: unknown): BotDebugQueryV1 {
       (input.limit as number) < 1 ||
       (input.limit as number) > BOT_DEBUG_RUN_LIMIT_V1
     ) {
-      throw new Error("debug query limit is invalid");
+      throw new BotDebugQueryRefusedErrorV1(
+        `debug query limit must be a whole number from 1 to ${BOT_DEBUG_RUN_LIMIT_V1}`,
+      );
     }
     query.limit = input.limit as number;
   }
   if (input.events !== undefined) {
     if (typeof input.events !== "boolean") {
-      throw new Error("debug query events is invalid");
+      throw new BotDebugQueryRefusedErrorV1(
+        "debug query events must be true or false",
+      );
     }
     query.events = input.events;
   }

package/src/run-protocol.test.ts

@@ -24,6 +24,7 @@ import {
   projectClientRunV1,
   projectClientRunOrDegradedV1,
   projectClientTurnV1,
+  UNRECORDED_TOOL_RESULT_TEXT_V1,
 } from "./run-protocol.js";
 
 const timestamp = "2026-08-29T00:00:00.000Z";
@@ -1061,14 +1062,59 @@ describe("client run protocol v1", () => {
     expect(() => projectClientRunListV1([storedRun([result])])).toThrow(
       'tool result has no matching occurrence "tool:1:1:0"',
     );
-    expect(() => projectClientRunListV1([storedRun([call])])).toThrow(
-      'terminal run has no result for tool call "tool-1"',
-    );
     expect(() =>
       projectClientRunListV1([storedRun([call, call, result])]),
     ).toThrow('tool occurrence "tool:1:1:0" has duplicate intent');
   });
 
+  // A READ never throws on a record that is already durable. A settled Turn
+  // whose tool call was never settled used to fail the whole transcript
+  // endpoint — a 500 on every later request — so one malformed row bricked the
+  // conversation for ever. It degrades to a row saying nothing was recorded.
+  test("degrades a settled Turn's unsettled tool call instead of throwing", () => {
+    const call = toolEvents(1)[0]!;
+
+    const projected = projectClientRunListV1([storedRun([call])]).runs[0];
+
+    expect(projected?.events).toEqual([
+      { type: "tool/call", call: { id: "tool-1", name: "lookup" } },
+      {
+        type: "tool/result",
+        callId: "tool-1",
+        content: UNRECORDED_TOOL_RESULT_TEXT_V1,
+        isError: true,
+      },
+    ]);
+    // And the degraded row survives the wire decode, which used to refuse it
+    // for the same reason the projection did.
+    expect(
+      decodeClientRunListV1({
+        schemaVersion: 1,
+        runs: [projected],
+        page: { truncated: false },
+      })[0]?.events,
+    ).toHaveLength(2);
+  });
+
+  test("accepts a settled Turn on the wire whose call carries no result", () => {
+    const projected = projectClientRunListV1([storedRun([])]).runs[0]!;
+
+    expect(
+      decodeClientRunListV1({
+        schemaVersion: 1,
+        runs: [
+          {
+            ...projected,
+            events: [
+              { type: "tool/call", call: { id: "tool-1", name: "lookup" } },
+            ],
+          },
+        ],
+        page: { truncated: false },
+      })[0]?.events,
+    ).toEqual([{ type: "tool/call", call: { id: "tool-1", name: "lookup" } }]);
+  });
+
   test("retains pending calls only for nonterminal runs", () => {
     const call = toolEvents(1)[0]!;
     const projected = projectClientRunListV1([storedRun([call], "running")])

package/src/run-protocol.ts

@@ -500,6 +500,14 @@ interface ProjectionUnitV1 {
   droppable: boolean;
 }
 
+/**
+ * What a settled Turn's tool call shows when the durable record holds no
+ * result for it. Same register as the rest of the transcript copy: it tells
+ * the person what is missing rather than naming an occurrence id.
+ */
+export const UNRECORDED_TOOL_RESULT_TEXT_V1 =
+  "No result was recorded for this tool call.";
+
 function dynamicToolCallInput(
   value: unknown,
 ): ClientDynamicToolCallInputV1 | undefined {
@@ -658,12 +666,23 @@ function projectionUnits(
     }
   }
   if (isTerminalRunStatus(status)) {
-    const orphaned = units.find((unit) => !unit.droppable);
-    if (orphaned) {
-      const call = orphaned.events[0] as ClientToolCallV1;
-      throw new Error(
-        `terminal run has no result for tool call "${call.call.id}"`,
-      );
+    for (const unit of units) {
+      if (unit.droppable) continue;
+      // A settled Turn owes every tool call a result, and `Session`'s
+      // interruption repairs now write one. Records already durable from
+      // before that do not have it, and a READ must never throw on them: one
+      // malformed row used to brick the whole transcript endpoint for ever.
+      // The row degrades instead, and says exactly what is missing — not
+      // through `projectClientRunOrDegradedV1`, which throws the whole Turn
+      // away for an unreadable record. Everything else here is readable.
+      const call = unit.events[0] as ClientToolCallV1;
+      unit.events.push({
+        type: "tool/result",
+        callId: call.call.id,
+        content: UNRECORDED_TOOL_RESULT_TEXT_V1,
+        isError: true,
+      });
+      unit.droppable = true;
     }
   }
   return units;
@@ -1137,10 +1156,12 @@ function decodeEvent(value: unknown): ClientRunEventV1 {
   throw new Error("run event.type is invalid");
 }
 
-function decodeEvents(
-  values: unknown[],
-  runStatus: ClientRunStatusV1,
-): ClientTurnEvent[] {
+/**
+ * The event walk a wire run is decoded through. It no longer takes the run's
+ * status: a settled Turn's tool call with no result is a row the projection
+ * has already degraded, not a message to refuse.
+ */
+function decodeEvents(values: unknown[]): ClientTurnEvent[] {
   const events = values.map(decodeEvent);
   let index = 0;
   if (events[0]?.type === "run/events-truncated") index = 1;
@@ -1178,9 +1199,10 @@ function decodeEvents(
       index += 2;
       continue;
     }
-    if (isTerminalRunStatus(runStatus)) {
-      throw new Error(`terminal run has no result for tool call "${id}"`);
-    }
+    // A settled Turn whose call has no result is a degraded row, not a bad
+    // wire message: the projection above already renders it as "no result
+    // recorded", and refusing it here would put the whole transcript behind
+    // one durable record nobody can now repair.
     index += 1;
   }
   return events;
@@ -1330,7 +1352,7 @@ function decodeRun(value: unknown): ClientRun {
     admittedAt,
     input: wireString(run, "input", MAX_INPUT_BYTES, "run"),
     status: runStatus,
-    events: decodeEvents(run.events, runStatus),
+    events: decodeEvents(run.events),
     ...(stopRequestedAt ? { stopRequestedAt } : {}),
     ...(run.queued === true ? { queued: true as const } : {}),
     ...(outcome?.type === "completed" ? { responseText: outcome.text } : {}),
@@ -1454,7 +1476,7 @@ export function decodeClientTurnV1(input: unknown): ClientTurnResponse {
   return {
     runId,
     text: wireString(turn, "text", MAX_OUTCOME_BYTES, "turn"),
-    events: decodeEvents(turn.events, "completed"),
+    events: decodeEvents(turn.events),
     ...(notification ? { notification } : {}),
   };
 }

package/src/shared.ts

@@ -107,6 +107,13 @@ export interface WebChatMessage {
    * Bot had already said, which it keeps (ADR 0024).
    */
   notice?: string;
+  /**
+   * The line offers to send the draft again. Set only where the client gave
+   * up on its own — it could not reach the backend — because that is the one
+   * ending the person cannot act on from the thread otherwise: their text is
+   * back in the composer, and this is the button that sends it.
+   */
+  retry?: "resend";
   tools: WebToolActivity[];
   /** The typed payloads this Turn sent to the user, oldest first. */
   sends: WebSendPayload[];

package/src/unread.test.ts

@@ -13,6 +13,7 @@ import {
   optionalUnreadStateV1,
   projectBotUnreadViewV1,
   sidebarMessagePreviewForTurnV1,
+  sidebarMessagePreviewFromRunsV1,
   UNREAD_COUNT_CAP,
   type UnreadStateV1,
 } from "./unread.js";
@@ -263,6 +264,73 @@ describe("the unread projection", () => {
   });
 });
 
+// The record is written at settlement, so a Bot whose Turns settled before
+// that projection existed has a full transcript and no preview — and its
+// sidebar row said "No messages yet" over six messages. A read derives it.
+describe("the sidebar preview derived from stored runs", () => {
+  const run = (over: Record<string, unknown> = {}) => ({
+    acceptedAt: "2026-08-31T00:02:00.000Z",
+    input: "What is the plan?",
+    responseText: "Here is the plan.",
+    status: "completed",
+    events: [{ timestamp: "2026-08-31T00:02:05.000Z" }],
+    ...over,
+  });
+
+  test("takes the newest settled chat Turn's reply, stamped when it settled", () => {
+    expect(sidebarMessagePreviewFromRunsV1([run()])).toEqual({
+      schemaVersion: 1,
+      text: "Here is the plan.",
+      at: "2026-08-31T00:02:05.000Z",
+      role: "assistant",
+    });
+  });
+
+  test("walks past a running Turn and an automation to the newest chat reply", () => {
+    expect(
+      sidebarMessagePreviewFromRunsV1([
+        run({ status: "running", responseText: undefined }),
+        run({
+          admission: { turnType: "automation" },
+          responseText: "Routine ran.",
+        }),
+        run({ responseText: "The older answer." }),
+      ]),
+    ).toMatchObject({ text: "The older answer.", role: "assistant" });
+  });
+
+  test("falls back to the User's own words when the reply was empty", () => {
+    expect(
+      sidebarMessagePreviewFromRunsV1([run({ responseText: "" })]),
+    ).toEqual({
+      schemaVersion: 1,
+      text: "What is the plan?",
+      at: "2026-08-31T00:02:00.000Z",
+      role: "user",
+    });
+  });
+
+  test("a Bot with no settled chat Turn still has no preview", () => {
+    expect(sidebarMessagePreviewFromRunsV1([])).toBeUndefined();
+    expect(
+      sidebarMessagePreviewFromRunsV1([
+        run({ status: "running", responseText: undefined, input: "" }),
+      ]),
+    ).toBeUndefined();
+  });
+
+  // A read of durable data never throws: a run whose stamps are unreadable
+  // costs the row, not the whole sidebar.
+  test("skips a run whose stored timestamps cannot be read", () => {
+    expect(
+      sidebarMessagePreviewFromRunsV1([
+        run({ acceptedAt: "not a time", events: [] }),
+        run({ responseText: "The readable one." }),
+      ]),
+    ).toMatchObject({ text: "The readable one." });
+  });
+});
+
 describe("the unread command", () => {
   test("decodes each type and refuses a mismatched cursor", () => {
     expect(

package/src/unread.ts

@@ -260,6 +260,59 @@ export function sidebarMessagePreviewForTurnV1(
   });
 }
 
+/** The little a settled run has to expose for a preview to be derived from it. */
+export interface SidebarPreviewRunV1 {
+  acceptedAt: string;
+  input: string;
+  responseText?: string;
+  status: string;
+  /** Only the timestamps are read: the newest one is when the Turn settled. */
+  events?: readonly { timestamp?: string }[];
+  /** Absent means the Turn was admitted as `chat`, as everywhere else. */
+  admission?: { turnType?: string };
+}
+
+/**
+ * The preview for a Bot that has a transcript but no preview record.
+ *
+ * The record is written at settlement, so every Turn that settled before that
+ * projection existed left one behind — and the row then claimed "No messages
+ * yet" over a full conversation. A read cannot write the record it is missing,
+ * so it derives the same line from the runs that are already durable. Runs
+ * arrive newest-first and the walk stops at the first settled chat Turn with
+ * text, which is exactly the line the settlement would have stored.
+ */
+export function sidebarMessagePreviewFromRunsV1(
+  runs: readonly SidebarPreviewRunV1[],
+): SidebarMessagePreviewV1 | undefined {
+  for (const run of runs) {
+    if (run.status === "running") continue;
+    // An automation Turn reaches the User through its own inbox entry and
+    // never became this row at settlement either.
+    if ((run.admission?.turnType ?? "chat") !== "chat") continue;
+    const settledAt = settlementTimestampV1(run);
+    try {
+      const preview = sidebarMessagePreviewForTurnV1(run, settledAt);
+      if (preview) return preview;
+    } catch {
+      // A run whose stored timestamps cannot be read is not worth the row —
+      // and a read of durable data never throws over one bad record.
+      continue;
+    }
+  }
+  return undefined;
+}
+
+/** When a stored run settled: its newest event's stamp, else its admission. */
+function settlementTimestampV1(run: SidebarPreviewRunV1): string {
+  for (let index = (run.events?.length ?? 0) - 1; index >= 0; index -= 1) {
+    const timestamp = run.events?.[index]?.timestamp;
+    if (typeof timestamp === "string" && Number.isFinite(Date.parse(timestamp)))
+      return timestamp;
+  }
+  return run.acceptedAt;
+}
+
 /**
  * Records a settled chat Turn. Monotonic: a cursor that is not newer than the
  * one already recorded leaves the record byte-for-byte unchanged, so a