fix(investigations): Preserve query context through refinement

src/sentry/investigations/agent.py

@@ -26,7 +26,10 @@
     InvestigationStatus,
 )
 from sentry.investigations.services.auto_run import schedule_eligible_auto_run_blocks
-from sentry.investigations.services.executions import mark_block_execution_dispatched
+from sentry.investigations.services.executions import (
+    freeze_query_links,
+    mark_block_execution_dispatched,
+)
 from sentry.investigations.services.investigations import (
     DEFAULT_INVESTIGATION_TITLE,
     investigation_source,
@@ -123,6 +126,17 @@ class TitleGenerationStatus(StrEnum):
 When notebookContext contains an item with currentBlock=true, it is the last successful result for
 the block being refined. Reuse its table and chart data for presentation-only requests such as
 changing line, area, or bar visualization; do not claim the data is unavailable or query it again.
+Keep the same measurements, filters, and time window when changing presentation. For a query
+change such as a different grouping, use the absolute start/end in that result's queryLinks.
+The current block's queryContext preserves its original source, filters, and parameters when
+query links are unavailable; its source may contain timeRange or an analysisWindow, either
+directly or inside snapshot. These saved settings take precedence over current page filters.
+Include the exact start/end timestamps in every new telemetry question. Change the time window
+only when the user's new request explicitly asks for a different period. Never reinterpret an
+old "last 6 days" label relative to today or infer a query window from the first/last chart point.
+If the original window is unavailable, reuse the saved data for presentation changes and ask
+for the window before querying again. Preserve the current result if a requested transformation
+cannot be performed from its saved data.
 The first character must be { and the last character must be }.
 Do not wrap the object in a Markdown code fence or include prose before or after it. Do not call any function to
 write or save the result. tableMarkdown must be a complete Markdown table (or an empty table). When
@@ -876,7 +890,20 @@ def synchronize_execution(execution: InvestigationBlockExecution, state: SeerRun
                 links, projects = _successful_links_and_projects(
                     state, execution.block.investigation.organization
                 )
-                result["queryLinks"] = links
+                if links:
+                    result["queryLinks"] = freeze_query_links(
+                        links, reference_time=execution.started_at or execution.date_added
+                    )
+                else:
+                    previous_result: dict[str, Any] = next(
+                        (
+                            item["result"]
+                            for item in execution.input_snapshot.get("context", [])
+                            if item.get("currentBlock") is True
+                        ),
+                        {},
+                    )
+                    result["queryLinks"] = previous_result.get("queryLinks", [])
                 result = validate_query_result(result)
                 allowed_project_ids = set(execution.input_snapshot.get("projectIds", []))
                 queried_project_ids = {project.id for project in projects}

src/sentry/investigations/services/executions.py

@@ -36,6 +36,7 @@
 from sentry.investigations.telemetry import record_execution_cancelled
 from sentry.models.project import Project
 from sentry.utils import json
+from sentry.utils.dates import parse_stats_period
 
 MAX_CONTEXT_BLOCKS = 20
 MAX_CONTEXT_TEXT_CHARS = 50_000
@@ -48,6 +49,35 @@ def _fingerprint(snapshot: dict[str, Any]) -> str:
     return hashlib.sha256(serialized.encode()).hexdigest()
 
 
+def freeze_query_time_range(params: dict[str, Any], *, reference_time: datetime) -> dict[str, Any]:
+    """Anchor relative windows to the execution that produced the saved data."""
+    frozen = dict(params)
+    if not (frozen.get("start") and frozen.get("end")):
+        period = frozen.get("stats_period") or frozen.get("statsPeriod")
+        if not isinstance(period, str) or frozen.get("start") or frozen.get("end"):
+            return frozen
+        duration = parse_stats_period(period)
+        if duration is None or duration <= timedelta():
+            return frozen
+        try:
+            start = reference_time - duration
+        except OverflowError:
+            return frozen
+        frozen.update(start=start.isoformat(), end=reference_time.isoformat())
+    frozen.pop("stats_period", None)
+    frozen.pop("statsPeriod", None)
+    return frozen
+
+
+def freeze_query_links(
+    links: list[dict[str, Any]], *, reference_time: datetime
+) -> list[dict[str, Any]]:
+    return [
+        {**link, "params": freeze_query_time_range(link["params"], reference_time=reference_time)}
+        for link in links
+    ]
+
+
 def _compact_query_context(
     result: Any, *, max_text_chars: int = MAX_CONTEXT_TEXT_CHARS
 ) -> dict[str, Any]:
@@ -272,6 +302,8 @@ def build_block_execution_snapshot(
             raise InvestigationValidationError({"detail": "The template dataset hint is invalid."})
 
     prompt = (block.prompt or block.content).strip()
+    source = investigation_source(block.investigation)
+    filters = investigation_filters(block.investigation)
     parameters: dict[str, Any] = {}
     for link in block.parameter_links.select_related("parameter").order_by("parameter__key"):
         parameter = link.parameter
@@ -290,6 +322,7 @@ def build_block_execution_snapshot(
             except ParameterValidationError as error:
                 raise InvestigationValidationError({"parameters": {parameter.key: str(error)}})
         parameters[parameter.key] = value
+    query_context = {"source": source, "filters": filters, "parameters": parameters}
     if block.kind == InvestigationBlockKind.TEXT:
         dependencies, context, context_project_ids = _materialize_notebook_context(
             block, accessible_project_ids=accessible_project_ids
@@ -310,6 +343,23 @@ def build_block_execution_snapshot(
                 raise InvestigationValidationError(
                     {"context": "The previous query result uses inaccessible project data."}
                 )
+            reference_time = previous_execution.started_at or previous_execution.date_added
+            previous_input = previous_execution.input_snapshot
+            query_context = previous_input.get("queryContext") or {
+                "source": previous_input.get("source", source),
+                "filters": previous_input.get("filters", filters),
+                "parameters": previous_input.get("parameters", parameters),
+            }
+            query_context = {
+                **query_context,
+                "filters": freeze_query_time_range(
+                    query_context.get("filters", {}), reference_time=reference_time
+                ),
+            }
+            previous_result = _compact_query_context(previous_execution.result)
+            previous_result["queryLinks"] = freeze_query_links(
+                previous_result["queryLinks"], reference_time=reference_time
+            )
             context.insert(
                 0,
                 {
@@ -318,7 +368,8 @@ def build_block_execution_snapshot(
                     "title": block.title,
                     "currentBlock": True,
                     "visibleExecutionId": str(previous_execution.id),
-                    "result": _compact_query_context(previous_execution.result),
+                    "result": previous_result,
+                    "queryContext": query_context,
                 },
             )
             context_project_ids = sorted(set(context_project_ids).union(previous_project_ids))
@@ -329,8 +380,8 @@ def build_block_execution_snapshot(
     snapshot: dict[str, Any] = {
         "prompt": prompt,
         "organizationSlug": block.investigation.organization.slug,
-        "source": investigation_source(block.investigation),
-        "filters": investigation_filters(block.investigation),
+        "source": source,
+        "filters": filters,
         "parameters": parameters,
         "dependencies": dependencies,
         "context": context,
@@ -342,6 +393,8 @@ def build_block_execution_snapshot(
     }
     if dataset_hint is not None:
         snapshot["datasetHint"] = dataset_hint
+    if block.kind == InvestigationBlockKind.QUERY:
+        snapshot["queryContext"] = query_context
     return snapshot, _fingerprint(snapshot)
 
 

src/sentry/investigations/services/orchestration_events.py

@@ -614,6 +614,7 @@ def _upsert_report_block(
         "reportRevision": revision,
         "stableAgentKey": key,
         "projectIds": project_ids,
+        "source": deepcopy(run.source),
     }
     now = timezone.now()
     completed_at = None

static/app/views/investigations/__stories__/investigationFixtureApi.spec.tsx

@@ -1,6 +1,6 @@
 import {OrganizationFixture} from 'sentry-fixture/organization';
 
-import {render, screen, userEvent} from 'sentry-test/reactTestingLibrary';
+import {render, screen, userEvent, waitFor} from 'sentry-test/reactTestingLibrary';
 
 import {QUERY_API_CLIENT} from 'sentry/utils/queryClient';
 import {InvestigationsPage} from 'sentry/views/investigations';
@@ -10,7 +10,9 @@ import {
   InvestigationBlockFixture,
   InvestigationDetailFixture,
   InvestigationListItemFixture,
+  InvestigationOrchestrationFixture,
 } from 'sentry/views/investigations/fixtures';
+import {InvestigationHypotheses} from 'sentry/views/investigations/hypotheses/investigationHypotheses';
 
 const organization = OrganizationFixture({
   features: ['investigations'],
@@ -81,22 +83,22 @@ describe('InvestigationFixtureApi', () => {
       investigation.title
     );
 
-    await userEvent.click(
-      screen.getByRole('button', {name: 'Add query cell (debug only)'})
-    );
-    await userEvent.type(
-      screen.getByRole('textbox', {name: 'Cell title'}),
-      'Slow checkouts'
-    );
-    await userEvent.type(
-      screen.getByRole('textbox', {name: 'Cell instructions'}),
-      'Compare checkout p95 before and after the deploy.'
-    );
-    await userEvent.click(screen.getByRole('button', {name: 'Add cell'}));
+    // Renaming is the detail mutation the page drives itself. Blurring the
+    // field cancels the debounce and writes immediately, so this needs no timer.
+    const titleField = screen.getByRole('textbox', {name: 'Investigation title'});
+    await userEvent.clear(titleField);
+    await userEvent.type(titleField, 'Invoice PDF timeouts everywhere');
+    await userEvent.tab();
 
-    expect(
-      await screen.findByRole('button', {name: 'Toggle Slow checkouts'})
-    ).toBeInTheDocument();
+    // Read back through the fixture API rather than the field: the input would
+    // show the new title from the optimistic cache update either way, so only a
+    // fresh fetch proves the fixture backend actually stored it.
+    await waitFor(async () => {
+      const stored = await QUERY_API_CLIENT.requestPromise(
+        `/organizations/storybook-investigation-detail-test/investigations/${investigation.id}/`
+      );
+      expect(stored.title).toBe('Invoice PDF timeouts everywhere');
+    });
   });
 
   it('keeps fixture IDs and block positions unique across mutations', async () => {
@@ -153,4 +155,102 @@ describe('InvestigationFixtureApi', () => {
     expect(firstDuplicate.id).toBe('fixture-id-collisions-copy');
     expect(secondDuplicate.id).toBe('fixture-id-collisions-copy-2');
   });
+
+  // These mirror the "Live, against a mocked orchestration API" story. The
+  // stories route is where this UI gets reviewed, so a fixture that no longer
+  // satisfies the component leaves a broken page rather than a failing build —
+  // rendering the story's contents here is what catches that.
+  describe('orchestration', () => {
+    function renderStoryHypotheses(
+      run = InvestigationOrchestrationFixture(),
+      investigationId = 'investigation-1'
+    ) {
+      return render(
+        <InvestigationFixtureApi
+          organizationSlug="hypotheses-story"
+          details={[InvestigationDetailFixture({id: investigationId, blocks: []})]}
+          orchestration={{[investigationId]: run}}
+        >
+          <InvestigationHypotheses investigationId={investigationId} />
+        </InvestigationFixtureApi>,
+        {organization}
+      );
+    }
+
+    it('serves the projection to the hypothesis row', async () => {
+      renderStoryHypotheses();
+
+      expect(await screen.findAllByTestId('investigation-hypothesis')).toHaveLength(3);
+      expect(
+        screen.getByRole('heading', {
+          name: 'Database or cache degradation delayed the response',
+        })
+      ).toBeInTheDocument();
+      expect(screen.getByText('Supported · 86% Confidence')).toBeInTheDocument();
+      expect(
+        screen.getByText('The delay begins before the document reaches the browser.')
+      ).toBeInTheDocument();
+    });
+
+    it('applies a disposition command and returns the new projection', async () => {
+      renderStoryHypotheses();
+
+      await userEvent.click(
+        await screen.findByRole('button', {
+          name: 'Actions for An external SSO provider slowed the response',
+        })
+      );
+      await userEvent.click(await screen.findByRole('menuitemradio', {name: 'Accept'}));
+
+      // The command response carries the updated projection, so the card
+      // changes without another read.
+      expect(
+        await screen.findByText('Accepted by you · 91% Confidence')
+      ).toBeInTheDocument();
+      // Accepting settles the hypothesis, so its edge picks up the accent.
+      expect(screen.getAllByTestId('investigation-hypothesis')[1]).toHaveAttribute(
+        'data-border',
+        'accent'
+      );
+    });
+
+    it('clears a disposition back to the agent verdict', async () => {
+      renderStoryHypotheses();
+
+      const trigger = await screen.findByRole('button', {
+        name: 'Actions for An external SSO provider slowed the response',
+      });
+      await userEvent.click(trigger);
+      await userEvent.click(await screen.findByRole('menuitemradio', {name: 'Accept'}));
+      await screen.findByText('Accepted by you · 91% Confidence');
+
+      await userEvent.click(trigger);
+      await userEvent.click(
+        await screen.findByRole('menuitemradio', {name: 'Clear decision'})
+      );
+
+      expect(await screen.findByText('Refuted · 91% Confidence')).toBeInTheDocument();
+      // Back to the agent's verdict, so the edge breaks again.
+      expect(screen.getAllByTestId('investigation-hypothesis')[1]).toHaveAttribute(
+        'data-border',
+        'dashed'
+      );
+    });
+
+    it('puts a retried hypothesis back into investigation', async () => {
+      renderStoryHypotheses();
+
+      await userEvent.click(
+        await screen.findByRole('button', {
+          name: 'Actions for Session validation created a shared bottleneck',
+        })
+      );
+      await userEvent.click(
+        await screen.findByRole('menuitemradio', {name: 'Investigate again'})
+      );
+
+      expect(await screen.findByText('Verifying…')).toBeInTheDocument();
+      expect(screen.getAllByText('Awaiting evidence').length).toBeGreaterThan(0);
+    });
+  });
 });