@frockbot/plugin-shell 0.3.6 → 0.3.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/plugin-shell",
-  "version": "0.3.6",
+  "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.6",
-    "@frockbot/application-foundation": "0.3.6",
-    "@frockbot/catalog-core": "0.3.6",
-    "@frockbot/client-core": "0.3.6",
-    "@frockbot/client-ui": "0.3.6",
-    "@frockbot/computer-core": "0.3.6",
-    "@frockbot/computer-host-protocol": "0.3.6",
-    "@frockbot/configuration-core": "0.3.6",
-    "@frockbot/connection-core": "0.3.6",
-    "@frockbot/kernel-agent-loop": "0.3.6",
-    "@frockbot/kernel-composition": "0.3.6",
-    "@frockbot/kernel-contracts": "0.3.6",
-    "@frockbot/kernel-do": "0.3.6",
-    "@frockbot/machine-protocol": "0.3.6",
-    "@frockbot/plugin-applets": "0.3.6",
-    "@frockbot/plugin-authoring": "0.3.6",
-    "@frockbot/plugin-bot-template": "0.3.6",
-    "@frockbot/plugin-computer": "0.3.6",
-    "@frockbot/plugin-flock": "0.3.6",
-    "@frockbot/plugin-image": "0.3.6",
-    "@frockbot/plugin-machine-messages": "0.3.6",
-    "@frockbot/plugin-mcp": "0.3.6",
-    "@frockbot/plugin-memory": "0.3.6",
-    "@frockbot/plugin-package-catalog": "0.3.6",
-    "@frockbot/plugin-routines": "0.3.6",
-    "@frockbot/plugin-skills": "0.3.6",
-    "@frockbot/plugin-subagents": "0.3.6",
-    "@frockbot/plugin-user-machine": "0.3.6",
-    "@frockbot/protocol": "0.3.6",
+    "@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.6",
+    "@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-recovery-integration.test.ts

@@ -354,26 +354,20 @@ describe("Bot recovery", () => {
         text: "uncertain",
       }),
     ).rejects.toThrow("response lost");
-    expect(
-      await storage.get<StoredRun>("run:ollama-run-uncertain"),
-    ).toMatchObject({ status: "reconciliation-required" });
+    // Ollama keeps no addressable copy of a completion, so a failure raised
+    // before the first stream event is definitive rather than uncertain: the
+    // run settles as a failed Turn instead of parking on a retrieval this
+    // provider can never perform.
+    const uncertain = await storage.get<StoredRun>("run:ollama-run-uncertain");
+    expect(uncertain?.status).toBe("failed");
+    expect(uncertain?.failure).toContain("response lost");
+    expect(await storage.get("active-run")).toBeUndefined();
 
+    // The alarm has nothing left to recover: a settled run stays settled.
     await host().alarm();
-    expect(
-      await storage.get<StoredRun>("run:ollama-run-uncertain"),
-    ).toMatchObject({ status: "reconciliation-required" });
-    await expect(
-      host().reconcileRun(
-        { userId: "user-1", botId: "primary" },
-        "ollama-run-uncertain",
-      ),
-    ).rejects.toThrow();
-    expect(
-      await storage.get<StoredRun>("run:ollama-run-uncertain"),
-    ).toMatchObject({
-      status: "failed",
-      failure: expect.stringContaining("explicitly abandoned"),
-    });
+    const settled = await storage.get<StoredRun>("run:ollama-run-uncertain");
+    expect(settled?.status).toBe("failed");
+    expect(settled?.failure).toContain("response lost");
     expect(await storage.get("active-run")).toBeUndefined();
   });
 

package/src/backend.ts

@@ -403,6 +403,7 @@ import {
   projectClientAnnouncementsV1,
   projectClientTurnV1,
   type ClientRunLookupV1,
+  type ClientConversationListV1,
   type ClientRunListV1,
   type ClientRunStopReceiptV1,
   type ClientRunV1,
@@ -436,6 +437,7 @@ import {
   optionalSidebarMessagePreviewV1,
   optionalUnreadStateV1,
   projectBotUnreadViewV1,
+  sidebarMessagePreviewFromRunsV1,
   SIDEBAR_PREVIEW_KEY,
   unreadReceiptKeyV1,
   UNREAD_COUNT_CAP,
@@ -443,6 +445,8 @@ import {
   type BotUnreadCommandV1,
   type BotUnreadReceiptV1,
   type BotUnreadViewV1,
+  type SidebarMessagePreviewV1,
+  type SidebarPreviewRunV1,
 } from "./unread.js";
 import { defineBotBackendContribution } from "@frockbot/kernel-contracts/contributions";
 
@@ -5253,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,
     });
@@ -5261,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
@@ -5293,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(
@@ -5319,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({
@@ -5335,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),
       ),
     };
   }
@@ -5443,6 +5476,15 @@ export class ShellBotBackendContribution {
   ): Promise<ClientRunListV1> {
     const query = decodeClientRunListQueryV1(input);
     await this.authority.recoverActiveRun();
+    // The transcript is one conversation, not every Turn the Bot has ever
+    // run. Absent means the conversation the Bot is on; naming an earlier one
+    // reads it exactly as it was left. A Bot whose object has not learned its
+    // identity yet has no conversation to filter by and shows what it has.
+    const conversationId =
+      query.conversationId ??
+      (await this.authority.readConversationSessionId());
+    const inConversation = (run: { sessionId: string }) =>
+      conversationId === undefined || run.sessionId === conversationId;
     const activeRunId = query.before
       ? undefined
       : await this.authority.readActiveRunId();
@@ -5457,7 +5499,7 @@ export class ShellBotBackendContribution {
       // An automation firing occupies the object like any other run, and is
       // still not part of the conversation: the visible transcript never
       // shows one, running or settled.
-      if (active && isVisibleRunV1(active))
+      if (active && isVisibleRunV1(active) && inConversation(active))
         selected.set(active.runId, {
           run: projectClientRunOrDegradedV1(active),
         });
@@ -5471,7 +5513,8 @@ export class ShellBotBackendContribution {
         continue;
       }
       const stored = await this.authority.readStoredRun(candidate.runId);
-      if (!stored || !isVisibleRunV1(stored)) continue;
+      if (!stored || !isVisibleRunV1(stored) || !inConversation(stored))
+        continue;
       const projected = projectClientRunOrDegradedV1(stored);
       const tentative = [
         ...selected.values(),
@@ -5527,6 +5570,36 @@ export class ShellBotBackendContribution {
     }
     return page;
   }
+  /** The conversations this Bot has had, newest first. */
+  async listConversations(): Promise<ClientConversationListV1> {
+    return {
+      schemaVersion: 1,
+      conversations: (await this.authority.listConversations()).map(
+        (conversation) => ({
+          schemaVersion: 1 as const,
+          conversationId: conversation.sessionId,
+          ordinal: conversation.ordinal,
+          startedAt: conversation.startedAt,
+          ...(conversation.endedAt ? { endedAt: conversation.endedAt } : {}),
+        }),
+      ),
+    };
+  }
+
+  /**
+   * Puts this conversation down and starts the next one.
+   *
+   * Memory is untouched: it is not conversation history, and the point of a
+   * new conversation is to prove that it is not.
+   */
+  async startConversation(
+    identity: BotIdentity,
+  ): Promise<ClientConversationListV1> {
+    await this.validateIdentity(identity);
+    await this.authority.startConversation(identity);
+    return this.listConversations();
+  }
+
   async lookupRun(input: unknown): Promise<ClientRunLookupV1> {
     const query = decodeClientRunLookupQueryV1(input);
     return projectClientRunLookupV1(await this.authority.readRun(query.runId));

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,7 +1227,33 @@ 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
+            where you are when you decide the last one is finished. Disabled
+            while a Turn is running: the Bot is still writing to it.
+          -->
+          <UiIconButton
+            icon="plus"
+            label="New conversation"
+            variant="ghost"
+            class="new-conversation-button"
+            :disabled="isRunning"
+            @click="web.startConversation()"
+          />
           <UiIconButton
             v-if="showStop"
             class="stop-button"

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,