diff --git a/static/app/views/issueDetails/streamline/sidebar/autofixSection.tsx b/static/app/views/issueDetails/streamline/sidebar/autofixSection.tsx
index 5416d04c20e570..93566027385de7 100644
--- a/static/app/views/issueDetails/streamline/sidebar/autofixSection.tsx
+++ b/static/app/views/issueDetails/streamline/sidebar/autofixSection.tsx
@@ -382,7 +382,6 @@ function AutofixPreviews({
size="md"
icon={
}
aria-label={t('Open Seer')}
- tooltipProps={{title: t('Open Seer')}}
priority="primary"
onClick={openSeerDrawer}
analyticsEventKey="issue_details.seer_opened"
diff --git a/static/app/views/navigation/secondary/sections/issues/issuesSecondaryNavigation.tsx b/static/app/views/navigation/secondary/sections/issues/issuesSecondaryNavigation.tsx
index 74abd32fd23cc6..0922df43bc238e 100644
--- a/static/app/views/navigation/secondary/sections/issues/issuesSecondaryNavigation.tsx
+++ b/static/app/views/navigation/secondary/sections/issues/issuesSecondaryNavigation.tsx
@@ -4,7 +4,7 @@ import styled from '@emotion/styled';
import {t} from 'sentry/locale';
import {useOrganization} from 'sentry/utils/useOrganization';
-import {makeMonitorBasePathname} from 'sentry/views/detectors/pathnames';
+import {makeAutomationBasePathname} from 'sentry/views/automations/pathnames';
import {ISSUE_TAXONOMY_CONFIG} from 'sentry/views/issueList/taxonomies';
import {usePrimaryNavigation} from 'sentry/views/navigation/primaryNavigationContext';
import {SecondaryNavigation} from 'sentry/views/navigation/secondary/components';
@@ -127,7 +127,7 @@ function ConfigureSection({baseUrl}: {baseUrl: string}) {
!hasRedirectOptOut && organization.features.includes('workflow-engine-ui');
const alertsLink = shouldRedirectToWorkflowEngineUI
- ? `${makeMonitorBasePathname(organization.slug)}?alertsRedirect=true`
+ ? `${makeAutomationBasePathname(organization.slug)}?alertsRedirect=true`
: `${baseUrl}/alerts/rules/`;
return (
diff --git a/static/app/views/seerExplorer/contexts/llmContext.spec.tsx b/static/app/views/seerExplorer/contexts/llmContext.spec.tsx
new file mode 100644
index 00000000000000..faa19cf9bf38c0
--- /dev/null
+++ b/static/app/views/seerExplorer/contexts/llmContext.spec.tsx
@@ -0,0 +1,339 @@
+import type {ReactNode} from 'react';
+
+import {render, waitFor} from 'sentry-test/reactTestingLibrary';
+
+import {LLMContextProvider, useLLMContext} from './llmContext';
+import type {LLMContextSnapshot} from './llmContextTypes';
+import {registerLLMContext} from './registerLLMContext';
+
+// ---------------------------------------------------------------------------
+// Test helper: ContextCapture
+//
+// Renders nothing but stores a reference to the getSnapshot function.
+// Since the context value is memoized (stable), this component only renders
+// once. However, getSnapshot() always reads stateRef.current (fresh), so
+// calling capturedRef.current() in waitFor gives live data.
+// ---------------------------------------------------------------------------
+
+function makeContextCapture() {
+ const ref: {current: ((componentOnly?: boolean) => LLMContextSnapshot) | null} = {
+ current: null,
+ };
+
+ function ContextCapture() {
+ const {getLLMContext} = useLLMContext();
+ ref.current = getLLMContext;
+ return null;
+ }
+
+ function getSnapshot(componentOnly?: boolean): LLMContextSnapshot {
+ if (!ref.current) throw new Error('ContextCapture not mounted');
+ return ref.current(componentOnly);
+ }
+
+ return {ContextCapture, getSnapshot};
+}
+
+// ---------------------------------------------------------------------------
+// Test fixtures
+// ---------------------------------------------------------------------------
+
+function DummyChart({label}: {label?: string}) {
+ useLLMContext({label: label ?? 'chart'});
+ return
{label ?? 'chart'}
;
+}
+
+function DummyWidget({title, children}: {children?: ReactNode; title?: string}) {
+ useLLMContext({title: title ?? 'widget', type: 'timeseries', unit: 'ms'});
+ return (
+
+ {title ?? 'widget'}
+ {children}
+
+ );
+}
+
+function DummyDashboard({name, children}: {children?: ReactNode; name?: string}) {
+ useLLMContext({name: name ?? 'dashboard'});
+ return (
+
+ {name ?? 'dashboard'}
+ {children}
+
+ );
+}
+
+const ContextChart = registerLLMContext('chart', DummyChart);
+const ContextWidget = registerLLMContext('widget', DummyWidget);
+const ContextDashboard = registerLLMContext('dashboard', DummyDashboard);
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('LLMContextProvider — empty state', () => {
+ it('returns an empty snapshot when no nodes are registered', async () => {
+ const {ContextCapture, getSnapshot} = makeContextCapture();
+
+ render(
+
+
+
+ );
+
+ await waitFor(() => {
+ expect(getSnapshot().nodes).toEqual([]);
+ });
+ });
+});
+
+describe('registerLLMContext — nesting', () => {
+ it('nests Chart inside Widget inside Dashboard in the snapshot', async () => {
+ const {ContextCapture, getSnapshot} = makeContextCapture();
+
+ render(
+
+
+
+
+
+
+
+
+ );
+
+ // Wait for the cascade of registration effects to settle, then assert the
+ // entire nested shape in one pass so the failure message shows the full tree.
+ await waitFor(() => {
+ expect(getSnapshot()).toEqual({
+ version: expect.any(Number),
+ nodes: [
+ {
+ nodeType: 'dashboard',
+ data: {name: 'Backend Health'},
+ children: [
+ {
+ nodeType: 'widget',
+ data: {title: 'Error Rate', type: 'timeseries', unit: 'ms'},
+ children: [
+ {
+ nodeType: 'chart',
+ data: {label: 'p99'},
+ children: [],
+ },
+ ],
+ },
+ ],
+ },
+ ],
+ });
+ });
+ });
+});
+
+describe('registerLLMContext — unmount cleanup', () => {
+ it('removes the node from the tree when the component unmounts', async () => {
+ const {ContextCapture, getSnapshot} = makeContextCapture();
+
+ const {rerender} = render(
+
+
+
+
+ );
+
+ // Node should be present after mount
+ await waitFor(() => {
+ expect(getSnapshot().nodes).toHaveLength(1);
+ });
+
+ // Unmount the widget
+ rerender(
+
+
+
+ );
+
+ // Node should be gone
+ await waitFor(() => {
+ expect(getSnapshot().nodes).toHaveLength(0);
+ });
+ });
+});
+
+describe('useLLMContext — data updates', () => {
+ it('writes data into the node and updates it on re-render', async () => {
+ const {ContextCapture, getSnapshot} = makeContextCapture();
+
+ function Gauge({value}: {value: number}) {
+ useLLMContext({value});
+ return
{value}
;
+ }
+ const ContextGauge = registerLLMContext('widget', Gauge);
+
+ const {rerender} = render(
+
+
+
+
+ );
+
+ // Initial data written after HOC registers and inner component re-renders
+ await waitFor(() => {
+ expect(getSnapshot().nodes[0]?.data).toEqual({value: 1});
+ });
+
+ // Update the prop
+ rerender(
+
+
+
+
+ );
+
+ await waitFor(() => {
+ expect(getSnapshot().nodes[0]?.data).toEqual({value: 2});
+ });
+ });
+
+ it('handles non-object data types', async () => {
+ const {ContextCapture, getSnapshot} = makeContextCapture();
+
+ function Label({text}: {text: string}) {
+ useLLMContext(text);
+ return
{text}
;
+ }
+ const ContextLabel = registerLLMContext('widget', Label);
+
+ render(
+
+
+
+
+ );
+
+ await waitFor(() => {
+ expect(getSnapshot().nodes[0]?.data).toBe('hello');
+ });
+ });
+
+ it('handles array data', async () => {
+ const {ContextCapture, getSnapshot} = makeContextCapture();
+
+ function Tags({items}: {items: string[]}) {
+ useLLMContext(items);
+ return
{items.join(',')}
;
+ }
+ const ContextTags = registerLLMContext('widget', Tags);
+
+ render(
+
+
+
+
+ );
+
+ await waitFor(() => {
+ expect(getSnapshot().nodes[0]?.data).toEqual(['a', 'b', 'c']);
+ });
+ });
+
+ it('handles numeric data', async () => {
+ const {ContextCapture, getSnapshot} = makeContextCapture();
+
+ function Score({value}: {value: number}) {
+ useLLMContext(value);
+ return
{value}
;
+ }
+ const ContextScore = registerLLMContext('widget', Score);
+
+ render(
+
+
+
+
+ );
+
+ await waitFor(() => {
+ expect(getSnapshot().nodes[0]?.data).toBe(42);
+ });
+ });
+});
+
+describe('getLLMContext — full tree vs componentOnly', () => {
+ it('getLLMContext() returns full tree including sibling branches', async () => {
+ const {ContextCapture, getSnapshot} = makeContextCapture();
+
+ function Widget1() {
+ useLLMContext({id: 'w1'});
+ return
w1
;
+ }
+ function Widget2() {
+ useLLMContext({id: 'w2'});
+ return
w2
;
+ }
+ const CW1 = registerLLMContext('widget', Widget1);
+ const CW2 = registerLLMContext('widget', Widget2);
+
+ render(
+
+
+
+
+
+ );
+
+ await waitFor(() => {
+ const snapshot = getSnapshot();
+ expect(snapshot.nodes).toHaveLength(2);
+ const types = snapshot.nodes.map(n => n.nodeType);
+ expect(types).toEqual(['widget', 'widget']);
+ });
+ });
+
+ it('getLLMContext(true) returns only the current component subtree', async () => {
+ // We need a capture inside the dashboard to test componentOnly
+ const innerRef: {
+ current: ((c?: boolean) => LLMContextSnapshot) | null;
+ } = {current: null};
+
+ function DashboardWithCapture({name}: {name: string}) {
+ useLLMContext({name});
+ const {getLLMContext} = useLLMContext();
+ innerRef.current = getLLMContext;
+ return (
+
+
+
+ );
+ }
+ const ContextDashboardWithCapture = registerLLMContext(
+ 'dashboard',
+ DashboardWithCapture
+ );
+
+ function SiblingDashboard() {
+ useLLMContext({name: 'sibling'});
+ return
sibling
;
+ }
+ const ContextSiblingDashboard = registerLLMContext('dashboard', SiblingDashboard);
+
+ render(
+
+
+
+
+ );
+
+ // componentOnly snapshot should contain only the dashboard + its inner widget,
+ // not the sibling dashboard
+ await waitFor(() => {
+ if (!innerRef.current) throw new Error('not mounted');
+ const snapshot = innerRef.current(true); // componentOnly
+ expect(snapshot.nodes).toHaveLength(1);
+ expect(snapshot.nodes[0]?.nodeType).toBe('dashboard');
+ expect(snapshot.nodes[0]?.children).toHaveLength(1);
+ expect(snapshot.nodes[0]?.children[0]?.nodeType).toBe('widget');
+ });
+ });
+});
diff --git a/static/app/views/seerExplorer/contexts/llmContext.tsx b/static/app/views/seerExplorer/contexts/llmContext.tsx
new file mode 100644
index 00000000000000..9919867ccb132f
--- /dev/null
+++ b/static/app/views/seerExplorer/contexts/llmContext.tsx
@@ -0,0 +1,251 @@
+import {
+ createContext,
+ type ReactNode,
+ useCallback,
+ useContext,
+ useEffect,
+ useMemo,
+ useRef,
+} from 'react';
+
+import {createDefinedContext} from 'sentry/utils/performance/contexts/utils';
+
+import type {
+ LLMContextInternalValue,
+ LLMContextNode,
+ LLMContextNodeSnapshot,
+ LLMContextSnapshot,
+ LLMContextState,
+} from './llmContextTypes';
+
+// ---------------------------------------------------------------------------
+// Internal context — holds the registry operations (registerNode, etc.)
+// ---------------------------------------------------------------------------
+
+const [_LLMContextProvider, _useLLMContextValue] =
+ createDefinedContext
({
+ name: 'LLMContext',
+ strict: true,
+ });
+
+/**
+ * Hook for internal use by registerLLMContext and useLLMContext to access
+ * the registry operations (registerNode, unregisterNode, updateNodeData, getSnapshot).
+ * Throws if called outside an LLMContextProvider.
+ */
+export const useLLMContextRegistry = _useLLMContextValue;
+
+// ---------------------------------------------------------------------------
+// LLMNodeContext — carries the current component's nodeId down the tree
+// so child registerLLMContext wrappers can declare their parentId immediately
+// during render (before any effects have fired).
+// Default undefined = no parent (root level).
+// ---------------------------------------------------------------------------
+
+export const LLMNodeContext = createContext(undefined);
+
+// ---------------------------------------------------------------------------
+// Tree assembly helpers — convert the flat node map to a nested snapshot.
+// Data is read from nodeData (imperative ref) rather than the reducer state
+// so that writes from useLLMContext(data) are visible immediately even
+// before the HOC's registerNode effect has fired.
+// ---------------------------------------------------------------------------
+
+function collectDescendantIds(
+ nodes: Map,
+ nodeId: string,
+ result = new Set()
+): Set {
+ result.add(nodeId);
+ for (const [id, node] of nodes) {
+ if (node.parentId === nodeId) {
+ collectDescendantIds(nodes, id, result);
+ }
+ }
+ return result;
+}
+
+function buildTree(
+ nodes: LLMContextState['nodes'],
+ nodeData: Map,
+ parentId: string | undefined
+): LLMContextNodeSnapshot[] {
+ const children: LLMContextNodeSnapshot[] = [];
+ for (const [id, node] of nodes) {
+ if (node.parentId === parentId) {
+ children.push({
+ nodeType: node.nodeType,
+ data: nodeData.has(id) ? nodeData.get(id) : {},
+ children: buildTree(nodes, nodeData, id),
+ });
+ }
+ }
+ return children;
+}
+
+function serializeState(
+ state: LLMContextState,
+ nodeData: Map,
+ fromNodeId?: string
+): LLMContextSnapshot {
+ if (fromNodeId) {
+ const node = state.nodes.get(fromNodeId);
+ if (!node) {
+ return {version: state.version, nodes: []};
+ }
+ return {
+ version: state.version,
+ nodes: [
+ {
+ nodeType: node.nodeType,
+ data: nodeData.has(fromNodeId) ? nodeData.get(fromNodeId) : {},
+ children: buildTree(state.nodes, nodeData, fromNodeId),
+ },
+ ],
+ };
+ }
+ return {
+ version: state.version,
+ nodes: buildTree(state.nodes, nodeData, undefined),
+ };
+}
+
+// ---------------------------------------------------------------------------
+// LLMContextProvider — root of the entire context tree
+// ---------------------------------------------------------------------------
+
+interface LLMContextProviderProps {
+ children: ReactNode;
+}
+
+const INITIAL_STATE: LLMContextState = {
+ nodes: new Map(),
+ version: 0,
+};
+
+export function LLMContextProvider({children}: LLMContextProviderProps) {
+ // All state lives in refs — no re-renders needed. Consumers read
+ // the latest data imperatively via getSnapshot().
+ const stateRef = useRef(INITIAL_STATE);
+ const nodeDataRef = useRef>(new Map());
+
+ const getSnapshot = useCallback((fromNodeId?: string): LLMContextSnapshot => {
+ return serializeState(stateRef.current, nodeDataRef.current, fromNodeId);
+ }, []);
+
+ const registerNode = useCallback(
+ (nodeId: string, nodeType: string, parentId?: string): void => {
+ const prev = stateRef.current;
+ const newNodes = new Map(prev.nodes);
+ newNodes.set(nodeId, {nodeType, parentId});
+ stateRef.current = {nodes: newNodes, version: prev.version + 1};
+ },
+ []
+ );
+
+ const unregisterNode = useCallback((nodeId: string) => {
+ const prev = stateRef.current;
+ if (!prev.nodes.has(nodeId)) {
+ return;
+ }
+ const toRemove = collectDescendantIds(prev.nodes, nodeId);
+ const newNodes = new Map(prev.nodes);
+ for (const id of toRemove) {
+ newNodes.delete(id);
+ nodeDataRef.current.delete(id);
+ }
+ stateRef.current = {nodes: newNodes, version: prev.version + 1};
+ }, []);
+
+ const updateNodeData = useCallback((nodeId: string, data: unknown) => {
+ nodeDataRef.current.set(nodeId, data);
+ // Bump version so consumers using it as a change token detect data updates.
+ stateRef.current = {...stateRef.current, version: stateRef.current.version + 1};
+ }, []);
+
+ // Memoize so that the context value reference is stable across re-renders.
+ const value = useMemo(
+ () => ({getSnapshot, registerNode, unregisterNode, updateNodeData}),
+ [getSnapshot, registerNode, unregisterNode, updateNodeData]
+ );
+
+ return <_LLMContextProvider value={value}>{children};
+}
+
+// ---------------------------------------------------------------------------
+// useLLMContext — write overload
+//
+// Call inside a registerLLMContext-wrapped component (or any descendant)
+// to push structured data into the nearest registered context node.
+// Accepts any value type — objects, arrays, strings, numbers, etc.
+//
+// useLLMContext({ title: 'Error Rate', threshold: 5 });
+// useLLMContext(someComputedValue);
+// ---------------------------------------------------------------------------
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type -- {} here means "any non-undefined value" to distinguish from the no-arg read overload
+export function useLLMContext(data: {} | null): void;
+
+// ---------------------------------------------------------------------------
+// useLLMContext — read overload
+//
+// Call with no arguments to get getLLMContext.
+//
+// const { getLLMContext } = useLLMContext();
+// getLLMContext() // full tree from root
+// getLLMContext(true) // current component's subtree only
+// ---------------------------------------------------------------------------
+
+export function useLLMContext(): {
+ getLLMContext: (componentOnly?: boolean) => LLMContextSnapshot;
+};
+
+export function useLLMContext(
+ data?: unknown
+): void | {getLLMContext: (componentOnly?: boolean) => LLMContextSnapshot} {
+ const ctx = useLLMContextRegistry();
+ const nodeId = useContext(LLMNodeContext);
+ const prevDataRef = useRef('');
+
+ // Write path: sync data into the nearest node whenever it changes.
+ // JSON equality guard prevents redundant writes. updateNodeData writes
+ // imperatively to a ref — no dispatch, no re-render required.
+ useEffect(() => {
+ if (!nodeId || data === undefined) {
+ return;
+ }
+ let serialized: string | null;
+ let safeData: unknown = data;
+ try {
+ serialized = JSON.stringify(data);
+ } catch {
+ // Non-serializable value (e.g. circular reference) — store a
+ // placeholder so getSnapshot() remains JSON-serializable.
+ serialized = null;
+ safeData = {error: 'non-serializable value'};
+ }
+ if (serialized === null || serialized !== prevDataRef.current) {
+ if (serialized !== null) {
+ prevDataRef.current = serialized;
+ }
+ ctx.updateNodeData(nodeId, safeData);
+ }
+ });
+
+ // Read path: always created so hooks run unconditionally.
+ // Only returned when called without data.
+ const getLLMContext = useCallback(
+ (componentOnly?: boolean): LLMContextSnapshot => {
+ if (componentOnly && nodeId) {
+ return ctx.getSnapshot(nodeId);
+ }
+ return ctx.getSnapshot();
+ },
+ [ctx, nodeId]
+ );
+
+ if (data === undefined) {
+ return {getLLMContext};
+ }
+ return undefined;
+}
diff --git a/static/app/views/seerExplorer/contexts/llmContextTypes.ts b/static/app/views/seerExplorer/contexts/llmContextTypes.ts
new file mode 100644
index 00000000000000..1120072a3a6667
--- /dev/null
+++ b/static/app/views/seerExplorer/contexts/llmContextTypes.ts
@@ -0,0 +1,71 @@
+/**
+ * LLM Context System — Types
+ *
+ * A flat map of context nodes that captures semantic state from the currently
+ * rendered page. Each node corresponds to a React component (dashboard,
+ * widget, etc.) and holds key-value data about it. The LLM context reader
+ * (e.g. Seer Explorer) reads a snapshot of this tree instead of scraping
+ * the DOM.
+ *
+ * Nodes are stored flat (keyed by ID) with a `parentId` pointer. The nested
+ * tree structure is assembled lazily at getSnapshot() time. This avoids
+ * ordering dependencies during registration — a child can declare its
+ * parentId immediately even before the parent's effect has fired.
+ */
+
+/**
+ * Known node types for the LLM context tree.
+ * Add new types here as new context-aware components are registered.
+ */
+export type LLMContextNodeType = 'chart' | 'dashboard' | 'widget';
+
+/**
+ * A single node in the flat registry.
+ *
+ * - `nodeType` — what kind of thing this is ("dashboard", "widget", etc.)
+ * - `parentId` — ID of the parent node, or undefined for root-level nodes
+ *
+ * Note: node data is stored separately in the provider's imperative
+ * `nodeDataRef` rather than on this struct, so that writes from
+ * `useLLMContext(data)` don't require a state mutation.
+ */
+export interface LLMContextNode {
+ nodeType: string;
+ parentId?: string;
+}
+
+/**
+ * The full state held by the provider (stored in a ref, not reactive).
+ *
+ * - `nodes` — flat map of all registered nodes keyed by ID
+ * - `version` — bumped on every mutation so consumers can detect updates cheaply
+ */
+export interface LLMContextState {
+ nodes: Map;
+ version: number;
+}
+
+/**
+ * The snapshot format returned by `getSnapshot()`. This is what gets sent
+ * to the LLM API — a plain-JSON-serializable nested tree.
+ */
+export interface LLMContextSnapshot {
+ nodes: LLMContextNodeSnapshot[];
+ version: number;
+}
+
+export interface LLMContextNodeSnapshot {
+ children: LLMContextNodeSnapshot[];
+ data: unknown;
+ nodeType: string;
+}
+
+/**
+ * The value exposed by the internal LLMContext to the HOC and hooks.
+ */
+export interface LLMContextInternalValue {
+ getSnapshot: (fromNodeId?: string) => LLMContextSnapshot;
+ registerNode: (nodeId: string, nodeType: string, parentId?: string) => void;
+ unregisterNode: (nodeId: string) => void;
+ updateNodeData: (nodeId: string, data: unknown) => void;
+}
diff --git a/static/app/views/seerExplorer/contexts/registerLLMContext.tsx b/static/app/views/seerExplorer/contexts/registerLLMContext.tsx
new file mode 100644
index 00000000000000..062603624a64d1
--- /dev/null
+++ b/static/app/views/seerExplorer/contexts/registerLLMContext.tsx
@@ -0,0 +1,61 @@
+import type {ComponentType} from 'react';
+import {useContext, useEffect, useId} from 'react';
+
+import {LLMNodeContext, useLLMContextRegistry} from './llmContext';
+import type {LLMContextNodeType} from './llmContextTypes';
+
+/**
+ * HOC that registers a component as a named node in the LLM context tree.
+ *
+ * On mount, a new node of the given `nodeType` is created in the tree,
+ * nested under the nearest parent node (from `LLMNodeContext`).
+ * On unmount, the node and all its descendants are removed.
+ *
+ * The wrapped component receives all its original props unchanged.
+ * To push structured data into this component's node, call
+ * `useLLMContext({ key: value })` anywhere inside the wrapped component.
+ *
+ * Usage:
+ * const ContextAwareDashboard = registerLLMContext('dashboard', Dashboard);
+ * const ContextAwareWidget = registerLLMContext('widget', Widget);
+ *
+ * // Widget rendered inside Dashboard will nest correctly:
+ * // { nodeType: 'dashboard', children: [{ nodeType: 'widget', ... }] }
+ */
+export function registerLLMContext>(
+ nodeType: LLMContextNodeType,
+ WrappedComponent: ComponentType
+): ComponentType
{
+ function LLMContextWrapper(props: P) {
+ const ctx = useLLMContextRegistry();
+
+ // Read the nearest parent's nodeId from LLMNodeContext.
+ // undefined = no parent (this node will be at root level).
+ const parentNodeId = useContext(LLMNodeContext);
+
+ // React's useId generates a stable, unique ID for this component instance.
+ const ownNodeId = useId();
+
+ useEffect(() => {
+ ctx.registerNode(ownNodeId, nodeType, parentNodeId);
+ return () => {
+ ctx.unregisterNode(ownNodeId);
+ };
+ // parentNodeId in deps: if the parent context changes (e.g. parent
+ // component re-mounts), re-register under the new parent.
+ }, [ctx, ownNodeId, parentNodeId]);
+
+ return (
+ // Provide ownNodeId downward so child registerLLMContext wrappers
+ // and useLLMContext(data) calls read this as their context anchor.
+
+ {/* TODO(any): HoC prop types not working w/ emotion https://github.com/emotion-js/emotion/issues/3261 */}
+
+
+ );
+ }
+
+ LLMContextWrapper.displayName = `registerLLMContext(${nodeType}, ${WrappedComponent.displayName || WrappedComponent.name || 'Component'})`;
+
+ return LLMContextWrapper;
+}
diff --git a/tests/sentry/core/endpoints/test_organization_details.py b/tests/sentry/core/endpoints/test_organization_details.py
index 60679a0f2e9085..f01d258575ad5f 100644
--- a/tests/sentry/core/endpoints/test_organization_details.py
+++ b/tests/sentry/core/endpoints/test_organization_details.py
@@ -21,6 +21,7 @@
from sentry.auth.authenticators.totp import TotpInterface
from sentry.constants import (
RESERVED_ORGANIZATION_SLUGS,
+ SEER_AUTOMATED_RUN_STOPPING_POINT_DEFAULT,
SEER_DEFAULT_CODING_AGENT_DEFAULT,
ObjectStatus,
)
@@ -1499,19 +1500,50 @@ def test_default_coding_agent_default(self) -> None:
response = self.get_success_response(self.organization.slug)
assert response.data["defaultCodingAgent"] == SEER_DEFAULT_CODING_AGENT_DEFAULT
- def test_default_coding_agent_can_be_set(self) -> None:
+ def test_default_coding_agent_can_be_set_to_seer(self) -> None:
data = {"defaultCodingAgent": "seer"}
response = self.get_success_response(self.organization.slug, **data)
assert self.organization.get_option("sentry:seer_default_coding_agent") == "seer"
assert response.data["defaultCodingAgent"] == "seer"
- def test_default_coding_agent_null_on_first_write_create_path(self) -> None:
- # Tests the create path (no OrganizationOption row exists yet): sending null
- # must store null rather than the string "None" via str(None).
+ def test_default_coding_agent_can_be_set_to_cursor(self) -> None:
+ for value in ("cursor", "cursor_background_agent"):
+ data = {"defaultCodingAgent": value}
+ response = self.get_success_response(self.organization.slug, **data)
+ assert (
+ self.organization.get_option("sentry:seer_default_coding_agent")
+ == "cursor_background_agent"
+ )
+ assert response.data["defaultCodingAgent"] == "cursor_background_agent"
+
+ def test_default_coding_agent_can_be_set_to_claude(self) -> None:
+ for value in ("claude_code", "claude_code_agent"):
+ data = {"defaultCodingAgent": value}
+ response = self.get_success_response(self.organization.slug, **data)
+ assert (
+ self.organization.get_option("sentry:seer_default_coding_agent")
+ == "claude_code_agent"
+ )
+ assert response.data["defaultCodingAgent"] == "claude_code_agent"
+
+ def test_default_coding_agent_none_casts_to_seer(self) -> None:
+ data = {"defaultCodingAgent": None}
+ response = self.get_success_response(self.organization.slug, **data)
+ assert self.organization.get_option("sentry:seer_default_coding_agent") == "seer"
+ assert response.data["defaultCodingAgent"] == "seer"
+
+ def test_default_coding_agent_none_resets_to_seer(self) -> None:
+ self.organization.update_option(
+ "sentry:seer_default_coding_agent", "cursor_background_agent"
+ )
data = {"defaultCodingAgent": None}
response = self.get_success_response(self.organization.slug, **data)
- assert self.organization.get_option("sentry:seer_default_coding_agent") is None
- assert response.data["defaultCodingAgent"] is None
+ assert self.organization.get_option("sentry:seer_default_coding_agent") == "seer"
+ assert response.data["defaultCodingAgent"] == "seer"
+
+ def test_default_coding_agent_rejects_invalid_choice(self) -> None:
+ data = {"defaultCodingAgent": "invalid_agent"}
+ self.get_error_response(self.organization.slug, status_code=400, **data)
def test_default_coding_agent_writing_default_value_stores_but_skips_audit_log(
self,
@@ -1581,12 +1613,25 @@ def test_default_coding_agent_integration_id_null_on_first_write_create_path(sel
)
assert response.data["defaultCodingAgentIntegrationId"] is None
- def test_default_coding_agent_can_be_cleared(self) -> None:
- self.organization.update_option("sentry:seer_default_coding_agent", "seer")
- data = {"defaultCodingAgent": None}
- response = self.get_success_response(self.organization.slug, **data)
- assert self.organization.get_option("sentry:seer_default_coding_agent") is None
- assert response.data["defaultCodingAgent"] is None
+ def test_default_automated_run_stopping_point_default(self) -> None:
+ response = self.get_success_response(self.organization.slug)
+ assert (
+ response.data["defaultAutomatedRunStoppingPoint"]
+ == SEER_AUTOMATED_RUN_STOPPING_POINT_DEFAULT
+ )
+
+ def test_default_automated_run_stopping_point_can_be_set(self) -> None:
+ for choice in ("code_changes", "open_pr"):
+ with self.subTest(choice=choice):
+ data = {"defaultAutomatedRunStoppingPoint": choice}
+ response = self.get_success_response(self.organization.slug, **data)
+ assert response.data["defaultAutomatedRunStoppingPoint"] == choice
+
+ def test_default_automated_run_stopping_point_rejects_invalid(self) -> None:
+ for invalid in ("root_cause", "solution", "invalid_point"):
+ with self.subTest(value=invalid):
+ data = {"defaultAutomatedRunStoppingPoint": invalid}
+ self.get_error_response(self.organization.slug, status_code=400, **data)
def test_default_coding_agent_integration_id_can_be_cleared(self) -> None:
self.organization.update_option("sentry:seer_default_coding_agent_integration_id", 123)
diff --git a/tests/sentry/grouping/test_parameterization.py b/tests/sentry/grouping/test_parameterization.py
index 43bf6ef0bf5152..49f9a6130c8d53 100644
--- a/tests/sentry/grouping/test_parameterization.py
+++ b/tests/sentry/grouping/test_parameterization.py
@@ -161,7 +161,7 @@
("hex without prefix - no letters, < 8 digits, negative", "-1234567", ""),
("hex without prefix - no letters, 8+ digits, positive", "12345678", ""),
("git sha", "commit a93c7d2", "commit "),
- ("git sha - all letters", "commit deadbeef", "commit deadbeef"),
+ ("git sha - all letters", "commit cabcafe", "commit cabcafe"),
("git sha - all numbers", "commit 4150908", "commit "),
("float", "0.23", ""),
("int", "23", ""),
diff --git a/tests/sentry/seer/autofix/test_autofix_utils.py b/tests/sentry/seer/autofix/test_autofix_utils.py
index 96260e838075e7..2f5c8c401d6ed3 100644
--- a/tests/sentry/seer/autofix/test_autofix_utils.py
+++ b/tests/sentry/seer/autofix/test_autofix_utils.py
@@ -15,6 +15,7 @@
deduplicate_repositories,
get_autofix_prompt,
get_coding_agent_prompt,
+ get_org_default_seer_automation_handoff,
has_project_connected_repos,
is_seer_seat_based_tier_enabled,
resolve_repository_ids,
@@ -1218,3 +1219,91 @@ def test_bulk_write_replaces_per_project(self) -> None:
assert p1_repo.branch_name == "new-branch"
p2_repo = SeerProjectRepository.objects.get(project=project2)
assert p2_repo.branch_name == "project-2-branch"
+
+
+class TestGetOrgDefaultSeerAutomationHandoff(TestCase):
+ def test_defaults(self):
+ stopping_point, handoff = get_org_default_seer_automation_handoff(self.organization)
+ assert stopping_point == "code_changes"
+ assert handoff is None
+
+ def test_respects_org_stopping_point_option(self):
+ self.organization.update_option("sentry:default_automated_run_stopping_point", "open_pr")
+ self.organization.update_option("sentry:auto_open_prs", True)
+
+ stopping_point, handoff = get_org_default_seer_automation_handoff(self.organization)
+ assert stopping_point == "open_pr"
+ assert handoff is None
+
+ def test_seer_agent_auto_open_prs_forces_open_pr(self):
+ self.organization.update_option(
+ "sentry:default_automated_run_stopping_point", "code_changes"
+ )
+ self.organization.update_option("sentry:auto_open_prs", True)
+
+ stopping_point, handoff = get_org_default_seer_automation_handoff(self.organization)
+ assert stopping_point == "open_pr"
+ assert handoff is None
+
+ def test_seer_agent_no_auto_open_prs_caps_open_pr_to_code_changes(self):
+ self.organization.update_option("sentry:default_automated_run_stopping_point", "open_pr")
+
+ stopping_point, handoff = get_org_default_seer_automation_handoff(self.organization)
+ assert stopping_point == "code_changes"
+ assert handoff is None
+
+ def test_external_agent_returns_handoff_config(self):
+ self.organization.update_option(
+ "sentry:seer_default_coding_agent", "cursor_background_agent"
+ )
+ self.organization.update_option("sentry:seer_default_coding_agent_integration_id", 42)
+
+ stopping_point, handoff = get_org_default_seer_automation_handoff(self.organization)
+ assert stopping_point == "code_changes"
+ assert handoff is not None
+ assert handoff.handoff_point == "root_cause"
+ assert handoff.target == "cursor_background_agent"
+ assert handoff.integration_id == 42
+ assert handoff.auto_create_pr is False
+
+ def test_external_agent_auto_open_prs_sets_auto_create_pr(self):
+ self.organization.update_option("sentry:seer_default_coding_agent", "claude_code_agent")
+ self.organization.update_option("sentry:seer_default_coding_agent_integration_id", 99)
+ self.organization.update_option("sentry:auto_open_prs", True)
+
+ stopping_point, handoff = get_org_default_seer_automation_handoff(self.organization)
+ assert handoff is not None
+ assert handoff.auto_create_pr is True
+
+ def test_external_agent_auto_open_prs_does_not_override_stopping_point(self):
+ self.organization.update_option(
+ "sentry:default_automated_run_stopping_point", "code_changes"
+ )
+ self.organization.update_option("sentry:auto_open_prs", True)
+ self.organization.update_option(
+ "sentry:seer_default_coding_agent", "cursor_background_agent"
+ )
+ self.organization.update_option("sentry:seer_default_coding_agent_integration_id", 42)
+
+ stopping_point, handoff = get_org_default_seer_automation_handoff(self.organization)
+ assert stopping_point == "code_changes"
+ assert handoff is not None
+
+ def test_external_agent_without_integration_id_falls_back_to_seer(self):
+ self.organization.update_option(
+ "sentry:seer_default_coding_agent", "cursor_background_agent"
+ )
+ self.organization.update_option("sentry:auto_open_prs", True)
+
+ stopping_point, handoff = get_org_default_seer_automation_handoff(self.organization)
+ assert stopping_point == "open_pr"
+ assert handoff is None
+
+ def test_seer_coding_agent_treated_as_no_external_agent(self):
+ self.organization.update_option("sentry:seer_default_coding_agent", "seer")
+ self.organization.update_option("sentry:seer_default_coding_agent_integration_id", 42)
+ self.organization.update_option("sentry:auto_open_prs", True)
+
+ stopping_point, handoff = get_org_default_seer_automation_handoff(self.organization)
+ assert stopping_point == "open_pr"
+ assert handoff is None
diff --git a/tests/sentry/tasks/seer/test_autofix.py b/tests/sentry/tasks/seer/test_autofix.py
index 20566413060f75..ed92f065fb2c17 100644
--- a/tests/sentry/tasks/seer/test_autofix.py
+++ b/tests/sentry/tasks/seer/test_autofix.py
@@ -4,6 +4,7 @@
import pytest
from django.test import TestCase
+from sentry.constants import SEER_AUTOMATED_RUN_STOPPING_POINT_DEFAULT
from sentry.models.repository import Repository
from sentry.seer.autofix.constants import AutofixStatus, SeerAutomationSource
from sentry.seer.autofix.utils import AutofixState, get_seer_seat_based_tier_cache_key
@@ -197,23 +198,166 @@ def test_overrides_autofix_off_to_medium(
@patch("sentry.tasks.seer.autofix.bulk_set_project_preferences")
@patch("sentry.tasks.seer.autofix.bulk_get_project_preferences")
- def test_skips_projects_with_existing_stopping_point(
+ def test_new_project_gets_stopping_point_and_no_handoff_from_org_defaults(
self, mock_bulk_get: MagicMock, mock_bulk_set: MagicMock
) -> None:
- """Test that projects with open_pr or code_changes stopping point are skipped."""
- project1 = self.create_project(organization=self.organization)
- project2 = self.create_project(organization=self.organization)
+ """Project with no existing prefs gets stopping point and no handoff (seer coding agent) from org defaults."""
+ project = self.create_project(organization=self.organization)
+
+ mock_bulk_get.return_value = {}
+
+ configure_seer_for_existing_org(organization_id=self.organization.id)
+
+ mock_bulk_set.assert_called_once()
+ prefs = mock_bulk_set.call_args[0][1]
+ prefs_by_project = {p["project_id"]: p for p in prefs}
+ assert prefs_by_project[project.id]["automated_run_stopping_point"] == "code_changes"
+ assert prefs_by_project[project.id]["automation_handoff"] is None
+
+ @patch("sentry.tasks.seer.autofix.bulk_set_project_preferences")
+ @patch("sentry.tasks.seer.autofix.bulk_get_project_preferences")
+ def test_new_project_gets_stopping_point_and_handoff_from_org_defaults(
+ self, mock_bulk_get: MagicMock, mock_bulk_set: MagicMock
+ ) -> None:
+ """Project with no existing prefs gets stopping point and external agent handoff from org defaults."""
+ project = self.create_project(organization=self.organization)
+ self.organization.update_option(
+ "sentry:seer_default_coding_agent", "cursor_background_agent"
+ )
+ self.organization.update_option("sentry:seer_default_coding_agent_integration_id", 42)
+ self.organization.update_option("sentry:auto_open_prs", True)
+
+ mock_bulk_get.return_value = {}
+
+ configure_seer_for_existing_org(organization_id=self.organization.id)
+
+ mock_bulk_set.assert_called_once()
+ prefs = mock_bulk_set.call_args[0][1]
+ prefs_by_project = {p["project_id"]: p for p in prefs}
+ assert prefs_by_project[project.id]["automation_handoff"] == {
+ "handoff_point": "root_cause",
+ "target": "cursor_background_agent",
+ "integration_id": 42,
+ "auto_create_pr": True,
+ }
+ # auto_open_prs should NOT override stopping point for external agents
+ assert (
+ prefs_by_project[project.id]["automated_run_stopping_point"]
+ == SEER_AUTOMATED_RUN_STOPPING_POINT_DEFAULT
+ )
+
+ @patch("sentry.tasks.seer.autofix.bulk_set_project_preferences")
+ @patch("sentry.tasks.seer.autofix.bulk_get_project_preferences")
+ def test_skips_project_with_valid_stopping_point_and_no_default_handoff(
+ self, mock_bulk_get: MagicMock, mock_bulk_set: MagicMock
+ ) -> None:
+ """Project is skipped when it has a valid stopping point and the org has no default handoff (seer agent)."""
+ project = self.create_project(organization=self.organization)
mock_bulk_get.return_value = {
- str(project1.id): {"automated_run_stopping_point": "open_pr"},
- str(project2.id): {"automated_run_stopping_point": "code_changes"},
+ str(project.id): {"automated_run_stopping_point": "open_pr"},
}
configure_seer_for_existing_org(organization_id=self.organization.id)
- # bulk_set should not be called since both projects are skipped
mock_bulk_set.assert_not_called()
+ @patch("sentry.tasks.seer.autofix.bulk_set_project_preferences")
+ @patch("sentry.tasks.seer.autofix.bulk_get_project_preferences")
+ def test_skips_project_with_valid_stopping_point_and_existing_handoff(
+ self, mock_bulk_get: MagicMock, mock_bulk_set: MagicMock
+ ) -> None:
+ """Project is skipped when it has a valid stopping point and an existing handoff configured."""
+ project = self.create_project(organization=self.organization)
+ self.organization.update_option(
+ "sentry:seer_default_coding_agent", "cursor_background_agent"
+ )
+ self.organization.update_option("sentry:seer_default_coding_agent_integration_id", 42)
+
+ mock_bulk_get.return_value = {
+ str(project.id): {
+ "automated_run_stopping_point": "code_changes",
+ "automation_handoff": {
+ "handoff_point": "root_cause",
+ "target": "claude_code_agent",
+ "integration_id": 99,
+ "auto_create_pr": False,
+ },
+ },
+ }
+
+ configure_seer_for_existing_org(organization_id=self.organization.id)
+
+ mock_bulk_set.assert_not_called()
+
+ @patch("sentry.tasks.seer.autofix.bulk_set_project_preferences")
+ @patch("sentry.tasks.seer.autofix.bulk_get_project_preferences")
+ def test_project_with_valid_stopping_point_gets_handoff_from_org_defaults(
+ self, mock_bulk_get: MagicMock, mock_bulk_set: MagicMock
+ ) -> None:
+ """Project with valid stopping point but no handoff gets org default handoff applied.
+ Existing stopping point is preserved."""
+ project = self.create_project(organization=self.organization)
+ self.organization.update_option(
+ "sentry:seer_default_coding_agent", "cursor_background_agent"
+ )
+ self.organization.update_option("sentry:seer_default_coding_agent_integration_id", 42)
+ self.organization.update_option("sentry:auto_open_prs", True)
+
+ mock_bulk_get.return_value = {
+ str(project.id): {"automated_run_stopping_point": "open_pr"},
+ }
+
+ configure_seer_for_existing_org(organization_id=self.organization.id)
+
+ mock_bulk_set.assert_called_once()
+ prefs = mock_bulk_set.call_args[0][1]
+ prefs_by_project = {p["project_id"]: p for p in prefs}
+ assert prefs_by_project[project.id]["automated_run_stopping_point"] == "open_pr"
+ assert prefs_by_project[project.id]["automation_handoff"] == {
+ "handoff_point": "root_cause",
+ "target": "cursor_background_agent",
+ "integration_id": 42,
+ "auto_create_pr": True,
+ }
+
+ @patch("sentry.tasks.seer.autofix.bulk_set_project_preferences")
+ @patch("sentry.tasks.seer.autofix.bulk_get_project_preferences")
+ def test_project_with_invalid_stopping_point_gets_org_default_stopping_point(
+ self, mock_bulk_get: MagicMock, mock_bulk_set: MagicMock
+ ) -> None:
+ """Project with unrecognized stopping point gets org default stopping point applied.
+ Existing handoff (if any) is preserved."""
+ project = self.create_project(organization=self.organization)
+ self.organization.update_option(
+ "sentry:seer_default_coding_agent", "cursor_background_agent"
+ )
+ self.organization.update_option("sentry:seer_default_coding_agent_integration_id", 42)
+
+ existing_handoff = {
+ "handoff_point": "root_cause",
+ "target": "claude_code_agent",
+ "integration_id": 99,
+ "auto_create_pr": False,
+ }
+ mock_bulk_get.return_value = {
+ str(project.id): {
+ "automated_run_stopping_point": "root_cause",
+ "automation_handoff": existing_handoff,
+ },
+ }
+
+ configure_seer_for_existing_org(organization_id=self.organization.id)
+
+ mock_bulk_set.assert_called_once()
+ prefs = mock_bulk_set.call_args[0][1]
+ prefs_by_project = {p["project_id"]: p for p in prefs}
+ assert (
+ prefs_by_project[project.id]["automated_run_stopping_point"]
+ == SEER_AUTOMATED_RUN_STOPPING_POINT_DEFAULT
+ )
+ assert prefs_by_project[project.id]["automation_handoff"] == existing_handoff
+
@patch("sentry.tasks.seer.autofix.bulk_get_project_preferences")
def test_raises_on_bulk_get_api_failure(self, mock_bulk_get: MagicMock) -> None:
"""Test that task raises on bulk GET API failure to trigger retry."""