fix(webapp,dashboard-agent): keep investigation cards, and stop a broken request reading as an answer

An investigation card could vanish from a reply that contained step
separators: the winning revision was keyed by its position in the
untouched reply, while rendering walked the stripped parts. Both now
index the same stripped list.

A host-written `data-view` card counted towards winning a revision but
was never drawn as a card, so it could suppress the tool-rendered card
it competed with into nothing. Both carriers now render.

`apiGet` left `fetch` and `res.json()` unguarded, so a connection reset
threw out of the tool, and a transport failure that did land could read
as a definite 404. It now returns a transport failure the way the
sibling paths do.

Also: guard the card's Hypotheses section on length, as Evidence
already is, and move the reports auth resource out of the serializer so
rendering a report doesn't pull the route builder in.

Author: kathiekiwi

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

@@ -29,7 +29,10 @@ function hostViewBlocks(part: UIMessage["parts"][number]): unknown[] | null {
   return Array.isArray(p.data?.blocks) ? p.data!.blocks! : null;
 }
 
-function investigationBlocksFor(part: UIMessage["parts"][number]): unknown[] | null {
+// Both carriers render as cards, so whichever one wins a revision is one the panel
+// can actually draw — a host-written card can never suppress a tool-rendered one
+// into nothing.
+function viewBlocksFor(part: UIMessage["parts"][number]): unknown[] | null {
   return viewSpecFor(part)?.blocks ?? hostViewBlocks(part);
 }
 
@@ -41,12 +44,15 @@ function investigationRef(block: unknown): InvestigationRef | 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. */
+/**
+ * Per investigation id, the one `messageId:partIndex` allowed to render: highest revision.
+ * Indexed over the same stripped parts the renderer walks, so the two agree on what part 0 is.
+ */
 export function winningInvestigationOccurrences(messages: UIMessage[]): Map<string, string> {
   const best = new Map<string, { revision: number; occurrence: string }>();
-  for (const message of messages) {
+  for (const message of messages.map(stripStepParts)) {
     (message.parts ?? []).forEach((part, partIndex) => {
-      for (const block of investigationBlocksFor(part) ?? []) {
+      for (const block of viewBlocksFor(part) ?? []) {
         const ref = investigationRef(block);
         if (!ref) continue;
         const current = best.get(ref.id);
@@ -71,37 +77,41 @@ function withoutSupersededInvestigations(
   });
 }
 
-// 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({
+// Renders one message. Assistant messages carrying a view spec 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.
+export function DashboardAgentMessageBubble({
   message,
   investigationWinners,
 }: {
   message: UIMessage;
   /** See {@link winningInvestigationOccurrences}. */
   investigationWinners?: Map<string, string>;
 }) {
-  if (message.role !== "assistant" || !message.parts?.some((p) => viewSpecFor(p))) {
+  if (message.role !== "assistant" || !message.parts?.some((p) => viewBlocksFor(p))) {
     return <MessageBubble message={message} />;
   }
   return (
     <div className="space-y-2">
       {message.parts.map((part, i) => {
-        const spec = viewSpecFor(part);
+        const spec = viewBlocksFor(part);
         if (!spec) return renderPart(part, i);
         const blocks = withoutSupersededInvestigations(
-          spec.blocks,
+          spec,
           `${message.id}:${i}`,
           investigationWinners
         );
         if (blocks.length === 0) return null;
+        // No `onIntent`: nothing here can act on one yet, so the cards drop their
+        // action rows rather than offer buttons that would do nothing.
         return <ViewBlocks key={i} blocks={blocks as never} />;
       })}
     </div>
   );
-});
+}
+
+const MemoizedMessageBubble = memo(DashboardAgentMessageBubble);
 
 // Renders the conversation with the shared agent message renderer — the same
 // MessageBubble the run inspector and playground use, so agent output looks
@@ -123,7 +133,7 @@ export function DashboardAgentMessages({
     <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
+          <MemoizedMessageBubble
             key={message.id}
             message={stripStepParts(message)}
             investigationWinners={investigationWinners}

apps/webapp/app/components/dashboard-agent/InvestigationCard.render.test.ts

@@ -0,0 +1,89 @@
+import type { InvestigationBlock } from "@internal/dashboard-agent-contracts";
+import { createElement } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { describe, expect, it } from "vitest";
+import { OperatingSystemContextProvider } from "~/components/primitives/OperatingSystemProvider";
+import { ShortcutsProvider } from "~/components/primitives/ShortcutsProvider";
+import { InvestigationCard } from "./InvestigationCard";
+
+/**
+ * What the card actually puts on the page, rather than what its source says. Static markup,
+ * so it proves the rendered output and nothing about interaction: a click is not exercised.
+ */
+
+const HYPOTHESIS = {
+  id: "h1",
+  statement: "The receipt builder is handed a null order id.",
+  verdict: "validated" as const,
+  evidence: [],
+};
+
+function block(overrides: {
+  hypotheses?: InvestigationBlock["investigation"]["hypotheses"];
+  actions?: NonNullable<InvestigationBlock["capabilities"]>["actions"];
+}): InvestigationBlock {
+  return {
+    type: "investigation",
+    id: "inv_1",
+    revision: 0,
+    version: 1,
+    investigation: {
+      outcome: "concluded",
+      severity: "crit",
+      confidence: "high",
+      title: "send-order-receipt fails on every retry",
+      headline: "Every attempt dies on a null order id.",
+      remediation: "Guard the receipt builder against a missing order.",
+      hypotheses: overrides.hypotheses ?? [],
+      evidence: [],
+    },
+    ...(overrides.actions
+      ? { capabilities: { version: 1, actions: overrides.actions } }
+      : undefined),
+  } as InvestigationBlock;
+}
+
+// The Button primitive reads both of these for its shortcut hints.
+function markup(props: Parameters<typeof InvestigationCard>[0]) {
+  return renderToStaticMarkup(
+    createElement(
+      OperatingSystemContextProvider,
+      { platform: "mac" },
+      createElement(ShortcutsProvider, null, createElement(InvestigationCard, props))
+    )
+  );
+}
+
+describe("the card's sections appear only when they have something in them", () => {
+  it("leaves out an empty Hypotheses heading, the way Evidence already does", () => {
+    const html = markup({ block: block({}), defaultExpanded: true });
+    expect(html).not.toContain("Hypotheses");
+    expect(html).not.toContain("Evidence");
+  });
+
+  it("shows the heading once there is a hypothesis under it", () => {
+    const html = markup({ block: block({ hypotheses: [HYPOTHESIS] }), defaultExpanded: true });
+    expect(html).toContain("Hypotheses");
+    expect(html).toContain("The receipt builder is handed a null order id.");
+  });
+});
+
+describe("action buttons need a host to hand the intent to", () => {
+  const actions = [
+    {
+      kind: "ask_follow_up" as const,
+      label: "Keep digging",
+      intent: { kind: "ask" as const, prompt: "Keep digging into the receipt failures." },
+    },
+  ];
+
+  it("renders no button when the host passes no onIntent, rather than a dead one", () => {
+    const html = markup({ block: block({ actions }), defaultExpanded: true });
+    expect(html).not.toContain("Keep digging");
+  });
+
+  it("renders the same action once a host can act on it", () => {
+    const html = markup({ block: block({ actions }), defaultExpanded: true, onIntent: () => {} });
+    expect(html).toContain("Keep digging");
+  });
+});

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

@@ -215,17 +215,19 @@ export function InvestigationCard({
 
           {expanded ? (
             <div className="space-y-5 pt-1">
-              <Section title="Hypotheses">
-                <ul className="space-y-5">
-                  {investigation.hypotheses.map((hypothesis) => (
-                    <HypothesisRow
-                      key={hypothesis.id}
-                      hypothesis={hypothesis}
-                      resolveUri={resolveUri}
-                    />
-                  ))}
-                </ul>
-              </Section>
+              {investigation.hypotheses.length > 0 ? (
+                <Section title="Hypotheses">
+                  <ul className="space-y-5">
+                    {investigation.hypotheses.map((hypothesis) => (
+                      <HypothesisRow
+                        key={hypothesis.id}
+                        hypothesis={hypothesis}
+                        resolveUri={resolveUri}
+                      />
+                    ))}
+                  </ul>
+                </Section>
+              ) : null}
 
               {investigation.evidence.length > 0 ? (
                 <Section title="Evidence">

apps/webapp/app/presenters/v3/reports/reportsApi.server.ts

@@ -2,10 +2,8 @@
 import { json } from "@remix-run/server-runtime";
 import { ReportFormatSchema, ReportPeriodSchema } from "@trigger.dev/core/v3/schemas";
 import { z } from "zod";
-import { reportQueryTables } from "~/presenters/v3/reports/report-registry";
 import { renderReportAnsi, renderReportMarkdown } from "~/presenters/v3/reports/renderMarkdown";
 import { type ReportViewModel } from "~/presenters/v3/reports/report-view-model";
-import { everyResource } from "~/services/routeBuilders/apiBuilder.server";
 
 export const ReportParamsSchema = z.object({
   key: z.string(),
@@ -36,11 +34,3 @@ export function reportResponse(vm: ReportViewModel, format: ReportFormatParam):
       });
   }
 }
-
-/**
- * Per-table, not the permissive `{ type: "query", id: "all" }`: a JWT must be scoped to every table
- * the report reads, so a partially scoped token can't reach the others.
- */
-export function reportAuthResource(key: string) {
-  return everyResource(reportQueryTables(key).map((id) => ({ type: "query", id })));
-}

apps/webapp/app/presenters/v3/reports/reportsApiAuth.server.ts

@@ -0,0 +1,12 @@
+// Apart from `reportsApi.server.ts` so that rendering a report doesn't drag the route
+// builder — and `env.server` behind it — into everything that serializes one.
+import { reportQueryTables } from "~/presenters/v3/reports/report-registry";
+import { everyResource } from "~/services/routeBuilders/apiBuilder.server";
+
+/**
+ * Per-table, not the permissive `{ type: "query", id: "all" }`: a JWT must be scoped to every table
+ * the report reads, so a partially scoped token can't reach the others.
+ */
+export function reportAuthResource(key: string) {
+  return everyResource(reportQueryTables(key).map((id) => ({ type: "query", id })));
+}

apps/webapp/app/routes/api.v1.dashboard-agent.eval-policy.ts

@@ -12,6 +12,9 @@ import { authenticateUatOrApiRequest } from "~/services/uatRoutePreamble.server"
 
 const QuerySchema = z.object({ organizationId: z.string().min(1) });
 
+// obs-map-disable request-context -- the only call here that can throw catches its own failure
+// and logs it with organizationId, in dashboardAgentEvalPolicy.server.ts; the rest are early
+// returns, and the one failure that does reach the boundary is auth, where no tenant is known yet.
 export async function loader({ request }: LoaderFunctionArgs) {
   const authentication = await authenticateUatOrApiRequest(request);
   if (!authentication?.userActor) {

apps/webapp/app/routes/api.v1.reports.$key.ts

@@ -4,9 +4,9 @@ import { isReportKey, REPORT_KEYS } from "~/presenters/v3/reports/report-registr
 import {
   ReportParamsSchema,
   ReportSearchParamsSchema,
-  reportAuthResource,
   reportResponse,
 } from "~/presenters/v3/reports/reportsApi.server";
+import { reportAuthResource } from "~/presenters/v3/reports/reportsApiAuth.server";
 import { logger } from "~/services/logger.server";
 import { createLoaderApiRoute } from "~/services/routeBuilders/apiBuilder.server";
 

apps/webapp/test/dashboardAgentMessageCards.test.ts

@@ -0,0 +1,108 @@
+import type { UIMessage } from "ai";
+import { describe, expect, it } from "vitest";
+import {
+  DashboardAgentMessageBubble,
+  winningInvestigationOccurrences,
+} from "~/components/dashboard-agent/DashboardAgentMessages";
+
+/**
+ * The two halves of card rendering that have to agree: which occurrence of an investigation
+ * wins, and which part index the renderer is standing on when it asks. Structural — these call
+ * the component as a function and read the returned element tree, so they prove what is handed
+ * to `ViewBlocks`, not what the browser paints.
+ */
+
+function investigationBlock(id: string, revision: number) {
+  return {
+    type: "investigation",
+    id,
+    revision,
+    version: 1,
+    investigation: {
+      outcome: "concluded",
+      severity: "warn",
+      confidence: "medium",
+      title: id,
+      headline: `${id} — what we have so far.`,
+      hypotheses: [],
+      evidence: [],
+    },
+  };
+}
+
+const stepStart = { type: "step-start" } as never;
+
+function toolCard(id: string, revision: number) {
+  return {
+    type: "tool-render_view",
+    toolCallId: `call-${id}-${revision}`,
+    state: "output-available",
+    output: { blocks: [investigationBlock(id, revision)] },
+  } as never;
+}
+
+function hostCard(id: string, revision: number) {
+  return { type: "data-view", data: { blocks: [investigationBlock(id, revision)] } } as never;
+}
+
+function message(id: string, parts: UIMessage["parts"]): UIMessage {
+  return { id, role: "assistant", parts };
+}
+
+/** Every `ViewBlocks` element in the rendered tree, with the blocks it was handed. */
+function renderedBlocks(node: unknown): unknown[][] {
+  const found: unknown[][] = [];
+  const walk = (value: unknown) => {
+    if (Array.isArray(value)) return value.forEach(walk);
+    const element = value as { props?: { blocks?: unknown[]; children?: unknown } } | null;
+    if (!element || typeof element !== "object") return;
+    if (Array.isArray(element.props?.blocks)) found.push(element.props.blocks);
+    if (element.props?.children) walk(element.props.children);
+  };
+  walk(node);
+  return found;
+}
+
+function renderBubble(msg: UIMessage, winners?: Map<string, string>) {
+  return renderedBlocks(
+    DashboardAgentMessageBubble({ message: msg, investigationWinners: winners })
+  );
+}
+
+describe("the winner's part index and the renderer's part index are the same index", () => {
+  it("counts the parts the renderer walks, not the ones it drops", () => {
+    // The step separator is stripped before rendering, so the card is part 0 on screen.
+    const withSeparator = message("msg-1", [stepStart, toolCard("inv_1", 0)]);
+    expect(winningInvestigationOccurrences([withSeparator]).get("inv_1")).toBe("msg-1:0");
+  });
+
+  it("keeps the card a reply with step separators would otherwise lose", () => {
+    const withSeparator = message("msg-1", [stepStart, toolCard("inv_1", 0)]);
+    const winners = winningInvestigationOccurrences([withSeparator]);
+
+    // What DashboardAgentMessages renders: the stripped message, against those winners.
+    const stripped = message("msg-1", [toolCard("inv_1", 0)]);
+    const blocks = renderBubble(stripped, winners);
+
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0]).toHaveLength(1);
+  });
+});
+
+describe("a host-written card and a tool-rendered card compete on equal terms", () => {
+  it("renders a host-written card, so winning one cannot mean rendering nothing", () => {
+    const blocks = renderBubble(message("msg-host", [hostCard("inv_2", 1)]));
+    expect(blocks).toHaveLength(1);
+    expect((blocks[0][0] as { id: string }).id).toBe("inv_2");
+  });
+
+  it("drops the superseded revision and keeps the winner, whichever carrier it arrived in", () => {
+    const older = message("msg-tool", [toolCard("inv_3", 1)]);
+    const newer = message("msg-host", [hostCard("inv_3", 2)]);
+    const winners = winningInvestigationOccurrences([older, newer]);
+
+    expect(winners.get("inv_3")).toBe("msg-host:0");
+    expect(renderBubble(older, winners)).toHaveLength(0);
+    expect(renderBubble(newer, winners)).toHaveLength(1);
+  });
+});