@frockbot/plugin-flock 0.3.19 → 0.3.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/plugin-flock",
-  "version": "0.3.19",
+  "version": "0.3.21",
   "private": false,
   "type": "module",
   "exports": {
@@ -28,16 +28,16 @@
     "typecheck": "vue-tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
-    "@frockbot/client-core": "0.3.19",
-    "@frockbot/client-ui": "0.3.19",
-    "@frockbot/configuration-core": "0.3.19",
-    "@frockbot/kernel-contracts": "0.3.19",
-    "@frockbot/plugin-shell": "0.3.19",
+    "@frockbot/client-core": "0.3.21",
+    "@frockbot/client-ui": "0.3.21",
+    "@frockbot/configuration-core": "0.3.21",
+    "@frockbot/kernel-contracts": "0.3.21",
+    "@frockbot/plugin-shell": "0.3.21",
     "cordis": "4.0.0-rc.8",
     "vue": "3.5.41"
   },
   "devDependencies": {
-    "@frockbot/plugin-testkit": "0.3.19",
+    "@frockbot/plugin-testkit": "0.3.21",
     "@types/bun": "1.4.0",
     "@vitejs/plugin-vue": "6.0.8",
     "css-tree": "2.3.1",

package/src/client/index.test.ts

@@ -735,3 +735,108 @@ describe("Flock sidebar rows follow the transcript", () => {
     });
   });
 });
+
+describe("Flock list follows the account", () => {
+  test("a Bot deleted elsewhere moves this tab's selection on the next unread beat", async () => {
+    installStorage();
+    const location = { href: "https://app.example/?bot=alpha" };
+    Object.defineProperty(globalThis, "window", {
+      configurable: true,
+      value: {
+        location,
+        history: {
+          state: null,
+          replaceState: (_state: unknown, _title: string, url: URL) => {
+            location.href = url.href;
+          },
+        },
+      },
+    });
+    const sheep = randomSheepRecipeV1(() => 0);
+    // The directory this tab read yesterday still has alpha; the account has
+    // since deleted it (from the phone, say) and made gamma.
+    let bots = ["alpha", "beta"];
+    let directoryReads = 0;
+    const state = mount((path) => {
+      if (path === "/api/bots/identities")
+        return Promise.resolve({ schemaVersion: 1, identities: [] });
+      if (path === "/api/bots") {
+        directoryReads += 1;
+        return Promise.resolve({
+          schemaVersion: 1,
+          revision: directoryReads,
+          bots: bots.map((botId) => ({
+            schemaVersion: 1,
+            botId,
+            registeredAt: new Date(0).toISOString(),
+            initialName: botId,
+            sheep,
+          })),
+        });
+      }
+      if (path === "/api/bots/lifecycles")
+        return Promise.resolve({
+          schemaVersion: 1,
+          lifecycles: bots.map((botId) => ({
+            schemaVersion: 1,
+            botId,
+            status: "active",
+            revision: 0,
+          })),
+        });
+      if (path === "/api/bots/unread")
+        return Promise.resolve({
+          schemaVersion: 1,
+          unread: bots.map((botId) => ({
+            schemaVersion: 1,
+            botId,
+            count: 0,
+            capped: false,
+            unread: false,
+            manuallyUnread: false,
+          })),
+        });
+      if (path.endsWith("/sheep")) {
+        const botId = path.split("/")[3]!;
+        return Promise.resolve({ schemaVersion: 1, botId, revision: 0, sheep });
+      }
+      return Promise.reject(new Error(`unexpected request: ${path}`));
+    });
+    const selected: string[] = [];
+    const shell = ref({
+      activeBotId: undefined as string | undefined,
+      selectBot: (botId: string) => {
+        selected.push(botId);
+        shell.value.activeBotId = botId;
+        return Promise.resolve();
+      },
+      transcripts: {
+        rememberViewport: () => undefined,
+        viewportFor: () => undefined,
+        forget: () => undefined,
+      },
+    });
+    state.value.bindShell(shell as unknown as Ref<FrockBotWebData>);
+    await state.value.load();
+    expect(selected).toEqual(["alpha"]);
+    expect(directoryReads).toBe(1);
+
+    // A beat that agrees with the list on screen reads nothing again.
+    await state.value.refreshUnread();
+    expect(directoryReads).toBe(1);
+
+    bots = ["beta", "gamma"];
+    await state.value.refreshUnread();
+    expect(directoryReads).toBe(2);
+    expect(state.value.directory.bots.map((bot) => bot.botId)).toEqual([
+      "beta",
+      "gamma",
+    ]);
+    expect(selected.at(-1)).toBe("beta");
+    expect(new URL(location.href).searchParams.get("bot")).toBe("beta");
+
+    // The same disagreement twice is still one reload.
+    await state.value.refreshUnread();
+    expect(directoryReads).toBe(2);
+  });
+});

package/src/client/index.ts

@@ -122,6 +122,11 @@ export const flockClientPlugin: ClientPlugin = (ctx) => {
   let unreadRefresh: Promise<void> | undefined;
   /** A beat that arrived while one was in flight, replayed once it finishes. */
   let unreadRefreshQueued = false;
+  /**
+   * The last flock the unread read disagreed with, so one disagreement is one
+   * reload and not a reload on every beat.
+   */
+  let reconciledFlockSignature: string | undefined;
 
   /**
    * One unread read at a time, with at most one more behind it.
@@ -383,6 +388,32 @@ export const flockClientPlugin: ClientPlugin = (ctx) => {
       const directory = decodeBotUnreadDirectoryViewV1(
         await request("/api/bots/unread"),
       );
+      // The unread read fans out over the whole non-archived flock, so it is
+      // also this tab's cheapest view of which Bots still exist. A Bot deleted
+      // or created from another tab or the phone leaves this tab's list
+      // stale, and a stale list can keep the conversation open on a Bot the
+      // server no longer has — every read of it answers 404 and the person
+      // cannot chat (2026-09-05: a day-old tab on a deleted Bob). A flock
+      // that differs from the list on screen is read again, which also moves
+      // the selection off a Bot that is gone. One disagreement is one reload.
+      if (state.value.loaded) {
+        const known = new Set(
+          state.value.directory.bots
+            .map((bot) => bot.botId)
+            .filter((botId) => state.value.lifecycles[botId] !== "archived"),
+        );
+        const seen = new Set(directory.unread.map((view) => view.botId));
+        const differs =
+          known.size !== seen.size ||
+          [...seen].some((botId) => !known.has(botId));
+        const signature = [...seen].sort().join("\n");
+        if (differs && signature !== reconciledFlockSignature) {
+          reconciledFlockSignature = signature;
+          await state.value.load();
+          return;
+        }
+        if (!differs) reconciledFlockSignature = undefined;
+      }
       // A Turn that settles in the conversation the User is looking at has
       // been read by the time it arrives, so the badge that counted it is
       // wrong the instant it appears — and painting it for the beat before the