@frockbot/plugin-shell 0.3.6 → 0.3.8

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