fix(seer): Mark handoffs failed when Seer registration fails entirely

create_seer_run_coding_agent_handoff runs per-repo before the batched
store_coding_agent_states_to_seer call. If that batch call raises
SeerApiError, Seer never learns about any of these agents at all --
for GitHub Copilot/Claude Code, which discover agents to poll purely
by iterating Seer's own copy of them, that means nothing will ever
check on these again. The just-created handoff rows would sit at
their initial pending/running status forever, looking like they're
still in progress.

Mark them failed in that case. launch_coding_agents' return value is
unaffected -- the provider launch itself genuinely succeeded, so
callers should still see it as a success; this only corrects Sentry's
own bookkeeping about whether we expect this row to ever update
again. A Cursor row marked failed here still gets corrected once its
own webhook arrives, since that path doesn't depend on Seer's
registration at all.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: trevor-e

src/sentry/seer/agent/coding_agent_handoff.py

@@ -26,7 +26,10 @@
     store_coding_agent_states_to_seer,
     validate_and_get_integration,
 )
-from sentry.seer.autofix.coding_agent_handoffs import create_seer_run_coding_agent_handoff
+from sentry.seer.autofix.coding_agent_handoffs import (
+    create_seer_run_coding_agent_handoff,
+    mark_seer_run_coding_agent_handoffs_failed,
+)
 from sentry.seer.autofix.utils import CodingAgentState, extract_api_error_message
 from sentry.seer.models import SeerApiError, SeerRepoDefinition
 from sentry.shared_integrations.exceptions import ApiError
@@ -211,6 +214,12 @@ def launch_coding_agents(
                 "repos": [f"{r.owner}/{r.name}" for r in repos],
             },
         )
+        # Seer never learned about these agents, so nothing will ever poll them
+        # again -- mark the rows we just created so they don't sit at pending
+        # forever, looking like they're still in progress.
+        mark_seer_run_coding_agent_handoffs_failed(
+            agent_ids=[state.id for state in states_to_store]
+        )
 
     logger.info(
         "explorer.coding_agent.launch_result",

src/sentry/seer/autofix/coding_agent_handoffs.py

@@ -6,6 +6,7 @@
 from __future__ import annotations
 
 import logging
+from collections.abc import Sequence
 
 from sentry.models.organization import Organization
 from sentry.seer.autofix.utils import (
@@ -15,7 +16,11 @@
     update_coding_agent_state,
 )
 from sentry.seer.endpoints.utils import get_seer_run
-from sentry.seer.models.run import SeerRunCodingAgentHandoff, SeerRunCodingAgentHandoffExtras
+from sentry.seer.models.run import (
+    SeerRunCodingAgentHandoff,
+    SeerRunCodingAgentHandoffExtras,
+    SeerRunCodingAgentHandoffStatus,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -45,6 +50,28 @@ def create_seer_run_coding_agent_handoff(
         logger.exception("seer.coding_agent_handoff.create_failed", extra=log_context)
 
 
+def mark_seer_run_coding_agent_handoffs_failed(agent_ids: Sequence[str]) -> None:
+    """Mark handoffs failed when Seer was never told about them at all. GitHub
+    Copilot/Claude Code polls only discover an agent by iterating Seer's own copy
+    of it, so if that registration never happened, nothing will ever check on it
+    again -- leaving the row at its initial pending/running status would make it
+    look like it's still in progress forever. (A Cursor row marked failed here
+    still gets corrected by its own webhook later, since that path doesn't depend
+    on Seer's registration.)
+    """
+    if not agent_ids:
+        return
+
+    try:
+        SeerRunCodingAgentHandoff.objects.filter(agent_id__in=agent_ids).update(
+            status=SeerRunCodingAgentHandoffStatus.FAILED
+        )
+    except Exception:
+        logger.exception(
+            "seer.coding_agent_handoff.mark_failed_error", extra={"agent_ids": agent_ids}
+        )
+
+
 def sync_coding_agent_status(
     *,
     agent_id: str,

tests/sentry/seer/agent/test_coding_agent_handoff.py

@@ -9,7 +9,7 @@
 from sentry.integrations.cursor.integration import CursorAgentIntegration
 from sentry.seer.agent.coding_agent_handoff import _resolve_client, launch_coding_agents
 from sentry.seer.autofix.utils import CodingAgentProviderType, CodingAgentState
-from sentry.seer.models import SeerRepoDefinition
+from sentry.seer.models import SeerApiError, SeerRepoDefinition
 from sentry.seer.models.run import SeerRunCodingAgentHandoff
 from sentry.shared_integrations.exceptions import ApiError
 from sentry.testutils.cases import TestCase
@@ -147,6 +147,31 @@ def test_successful_launch_persists_seer_run_coding_agent_handoff_row(
         assert handoff.extras["agent_url"] == "https://cursor.sh/agent"
         assert handoff.status == "pending"
 
+    @patch("sentry.seer.agent.coding_agent_handoff.store_coding_agent_states_to_seer")
+    @patch("sentry.seer.agent.coding_agent_handoff.validate_and_get_integration")
+    def test_marks_handoffs_failed_when_seer_storage_errors(self, mock_validate, mock_store):
+        """If Seer never learns about a launched agent at all, GitHub Copilot/Claude
+        polls will never discover it to check on later -- the row must not sit at
+        pending forever, looking like it's still in progress."""
+        self.create_seer_run(self.organization, seer_run_state_id=self.run_id)
+        mock_store.side_effect = SeerApiError("Seer unavailable", status=503)
+        installation = FakeCodingAgentInstallation(_state("agent-123"))
+        mock_validate.return_value = (None, installation)
+
+        result = launch_coding_agents(
+            organization=self.organization,
+            integration_id=1,
+            run_id=self.run_id,
+            prompt="Fix the bug",
+            repos=[_repo("owner", "repo")],
+        )
+
+        # The provider launch itself still succeeded -- callers should still see it.
+        assert len(result["successes"]) == 1
+
+        handoff = SeerRunCodingAgentHandoff.objects.get(agent_id="agent-123")
+        assert handoff.status == "failed"
+
     @patch("sentry.seer.agent.coding_agent_handoff.store_coding_agent_states_to_seer")
     @patch("sentry.seer.agent.coding_agent_handoff.validate_and_get_integration")
     def test_launch_raises_value_error(self, mock_validate, mock_store):

tests/sentry/seer/autofix/test_coding_agent_handoffs.py

@@ -3,6 +3,7 @@
 
 from sentry.seer.autofix.coding_agent_handoffs import (
     create_seer_run_coding_agent_handoff,
+    mark_seer_run_coding_agent_handoffs_failed,
     sync_coding_agent_status,
 )
 from sentry.seer.autofix.utils import (
@@ -72,6 +73,39 @@ def test_noop_when_run_not_found(self, mock_logger: Mock) -> None:
         )
 
 
+class MarkSeerRunCodingAgentHandoffsFailedTest(TestCase):
+    def setUp(self) -> None:
+        self.seer_run = self.create_seer_run(
+            self.organization, type=SeerRunType.FEATURE_RUN, seer_run_state_id=RUN_STATE_ID
+        )
+
+    def test_marks_matching_handoffs_failed(self) -> None:
+        create_seer_run_coding_agent_handoff(self.organization, RUN_STATE_ID, _state("agent-1"))
+        create_seer_run_coding_agent_handoff(self.organization, RUN_STATE_ID, _state("agent-2"))
+
+        mark_seer_run_coding_agent_handoffs_failed(agent_ids=["agent-1", "agent-2"])
+
+        handoffs = SeerRunCodingAgentHandoff.objects.filter(seer_run=self.seer_run)
+        assert all(h.status == "failed" for h in handoffs)
+
+    def test_noop_when_agent_ids_empty(self) -> None:
+        create_seer_run_coding_agent_handoff(self.organization, RUN_STATE_ID, _state("agent-1"))
+
+        mark_seer_run_coding_agent_handoffs_failed(agent_ids=[])
+
+        handoff = SeerRunCodingAgentHandoff.objects.get(agent_id="agent-1")
+        assert handoff.status == "running"
+
+    def test_does_not_touch_unrelated_agents(self) -> None:
+        create_seer_run_coding_agent_handoff(self.organization, RUN_STATE_ID, _state("agent-1"))
+        create_seer_run_coding_agent_handoff(self.organization, RUN_STATE_ID, _state("agent-2"))
+
+        mark_seer_run_coding_agent_handoffs_failed(agent_ids=["agent-1"])
+
+        assert SeerRunCodingAgentHandoff.objects.get(agent_id="agent-1").status == "failed"
+        assert SeerRunCodingAgentHandoff.objects.get(agent_id="agent-2").status == "running"
+
+
 class SyncCodingAgentStatusTest(TestCase):
     def setUp(self) -> None:
         self.seer_run = self.create_seer_run(