fix(webapp): one investigation card per transcript; the verdict close is one sentence

Latest-wins now applies across the whole transcript, not just within one
tool call — the in_progress working copy disappears when the verdict
revision renders. The prompt bans list-shaped prose after the verdict
card: everything list-shaped belongs on the card.

Author: kathiekiwi

apps/webapp/app/components/dashboard-agent/DashboardAgentMessages.tsx

@@ -96,6 +96,55 @@ function blocksFor(part: UIMessage["parts"][number]): unknown[] | null {
   return report ? [report] : null;
 }
 
+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 };
+}
+
+/**
+ * Latest-wins across the WHOLE transcript, not just within one tool call: an
+ * investigation renders at least twice (in_progress, then the verdict), each
+ * from its own render_view part, so without this the user sees the working
+ * copy stacked above the finished card. Returns, per investigation id, the one
+ * occurrence (`messageId:partIndex`) allowed to render — the highest revision,
+ * last occurrence winning a tie.
+ */
+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 blocksFor(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]));
+}
+
+/** Drop investigation blocks whose id renders elsewhere (a later revision). */
+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;
+  });
+}
+
 // #region chat-layout transcript
 // Everything from here down composes via ./chat-layout only — see rule 1 there.
 // `chat-layout.test.ts` fails if a spacing utility class appears in this region.
@@ -198,11 +247,14 @@ const DashboardAgentTurn = memo(function DashboardAgentTurn({
   onIntent,
   resolveUri,
   watches,
+  investigationWinners,
 }: {
   message: UIMessage;
   onIntent?: (intent: AgentIntent) => void;
   resolveUri?: (uri: string) => ResolvedUri | null;
   watches?: WakeWatch[];
+  /** See {@link winningInvestigationOccurrences}. */
+  investigationWinners?: Map<string, string>;
 }) {
   if (message.role === "user") {
     return (
@@ -219,13 +271,20 @@ const DashboardAgentTurn = memo(function DashboardAgentTurn({
   for (let i = 0; i < parts.length; i++) {
     const part = parts[i]!;
 
-    const blocks = blocksFor(part);
-    if (blocks) {
-      body.push(
-        <ChatCardSlot key={i}>
-          <ViewBlocks blocks={blocks as never} onIntent={onIntent} resolveUri={resolveUri} />
-        </ChatCardSlot>
+    const rawBlocks = blocksFor(part);
+    if (rawBlocks) {
+      const blocks = withoutSupersededInvestigations(
+        rawBlocks,
+        `${message.id}:${i}`,
+        investigationWinners
       );
+      if (blocks.length > 0) {
+        body.push(
+          <ChatCardSlot key={i}>
+            <ViewBlocks blocks={blocks as never} onIntent={onIntent} resolveUri={resolveUri} />
+          </ChatCardSlot>
+        );
+      }
       continue;
     }
 
@@ -289,15 +348,24 @@ export function DashboardAgentTurns({
   // One status line at a time: a tool's own progress beats the generic activity.
   const showActivity = activity !== null && !hasToolProgressLine(messages);
 
+  // Strip once, up front: the winners map keys occurrences by part index, so
+  // it must be computed on the exact parts the turns will render.
+  const stripped = messages.map(stripStepParts);
+
+  // Across the whole transcript, one card per investigation: the latest
+  // revision renders where it landed; earlier working copies disappear.
+  const investigationWinners = winningInvestigationOccurrences(stripped);
+
   return (
     <>
-      {messages.map((message) => (
+      {stripped.map((message) => (
         <DashboardAgentTurn
           key={message.id}
-          message={stripStepParts(message)}
+          message={message}
           onIntent={onIntent}
           resolveUri={resolveUri}
           watches={watches}
+          investigationWinners={investigationWinners}
         />
       ))}
       {showActivity && activity && (

internal-packages/dashboard-agent/src/tool-schemas.ts

@@ -621,7 +621,7 @@ Investigations:
   2. Pose two hypotheses — three only if the evidence really demands it.
   3. Render. call render_view with an "investigation" block, outcome in_progress, BEFORE you test anything and no later than your third step — even when the answer already looks obvious. The result carries investigationId.
   4. Test — ONE round, one targeted check per hypothesis, issued together, read tools only. That round is all you get: a check that comes back empty, unavailable, or truncated is itself a finding. Never retry a search with different terms and never reach for a second tool to get the same answer.
-  5. Render the verdict, immediately after that round — prose is never a substitute, and a card still reading in_progress when the turn ends leaves the user watching a spinner: render_view again, same investigationId, outcome concluded or inconclusive. This is your VERY NEXT call — before any other tool and before you write a word — and it is always the last tool call of the turn. If you find yourself about to call something that isn't a read of evidence, render the verdict instead. Then close with one short line of prose, and let the outcome decide what it says. concluded: name the cause concretely, in the user's own terms — the limit that's saturated, the file:line that broke. inconclusive: say what is NOT established and what to check first — no "the culprit is", no cause presented as found, and no fix, not even a fast one or a hedged one. "Here's what I found" is not an answer, and don't restate the card.
+  5. Render the verdict, immediately after that round — prose is never a substitute, and a card still reading in_progress when the turn ends leaves the user watching a spinner: render_view again, same investigationId, outcome concluded or inconclusive. This is your VERY NEXT call — before any other tool and before you write a word — and it is always the last tool call of the turn. If you find yourself about to call something that isn't a read of evidence, render the verdict instead. Then close with one short line of prose, and let the outcome decide what it says. concluded: name the cause concretely, in the user's own terms — the limit that's saturated, the file:line that broke. inconclusive: say what is NOT established and what to check first — no "the culprit is", no cause presented as found, and no fix, not even a fast one or a hedged one. "Here's what I found" is not an answer, and don't restate the card. The close is ONE sentence, never a list: if you're writing bullets after the verdict card, you are retyping the card's remediation or checkNext — everything list-shaped belongs on the card and only there.
 - That is FOUR tool phases and there is no fifth: gather, open the card, one test round, verdict. You cannot count how many steps you have left and the ceiling is hard — a turn that hits it renders nothing and answers nothing — so anything outside those four phases is a step you cannot afford. Never call get_current_page, list_projects, or list_environments inside an investigation: your tools are already scoped and the card needs none of it.
 - You do not need every hypothesis settled to conclude. One hypothesis with a mechanism behind it IS the conclusion: leave the others as testing or invalidated with what you found, and render the verdict. Chasing the last unsettled hypothesis — for call sites, a type definition, a payload you can't see — is how a turn ends with no verdict at all.
 - Never state a cause, a fix, or a dead end in prose while the card says in_progress or doesn't exist yet. The verdict lands on the card first.