fix(investigations): Hide the raw JSON query answer from the transcript (#123162)

A query block's final answer is always a single raw JSON object (per
`QUERY_INSTRUCTIONS` in `agent.py`) meant to be parsed into a
chart/table — never prose meant to be read as-is. The Seer transcript
rendered it as a plain assistant message anyway: a wall of partial JSON
while it streamed in, then a redundant full JSON dump once the parsed
result was already showing above it in `QueryResult`.

- While the structured result is still streaming in, the transcript now
shows `Building chart…` instead of the raw partial JSON.
- Once it settles, the row is dropped entirely — `QueryResult` already
renders the parsed chart or table for it.
- A query block's inline clarification questions (plain markdown, never
JSON) are unaffected — detection is keyed on the message starting with
`{`.

---------

Co-authored-by: Cursor Agent <cursoragent@cursor.com>

Author: natemoo-re

static/app/views/investigations/detail/cell.tsx

@@ -37,6 +37,7 @@ import {
 } from 'sentry/views/investigations/api';
 import type {
   InvestigationBlock,
+  InvestigationBlockKind,
   InvestigationDetail,
   InvestigationExecutionDetail,
   InvestigationExecutionStatus,
@@ -46,6 +47,7 @@ import type {
 import {visibleCallRecords} from 'sentry/views/seerExplorer/callRecords';
 import {AskUserQuestionBlock} from 'sentry/views/seerExplorer/components/askUserQuestionBlock';
 import {BlockComponent} from 'sentry/views/seerExplorer/components/chat';
+import {MessagePlaceholder} from 'sentry/views/seerExplorer/components/chat/shared';
 import {usePendingUserInput} from 'sentry/views/seerExplorer/hooks/usePendingUserInput';
 import type {Block} from 'sentry/views/seerExplorer/types';
 
@@ -732,6 +734,7 @@ function RefinementPanel({
       <RefinementDisclosureContent>
         <Stack gap="md">
           <Transcript
+            blockKind={block.kind}
             blocks={execution?.blocks ?? []}
             completedAt={currentExecution?.completedAt ?? null}
             active={active}
@@ -867,17 +870,22 @@ function PendingInvestigationQuestion({
 
 function Transcript({
   active,
+  blockKind,
   blocks,
   completedAt,
 }: {
   active: boolean;
+  blockKind: InvestigationBlockKind;
   blocks: InvestigationTranscriptBlock[];
   completedAt: string | null;
 }) {
   const now = useNow(active);
   const visibleBlocks = useMemo(
-    () => blocks.filter(isRenderableTranscriptBlock),
-    [blocks]
+    () =>
+      blocks.filter((block, index) =>
+        isRenderableTranscriptBlock(block, index, blockKind)
+      ),
+    [blocks, blockKind]
   );
   const explorerBlocks = useMemo(
     () => visibleBlocks.map(adaptTranscriptBlock),
@@ -897,18 +905,33 @@ function Transcript({
       data-test-id="investigation-transcript"
     >
       {explorerBlocks.map((block, index) => {
+        const currentVisibleBlock = visibleBlocks[index];
+        if (!currentVisibleBlock) {
+          return null;
+        }
         const end =
           visibleBlocks[index + 1]?.timestamp ?? completedAt ?? (active ? now : null);
         const duration = getElapsedMilliseconds(block.timestamp, end);
+        // Still streaming in: the raw JSON is unreadable as prose, so this row is rendered as a
+        // plain loading placeholder instead of routing it through `BlockComponent`, which would
+        // otherwise show it as assistant markdown. `isRenderableTranscriptBlock` drops the row
+        // outright once the object is complete, since `QueryResult` above already renders it.
+        const isBuildingChart =
+          currentVisibleBlock.loading &&
+          isStructuredQueryResultBlock(currentVisibleBlock, blockKind);
         return (
           <Grid key={block.id} columns="minmax(0, 1fr) auto" align="start" gap="md">
-            <BlockComponent
-              block={block}
-              blockIndex={index}
-              blocks={explorerBlocks}
-              readOnly
-              showThinking
-            />
+            {isBuildingChart ? (
+              <MessagePlaceholder content={t('Building chart…')} />
+            ) : (
+              <BlockComponent
+                block={block}
+                blockIndex={index}
+                blocks={explorerBlocks}
+                readOnly
+                showThinking
+              />
+            )}
             {duration === null ? null : <ElapsedDuration milliseconds={duration} />}
           </Grid>
         );
@@ -926,10 +949,36 @@ function isInternalPromptBlock(block: InvestigationTranscriptBlock, index: numbe
   );
 }
 
-function isRenderableTranscriptBlock(block: InvestigationTranscriptBlock, index: number) {
+/**
+ * A query block's final answer is always a single raw JSON object (see `QUERY_INSTRUCTIONS` in
+ * `agent.py`), never prose meant to be read as-is — `QueryResult` above already renders its
+ * parsed chart or table. Detected by role and a `{` prefix so a legitimate inline clarification
+ * question (plain markdown, never JSON) still renders normally.
+ */
+function isStructuredQueryResultBlock(
+  block: InvestigationTranscriptBlock,
+  blockKind: InvestigationBlockKind
+): boolean {
+  return (
+    blockKind === 'query' &&
+    block.message.role === 'assistant' &&
+    Boolean(block.message.content?.trim().startsWith('{'))
+  );
+}
+
+function isRenderableTranscriptBlock(
+  block: InvestigationTranscriptBlock,
+  index: number,
+  blockKind: InvestigationBlockKind
+) {
   if (isInternalPromptBlock(block, index)) {
     return false;
   }
+  // Once it has finished streaming, this is the redundant raw JSON dump described above — the
+  // rendered chart/table already stands in for it, so the row is dropped rather than shown.
+  if (!block.loading && isStructuredQueryResultBlock(block, blockKind)) {
+    return false;
+  }
   if (block.loading || block.message.content?.trim()) {
     return true;
   }

static/app/views/investigations/detail/index.spec.tsx

@@ -1287,6 +1287,116 @@ describe('Investigation detail', () => {
     expect(screen.getByLabelText('Instructions for Seer')).toHaveValue('');
   });
 
+  it('shows "Building chart…" for a query block\'s in-progress structured result instead of raw JSON', async () => {
+    const investigation = InvestigationDetailFixture();
+    MockApiClient.addMockResponse({url: detailUrl, body: investigation});
+    const blockUrl = `${detailUrl}blocks/block-2/`;
+    MockApiClient.addMockResponse({
+      url: blockUrl,
+      method: 'PUT',
+      body: {...investigation.blocks[1]!, version: 2},
+    });
+    const runUrl = `${blockUrl}executions/`;
+    MockApiClient.addMockResponse({
+      url: runUrl,
+      method: 'POST',
+      body: {id: 'execution-building', status: 'running'},
+    });
+    MockApiClient.addMockResponse({
+      url: `${runUrl}execution-building/`,
+      body: {
+        id: 'execution-building',
+        status: 'running',
+        blocks: [
+          {
+            id: 'step-1',
+            timestamp: '2026-08-18T20:00:01Z',
+            loading: true,
+            message: {
+              role: 'assistant',
+              content: '{"tableMarkdown":"| Fact | Value |\\n|---|---|\\n| Monit',
+            },
+            artifacts: [],
+            toolLinks: null,
+            toolResults: null,
+          },
+        ],
+        transcriptTruncated: false,
+        pendingUserInput: null,
+        partialMarkdown: null,
+        error: null,
+      },
+    });
+
+    renderView();
+    await chooseCellAction('Latency query', 'Refine');
+    await userEvent.type(
+      screen.getByLabelText('Instructions for Seer'),
+      'Find slow spans'
+    );
+    fireEvent.keyDown(screen.getByLabelText('Instructions for Seer'), {key: 'Enter'});
+
+    expect(await screen.findByText('Building chart…')).toBeInTheDocument();
+    expect(screen.queryByText(/tableMarkdown/)).not.toBeInTheDocument();
+  });
+
+  it("hides a query block's completed structured result from the transcript, not just while streaming", async () => {
+    const investigation = InvestigationDetailFixture();
+    MockApiClient.addMockResponse({url: detailUrl, body: investigation});
+    const blockUrl = `${detailUrl}blocks/block-2/`;
+    MockApiClient.addMockResponse({
+      url: blockUrl,
+      method: 'PUT',
+      body: {...investigation.blocks[1]!, version: 2},
+    });
+    const runUrl = `${blockUrl}executions/`;
+    MockApiClient.addMockResponse({
+      url: runUrl,
+      method: 'POST',
+      body: {id: 'execution-built', status: 'running'},
+    });
+    MockApiClient.addMockResponse({
+      url: `${runUrl}execution-built/`,
+      body: {
+        id: 'execution-built',
+        status: 'completed',
+        blocks: [
+          {
+            id: 'step-1',
+            timestamp: '2026-08-18T20:00:04Z',
+            loading: false,
+            message: {
+              role: 'assistant',
+              content:
+                '{"tableMarkdown":"| Fact | Value |","chart":null,"preferredView":"table","isEmpty":false,"chartUnavailableReason":null}',
+            },
+            artifacts: [],
+            toolLinks: null,
+            toolResults: null,
+          },
+        ],
+        transcriptTruncated: false,
+        pendingUserInput: null,
+        partialMarkdown: null,
+        error: null,
+      },
+    });
+
+    renderView();
+    await chooseCellAction('Latency query', 'Refine');
+    await userEvent.type(
+      screen.getByLabelText('Instructions for Seer'),
+      'Find slow spans'
+    );
+    fireEvent.keyDown(screen.getByLabelText('Instructions for Seer'), {key: 'Enter'});
+
+    // The transcript renders once the block settles, but the raw JSON answer is dropped —
+    // `QueryResult` above already presents its parsed chart/table.
+    expect(await screen.findByText('No steps')).toBeInTheDocument();
+    expect(screen.queryByText(/tableMarkdown/)).not.toBeInTheDocument();
+    expect(screen.queryByText('Building chart…')).not.toBeInTheDocument();
+  });
+
   it('stops an active refinement and leaves the rendered result visible', async () => {
     const investigation = InvestigationDetailFixture();
     investigation.blocks = [