fix(dashboard-agent): pin the investigation cards the transcript actually holds

kathiekiwi · kathiekiwi · commit 0cae30190afe · 2026-08-08T17:03:54.000Z
`collectDurableState` read `data-view` parts only, but `render_view` writes
every investigation card as a `tool-render_view` part, so compaction pinned
nothing and an open card could be summarised away.

It now resolves cards through `latestCards`, the resolver the panel and the
watch actions already use: highest revision per id wins whatever order the
renders arrive in, so a stale `in_progress` render landing after the settling
one no longer reopens a closed card. `latestCards` reads host-written
`data-view` blocks too, matching the panel.
diff --git a/apps/webapp/app/components/dashboard-agent/DashboardAgentMessages.tsx b/apps/webapp/app/components/dashboard-agent/DashboardAgentMessages.tsx
@@ -23,14 +23,65 @@ function viewSpecFor(part: UIMessage["parts"][number]): { blocks: unknown[] } |
   return Array.isArray(p.output?.blocks) ? { blocks: p.output!.blocks! } : null;
 }
 
+function hostViewBlocks(part: UIMessage["parts"][number]): unknown[] | null {
+  const p = part as { type: string; data?: { blocks?: unknown[] } };
+  if (p.type !== "data-view") return null;
+  return Array.isArray(p.data?.blocks) ? p.data!.blocks! : null;
+}
+
+function investigationBlocksFor(part: UIMessage["parts"][number]): unknown[] | null {
+  return viewSpecFor(part)?.blocks ?? hostViewBlocks(part);
+}
+
+type InvestigationRef = { id: string; revision: number };
+
+function investigationRef(block: unknown): InvestigationRef | null {
+  const b = block as { type?: string; id?: string; revision?: number };
+  if (b?.type !== "investigation" || typeof b.id !== "string") return null;
+  return { id: b.id, revision: typeof b.revision === "number" ? b.revision : 0 };
+}
+
+/** Per investigation id, the one `messageId:partIndex` allowed to render: highest revision. */
+export function winningInvestigationOccurrences(messages: UIMessage[]): Map<string, string> {
+  const best = new Map<string, { revision: number; occurrence: string }>();
+  for (const message of messages) {
+    (message.parts ?? []).forEach((part, partIndex) => {
+      for (const block of investigationBlocksFor(part) ?? []) {
+        const ref = investigationRef(block);
+        if (!ref) continue;
+        const current = best.get(ref.id);
+        if (!current || ref.revision >= current.revision) {
+          best.set(ref.id, { revision: ref.revision, occurrence: `${message.id}:${partIndex}` });
+        }
+      }
+    });
+  }
+  return new Map([...best.entries()].map(([id, w]) => [id, w.occurrence]));
+}
+
+function withoutSupersededInvestigations(
+  blocks: unknown[],
+  occurrence: string,
+  winners: Map<string, string> | undefined
+): unknown[] {
+  if (!winners) return blocks;
+  return blocks.filter((block) => {
+    const ref = investigationRef(block);
+    return !ref || winners.get(ref.id) === occurrence;
+  });
+}
+
 // Renders one message. Assistant messages that include a completed render_view
 // part get the catalog cards (plus the gather tool rows / lead-in text for
 // transparency); everything else uses the shared MessageBubble unchanged, so
 // its streaming memoization is preserved for the common case.
 const DashboardAgentMessageBubble = memo(function DashboardAgentMessageBubble({
   message,
+  investigationWinners,
 }: {
   message: UIMessage;
+  /** See {@link winningInvestigationOccurrences}. */
+  investigationWinners?: Map<string, string>;
 }) {
   if (message.role !== "assistant" || !message.parts?.some((p) => viewSpecFor(p))) {
     return <MessageBubble message={message} />;
@@ -39,8 +90,14 @@ const DashboardAgentMessageBubble = memo(function DashboardAgentMessageBubble({
     <div className="space-y-2">
       {message.parts.map((part, i) => {
         const spec = viewSpecFor(part);
-        if (spec) return <ViewBlocks key={i} blocks={spec.blocks as never} />;
-        return renderPart(part, i);
+        if (!spec) return renderPart(part, i);
+        const blocks = withoutSupersededInvestigations(
+          spec.blocks,
+          `${message.id}:${i}`,
+          investigationWinners
+        );
+        if (blocks.length === 0) return null;
+        return <ViewBlocks key={i} blocks={blocks as never} />;
       })}
     </div>
   );
@@ -60,12 +117,17 @@ export function DashboardAgentMessages({
   error?: Error;
 }) {
   const rootRef = useAutoScrollToBottom([messages, isThinking]);
+  const investigationWinners = winningInvestigationOccurrences(messages);
 
   return (
     <div className="flex-1 overflow-y-auto scrollbar-thin scrollbar-track-transparent scrollbar-thumb-surface-control">
       <div ref={rootRef} className="space-y-4 p-4">
         {messages.map((message) => (
-          <DashboardAgentMessageBubble key={message.id} message={stripStepParts(message)} />
+          <DashboardAgentMessageBubble
+            key={message.id}
+            message={stripStepParts(message)}
+            investigationWinners={investigationWinners}
+          />
         ))}
         {isThinking && (
           <div className="flex items-center gap-2 text-sm text-text-dimmed">
diff --git a/apps/webapp/test/dashboardAgentInvestigationWinner.test.ts b/apps/webapp/test/dashboardAgentInvestigationWinner.test.ts
@@ -0,0 +1,80 @@
+import { describe, expect, it } from "vitest";
+import type { UIMessage } from "ai";
+import { winningInvestigationOccurrences } from "~/components/dashboard-agent/DashboardAgentMessages";
+
+/**
+ * The panel half of the pin invariant: the compactor pins the revision the panel
+ * renders, so the transcripts in `compaction.test.ts` are resolved here too. The
+ * message id carries the revision, so the winner names it.
+ */
+function investigationMessage(args: {
+  id: string;
+  title: string;
+  outcome: string;
+  revision?: number;
+}): UIMessage {
+  return {
+    id: `msg-${args.id}-${args.revision ?? 0}`,
+    role: "assistant",
+    parts: [
+      {
+        type: "tool-render_view",
+        toolCallId: `call-${args.id}-${args.revision ?? 0}`,
+        state: "output-available",
+        output: {
+          blocks: [
+            {
+              type: "investigation",
+              id: args.id,
+              revision: args.revision ?? 0,
+              version: 1,
+              investigation: {
+                outcome: args.outcome,
+                severity: "warn",
+                confidence: "medium",
+                title: args.title,
+                headline: `${args.title} — what we have so far.`,
+                hypotheses: [],
+                evidence: [],
+              },
+            },
+          ],
+        },
+      } as never,
+    ],
+  };
+}
+
+describe("the winning revision of an investigation card", () => {
+  it("is the highest revision, not the last render", () => {
+    const winners = winningInvestigationOccurrences([
+      investigationMessage({ id: "inv_1", title: "first pass", outcome: "in_progress" }),
+      investigationMessage({ id: "inv_1", title: "first pass", outcome: "concluded", revision: 3 }),
+      investigationMessage({
+        id: "inv_1",
+        title: "first pass",
+        outcome: "in_progress",
+        revision: 1,
+      }),
+    ]);
+
+    expect(winners.get("inv_1")).toBe("msg-inv_1-3:0");
+  });
+
+  it("resolves a host-written card the same way", () => {
+    const hostCard: UIMessage = {
+      id: "host-inv_2-2",
+      role: "assistant",
+      parts: [
+        {
+          type: "data-view",
+          data: {
+            blocks: [{ type: "investigation", id: "inv_2", revision: 2, version: 1 }],
+          },
+        } as never,
+      ],
+    };
+
+    expect(winningInvestigationOccurrences([hostCard]).get("inv_2")).toBe("host-inv_2-2:0");
+  });
+});
diff --git a/internal-packages/dashboard-agent/src/agent-runtime.ts b/internal-packages/dashboard-agent/src/agent-runtime.ts
@@ -202,12 +202,24 @@ export function settlementCardMessages(
 
 export type TranscriptCard = { id: string; revision: number; state: InvestigationState | null };
 
+/** Both shapes the panel reads: a tool's output blocks, and a host-written view. */
+function blocksInPart(part: unknown): unknown[] {
+  const typed = part as {
+    type?: string;
+    output?: { blocks?: unknown[] };
+    data?: { blocks?: unknown[] };
+  };
+  if (typed.type === "tool-render_view" && Array.isArray(typed.output?.blocks)) {
+    return typed.output.blocks;
+  }
+  if (typed.type === "data-view" && Array.isArray(typed.data?.blocks)) return typed.data.blocks;
+  return [];
+}
+
 function cardsInMessage(message: UIMessage): TranscriptCard[] {
   const found: TranscriptCard[] = [];
   for (const part of message.parts ?? []) {
-    const typed = part as { type?: string; output?: { blocks?: unknown[] } };
-    if (typed.type !== "tool-render_view" || !Array.isArray(typed.output?.blocks)) continue;
-    for (const block of typed.output.blocks) {
+    for (const block of blocksInPart(part)) {
       const candidate = block as { type?: string; id?: string; revision?: number };
       if (candidate?.type !== "investigation" || typeof candidate.id !== "string") continue;
       const parsed = investigationStateSchema.safeParse(
diff --git a/internal-packages/dashboard-agent/src/compaction.test.ts b/internal-packages/dashboard-agent/src/compaction.test.ts
@@ -32,35 +32,67 @@ function bulk(count: number, chars: number): ModelMessage[] {
   );
 }
 
-/** The card, as `render_view` persisted it into the transcript. */
+function investigationBlock(args: {
+  id: string;
+  title: string;
+  outcome: string;
+  revision?: number;
+}) {
+  return {
+    type: "investigation",
+    id: args.id,
+    revision: args.revision ?? 0,
+    version: 1,
+    investigation: {
+      outcome: args.outcome,
+      severity: "warn",
+      confidence: "medium",
+      title: args.title,
+      headline: `${args.title} — what we have so far.`,
+      hypotheses: [],
+      evidence: [],
+    },
+  };
+}
+
+/**
+ * The card as `render_view` persists it: a tool part, which is the only shape
+ * production writes an investigation in.
+ */
 function investigationMessage(args: {
   id: string;
   title: string;
   outcome: string;
   revision?: number;
 }): UIMessage {
   return {
-    id: `msg-${args.id}`,
+    id: `msg-${args.id}-${args.revision ?? 0}`,
     role: "assistant",
     parts: [
       {
-        type: "data-view",
-        data: {
-          blocks: [
-            {
-              type: "investigation",
-              id: args.id,
-              revision: args.revision ?? 0,
-              version: 1,
-              investigation: { title: args.title, outcome: args.outcome },
-            },
-          ],
-        },
+        type: "tool-render_view",
+        toolCallId: `call-${args.id}-${args.revision ?? 0}`,
+        state: "output-available",
+        output: { blocks: [investigationBlock(args)] },
       } as never,
     ],
   };
 }
 
+/** The other shape the panel accepts: a host-written view. */
+function hostInvestigationMessage(args: {
+  id: string;
+  title: string;
+  outcome: string;
+  revision?: number;
+}): UIMessage {
+  return {
+    id: `host-${args.id}-${args.revision ?? 0}`,
+    role: "assistant",
+    parts: [{ type: "data-view", data: { blocks: [investigationBlock(args)] } } as never],
+  };
+}
+
 describe("when the conversation is compacted", () => {
   it("stays under the budget for an ordinary conversation", () => {
     expect(shouldCompactConversation({ messages: bulk(20, 500), inputTokens: 22_000 })).toBe(false);
@@ -120,6 +152,56 @@ describe("the state a summary may not swallow", () => {
     expect(first).toContain("never open a second card");
   });
 
+  it("pins a card written the way render_view writes one", () => {
+    const state = collectDurableState([
+      investigationMessage({
+        id: "inv_tool",
+        title: "orders queue is backing up",
+        outcome: "in_progress",
+        revision: 1,
+      }),
+    ]);
+    expect(state.investigations.map((i) => i.id)).toEqual(["inv_tool"]);
+    expect(
+      describeDurableState([
+        investigationMessage({
+          id: "inv_tool",
+          title: "orders queue is backing up",
+          outcome: "in_progress",
+          revision: 1,
+        }),
+      ])
+    ).toContain("inv_tool");
+  });
+
+  it("pins a card a host view wrote, too", () => {
+    const state = collectDurableState([
+      hostInvestigationMessage({ id: "inv_host", title: "host card", outcome: "in_progress" }),
+    ]);
+    expect(state.investigations.map((i) => i.id)).toEqual(["inv_host"]);
+  });
+
+  it("keeps a settled card closed when a stale render arrives after it", () => {
+    const settledThenStale = [
+      investigationMessage({
+        id: "inv_1",
+        title: "first pass",
+        outcome: "in_progress",
+        revision: 0,
+      }),
+      investigationMessage({ id: "inv_1", title: "first pass", outcome: "concluded", revision: 3 }),
+      // A late replay of an earlier revision: lower, so it loses whatever order it lands in.
+      investigationMessage({
+        id: "inv_1",
+        title: "first pass",
+        outcome: "in_progress",
+        revision: 1,
+      }),
+    ];
+    expect(collectDurableState(settledThenStale).investigations).toEqual([]);
+    expect(describeDurableState(settledThenStale)).toBeUndefined();
+  });
+
   it("pins the freshest revision of one card, not one entry per render", () => {
     const state = collectDurableState([
       investigationMessage({
diff --git a/internal-packages/dashboard-agent/src/compaction.ts b/internal-packages/dashboard-agent/src/compaction.ts
