From 7510f1fd7c340dac96abf45c72f1dfb15027106c Mon Sep 17 00:00:00 2001
From: Copilot <223556219+Copilot@users.noreply.github.com>
Date: Fri, 17 Jul 2026 15:47:03 -0700
Subject: [PATCH 1/2] Fix Round Robin target identity matching

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 0162bbcb-1620-4d09-ac1c-7cfa9ae5046f
---
 frontend/src/App.test.tsx                     | 15 ++++
 frontend/src/App.tsx                          |  8 +-
 .../src/components/Chat/ChatWindow.test.tsx   | 72 +++++++++++++++
 frontend/src/components/Chat/ChatWindow.tsx   | 11 ++-
 frontend/src/types/index.ts                   |  1 +
 frontend/src/utils/targetIdentity.test.ts     | 74 ++++++++++++++++
 frontend/src/utils/targetIdentity.ts          |  9 +-
 pyrit/backend/models/attacks.py               |  2 +
 pyrit/backend/services/attack_service.py      | 12 +--
 tests/unit/backend/test_attack_service.py     | 88 +++++++++++++++++++
 tests/unit/backend/test_mappers.py            | 43 +++++++--
 11 files changed, 311 insertions(+), 24 deletions(-)

diff --git a/frontend/src/App.test.tsx b/frontend/src/App.test.tsx
index 7663291a4d..9f5df1d3be 100644
--- a/frontend/src/App.test.tsx
+++ b/frontend/src/App.test.tsx
@@ -120,6 +120,7 @@ jest.mock("./components/Chat/ChatWindow", () => {
     attackResultId,
     conversationId,
     activeConversationId,
+    attackTarget,
     onConversationCreated,
     onSelectConversation,
     labels,
@@ -129,6 +130,7 @@ jest.mock("./components/Chat/ChatWindow", () => {
     attackResultId: string | null;
     conversationId: string | null;
     activeConversationId: string | null;
+    attackTarget?: { identifier_hash?: string | null } | null;
     onConversationCreated: (attackResultId: string, conversationId: string) => void;
     onSelectConversation: (convId: string) => void;
     labels: Record<string, string>;
@@ -139,6 +141,7 @@ jest.mock("./components/Chat/ChatWindow", () => {
         <span data-testid="conversation-id">{conversationId ?? "none"}</span>
         <span data-testid="active-conversation-id">{activeConversationId ?? "none"}</span>
         <span data-testid="has-target">{activeTarget ? "yes" : "no"}</span>
+        <span data-testid="attack-target-hash">{attackTarget?.identifier_hash ?? "none"}</span>
         <span data-testid="labels-operator">{labels.operator ?? ""}</span>
         <span data-testid="labels-json">{JSON.stringify(labels)}</span>
         <button onClick={onNewAttack} data-testid="new-attack">
@@ -185,6 +188,7 @@ jest.mock("./components/Config/TargetConfig", () => {
             onSetActiveTarget(makeTarget({
               target_registry_name: "test_target",
               target_type: "OpenAIChatTarget",
+              identifier_hash: "test-target-hash",
             }))
           }
           data-testid="set-target"
@@ -386,6 +390,17 @@ describe("App", () => {
     expect(screen.getByTestId("conversation-id")).toHaveTextContent("conv-123");
   });
 
+  it("retains the active target identifier when creating an attack", () => {
+    renderApp();
+
+    fireEvent.click(screen.getByTestId("nav-config"));
+    fireEvent.click(screen.getByTestId("set-target"));
+    fireEvent.click(screen.getByTestId("nav-chat"));
+    fireEvent.click(screen.getByTestId("set-conversation"));
+
+    expect(screen.getByTestId("attack-target-hash")).toHaveTextContent("test-target-hash");
+  });
+
   it("clears conversationId on new attack", () => {
     renderApp();
 
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index c617828545..ae9a572dee 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -18,7 +18,12 @@ import { DEFAULT_GLOBAL_LABELS } from './components/Labels/labelDefaults'
 import { filtersFromSearchParams, filtersToSearchParams } from './components/History/historyFilters'
 import type { ViewName } from './components/Sidebar/Navigation'
 import type { TargetInstance, TargetInfo } from './types'
-import { targetEndpoint, targetModelName, targetType } from './utils/targetIdentity'
+import {
+  targetEndpoint,
+  targetIdentifierHash,
+  targetModelName,
+  targetType,
+} from './utils/targetIdentity'
 import { attacksApi, versionApi } from './services/api'
 import { toApiError } from './services/errors'
 import { useTour } from './hooks/useTour'
@@ -284,6 +289,7 @@ function App() {
           target_type: targetType(activeTarget),
           endpoint: targetEndpoint(activeTarget),
           model_name: targetModelName(activeTarget),
+          identifier_hash: targetIdentifierHash(activeTarget),
         }
       : null
     skipNextLoadForAttackId.current = arId
diff --git a/frontend/src/components/Chat/ChatWindow.test.tsx b/frontend/src/components/Chat/ChatWindow.test.tsx
index f705915964..8d97664de5 100644
--- a/frontend/src/components/Chat/ChatWindow.test.tsx
+++ b/frontend/src/components/Chat/ChatWindow.test.tsx
@@ -1646,6 +1646,7 @@ describe("ChatWindow Integration", () => {
       target_type: "AzureOpenAIChatTarget",
       endpoint: "https://azure.openai.com",
       model_name: "gpt-4o",
+      identifier_hash: "different-target-hash",
     };
 
     render(
@@ -1667,6 +1668,7 @@ describe("ChatWindow Integration", () => {
       target_type: mockTarget.identifier.class_name,
       endpoint: mockTarget.identifier.endpoint,
       model_name: mockTarget.identifier.model_name,
+      identifier_hash: mockTarget.identifier.hash,
     };
 
     render(
@@ -1683,6 +1685,76 @@ describe("ChatWindow Integration", () => {
     expect(screen.queryByTestId("cross-target-banner")).not.toBeInTheDocument();
   });
 
+  it("should keep a historical Round Robin attack writable when the identifier hash matches", () => {
+    const roundRobinTarget = makeTarget({
+      target_registry_name: "round-robin",
+      target_type: "RoundRobinTarget",
+      endpoint: null,
+      model_name: null,
+      identifier_hash: "round-robin-hash",
+      inner_targets: [
+        { target_registry_name: "inner-a", model_name: "e2e-dummy-model" },
+        { target_registry_name: "inner-b", model_name: "e2e-dummy-model" },
+      ],
+    });
+    const historicalTarget: TargetInfo = {
+      target_type: "RoundRobinTarget",
+      endpoint: null,
+      model_name: null,
+      identifier_hash: "round-robin-hash",
+    };
+
+    render(
+      <TestWrapper>
+        <ChatWindow
+          {...defaultProps}
+          activeTarget={roundRobinTarget}
+          attackResultId="ar-round-robin"
+          conversationId="conv-round-robin"
+          attackTarget={historicalTarget}
+        />
+      </TestWrapper>
+    );
+
+    expect(screen.queryByTestId("cross-target-banner")).not.toBeInTheDocument();
+    expect(screen.getByTestId("chat-input")).toBeEnabled();
+  });
+
+  it("should lock a historical Round Robin attack when the composite identifier hash differs", () => {
+    const roundRobinTarget = makeTarget({
+      target_registry_name: "round-robin",
+      target_type: "RoundRobinTarget",
+      endpoint: null,
+      model_name: null,
+      identifier_hash: "active-round-robin-hash",
+      inner_targets: [
+        { target_registry_name: "inner-a", model_name: "e2e-dummy-model" },
+        { target_registry_name: "inner-b", model_name: "e2e-dummy-model" },
+      ],
+    });
+    const historicalTarget: TargetInfo = {
+      target_type: "RoundRobinTarget",
+      endpoint: null,
+      model_name: null,
+      identifier_hash: "different-round-robin-hash",
+    };
+
+    render(
+      <TestWrapper>
+        <ChatWindow
+          {...defaultProps}
+          activeTarget={roundRobinTarget}
+          attackResultId="ar-round-robin"
+          conversationId="conv-round-robin"
+          attackTarget={historicalTarget}
+        />
+      </TestWrapper>
+    );
+
+    expect(screen.getByTestId("cross-target-banner")).toBeInTheDocument();
+    expect(screen.queryByTestId("chat-input")).not.toBeInTheDocument();
+  });
+
   it("should auto-open conversation panel when relatedConversationCount > 0", async () => {
     mockedAttacksApi.getRelatedConversations.mockResolvedValue({
       conversations: [
diff --git a/frontend/src/components/Chat/ChatWindow.tsx b/frontend/src/components/Chat/ChatWindow.tsx
index 73d257d8e2..2e65d07443 100644
--- a/frontend/src/components/Chat/ChatWindow.tsx
+++ b/frontend/src/components/Chat/ChatWindow.tsx
@@ -19,7 +19,7 @@ import { attacksApi } from '../../services/api'
 import { toApiError } from '../../services/errors'
 import { buildMessagePieces, backendMessagesToFrontend } from '../../utils/messageMapper'
 import type { Message, MessageAttachment, TargetInstance, TargetInfo } from '../../types'
-import { targetEndpoint, targetModelName, targetType } from '../../utils/targetIdentity'
+import { targetInfoMatchesTarget } from '../../utils/targetIdentity'
 import type { ViewName } from '../Sidebar/Navigation'
 import { useChatWindowStyles } from './ChatWindow.styles'
 
@@ -543,11 +543,10 @@ export default function ChatWindow({
   // from the currently configured target, prevent sending new messages.
   // The user can "Continue with your target" to branch into a new attack with their target.
   const isCrossTargetLocked = Boolean(
-    attackResultId && attackTarget && activeTarget && (
-      attackTarget.target_type !== targetType(activeTarget) ||
-      (attackTarget.endpoint ?? '') !== (targetEndpoint(activeTarget) ?? '') ||
-      (attackTarget.model_name ?? '') !== (targetModelName(activeTarget) ?? '')
-    )
+    attackResultId &&
+    attackTarget &&
+    activeTarget &&
+    !targetInfoMatchesTarget(attackTarget, activeTarget)
   )
 
   // "Continue with your target" — clone the current conversation into a new attack
diff --git a/frontend/src/types/index.ts b/frontend/src/types/index.ts
index eab139d013..ed0df1d282 100644
--- a/frontend/src/types/index.ts
+++ b/frontend/src/types/index.ts
@@ -170,6 +170,7 @@ export interface TargetInfo {
   target_type: string
   endpoint?: string | null
   model_name?: string | null
+  identifier_hash?: string | null
 }
 
 export interface AttackSummary {
diff --git a/frontend/src/utils/targetIdentity.test.ts b/frontend/src/utils/targetIdentity.test.ts
index 57cfc609db..cb6be17f9e 100644
--- a/frontend/src/utils/targetIdentity.test.ts
+++ b/frontend/src/utils/targetIdentity.test.ts
@@ -2,6 +2,7 @@ import { makeTarget } from '../test-utils/targetFixtures'
 import {
   targetEndpoint,
   targetIdentifierHash,
+  targetInfoMatchesTarget,
   targetModelName,
   targetType,
   targetUnderlyingModelName,
@@ -34,6 +35,79 @@ describe('targetIdentity', () => {
     })
   })
 
+  describe('targetInfoMatchesTarget', () => {
+    it('matches a historical Round Robin target by its identifier hash', () => {
+      const target = makeTarget({
+        target_registry_name: 'round_robin_1',
+        target_type: 'RoundRobinTarget',
+        endpoint: null,
+        model_name: null,
+        identifier_hash: 'round-robin-hash',
+        inner_targets: [
+          { target_registry_name: 'inner_a', model_name: 'e2e-dummy-model' },
+          { target_registry_name: 'inner_b', model_name: 'e2e-dummy-model' },
+        ],
+      })
+
+      expect(targetModelName(target)).toBe('e2e-dummy-model')
+      expect(
+        targetInfoMatchesTarget(
+          {
+            target_type: 'RoundRobinTarget',
+            endpoint: null,
+            model_name: null,
+            identifier_hash: 'round-robin-hash',
+          },
+          target,
+        ),
+      ).toBe(true)
+    })
+
+    it('rejects a different composite with the same root projection', () => {
+      const target = makeTarget({
+        target_registry_name: 'round_robin_1',
+        target_type: 'RoundRobinTarget',
+        endpoint: null,
+        model_name: null,
+        identifier_hash: 'active-round-robin-hash',
+        inner_targets: [
+          { target_registry_name: 'inner_a', model_name: 'e2e-dummy-model' },
+          { target_registry_name: 'inner_b', model_name: 'e2e-dummy-model' },
+        ],
+      })
+
+      expect(
+        targetInfoMatchesTarget(
+          {
+            target_type: 'RoundRobinTarget',
+            endpoint: null,
+            model_name: null,
+            identifier_hash: 'different-round-robin-hash',
+          },
+          target,
+        ),
+      ).toBe(false)
+    })
+
+    it('fails closed when persisted target identity is unavailable', () => {
+      const target = makeTarget({
+        target_registry_name: 'text_1',
+        identifier_hash: 'active-target-hash',
+      })
+
+      expect(
+        targetInfoMatchesTarget(
+          {
+            target_type: target.identifier.class_name,
+            endpoint: target.identifier.endpoint,
+            model_name: target.identifier.model_name,
+          },
+          target,
+        ),
+      ).toBe(false)
+    })
+  })
+
   describe('targetModelName / targetUnderlyingModelName', () => {
     it('returns the target own model name when set', () => {
       const target = makeTarget({
diff --git a/frontend/src/utils/targetIdentity.ts b/frontend/src/utils/targetIdentity.ts
index d49ec004ac..f71b3b9431 100644
--- a/frontend/src/utils/targetIdentity.ts
+++ b/frontend/src/utils/targetIdentity.ts
@@ -1,4 +1,4 @@
-import type { TargetInstance } from '../types'
+import type { TargetInfo, TargetInstance } from '../types'
 
 /**
  * Helpers for reading a target's identity off its embedded `identifier`.
@@ -49,3 +49,10 @@ export function targetEndpoint(target: TargetInstance): string | null {
 export function targetIdentifierHash(target: TargetInstance): string | null {
   return target.identifier.hash ?? null
 }
+
+/** Whether persisted attack target information identifies the active target. */
+export function targetInfoMatchesTarget(targetInfo: TargetInfo, target: TargetInstance): boolean {
+  const persistedHash = targetInfo.identifier_hash
+  const activeHash = targetIdentifierHash(target)
+  return Boolean(persistedHash && activeHash && persistedHash === activeHash)
+}
diff --git a/pyrit/backend/models/attacks.py b/pyrit/backend/models/attacks.py
index 00464ebdcd..6f320f7bd5 100644
--- a/pyrit/backend/models/attacks.py
+++ b/pyrit/backend/models/attacks.py
@@ -31,6 +31,7 @@ class TargetInfo(BaseModel):
     target_type: str = Field(..., description="Target class name (e.g., 'OpenAIChatTarget')")
     endpoint: str | None = Field(None, description="Target endpoint URL")
     model_name: str | None = Field(None, description="Model or deployment name")
+    identifier_hash: str = Field(..., description="Canonical target identifier hash")
 
 
 class ScoreView(Score):
@@ -250,6 +251,7 @@ def target(self) -> TargetInfo | None:
             target_type=target_id.class_name,
             endpoint=cast("str | None", target_id.params.get("endpoint") or None),
             model_name=cast("str | None", target_id.params.get("model_name") or None),
+            identifier_hash=target_id.hash,
         )
 
     @computed_field  # type: ignore[prop-decorator]
diff --git a/pyrit/backend/services/attack_service.py b/pyrit/backend/services/attack_service.py
index 5a2164b221..a3dd0bc516 100644
--- a/pyrit/backend/services/attack_service.py
+++ b/pyrit/backend/services/attack_service.py
@@ -698,16 +698,10 @@ def _validate_target_match(
             return
 
         request_target_id = request_target_obj.get_identifier()
-        if (
-            stored_target_id.class_name != request_target_id.class_name
-            or (stored_target_id.params.get("endpoint") or "") != (request_target_id.params.get("endpoint") or "")
-            or (stored_target_id.params.get("model_name") or "") != (request_target_id.params.get("model_name") or "")
-        ):
+        if stored_target_id.hash != request_target_id.hash:
             raise ValueError(
-                f"Target mismatch: attack was created with "
-                f"{stored_target_id.class_name}/{stored_target_id.params.get('model_name')} "
-                f"but request uses "
-                f"{request_target_id.class_name}/{request_target_id.params.get('model_name')}. "
+                f"Target mismatch: attack was created with {stored_target_id.unique_name} "
+                f"but request uses {request_target_id.unique_name}. "
                 f"Create a new attack to use a different target."
             )
 
diff --git a/tests/unit/backend/test_attack_service.py b/tests/unit/backend/test_attack_service.py
index a4809b1078..adcdaf98c0 100644
--- a/tests/unit/backend/test_attack_service.py
+++ b/tests/unit/backend/test_attack_service.py
@@ -118,6 +118,33 @@ def _make_matching_target_mock() -> MagicMock:
     return mock_target
 
 
+def _make_round_robin_identifier(
+    *,
+    second_model_name: str = "e2e-dummy-model",
+    weights: tuple[int, int] = (1, 1),
+) -> ComponentIdentifier:
+    """Create a composite target identifier with no root endpoint or model."""
+    return ComponentIdentifier(
+        class_name="RoundRobinTarget",
+        class_module="pyrit.prompt_target.round_robin_target",
+        params={"weights": list(weights)},
+        children={
+            "targets": [
+                ComponentIdentifier(
+                    class_name="TextTarget",
+                    class_module="pyrit.prompt_target",
+                    params={"model_name": "e2e-dummy-model"},
+                ),
+                ComponentIdentifier(
+                    class_name="TextTarget",
+                    class_module="pyrit.prompt_target",
+                    params={"model_name": second_model_name},
+                ),
+            ]
+        },
+    )
+
+
 def make_mock_piece(
     *,
     conversation_id: str,
@@ -2710,6 +2737,67 @@ async def test_allows_matching_target(self, attack_service, mock_memory) -> None
             result = await attack_service.add_message_async(attack_result_id="test-id", request=request)
             assert result.attack is not None
 
+    def test_allows_matching_round_robin_target(self, attack_service) -> None:
+        """Equivalent composite identifiers should pass target validation."""
+        stored_target_id = _make_round_robin_identifier()
+        request_target = MagicMock()
+        request_target.get_identifier.return_value = _make_round_robin_identifier()
+        attack_identifier = ComponentIdentifier(
+            class_name="ManualAttack",
+            class_module="pyrit.executor.attack",
+            children={"objective_target": stored_target_id},
+        )
+        request = AddMessageRequest(
+            pieces=[MessagePieceRequest(original_value="Hello")],
+            target_conversation_id="attack-1",
+            send=True,
+            target_registry_name="round-robin",
+        )
+
+        with patch("pyrit.backend.services.attack_service.get_target_service") as mock_get_target_svc:
+            mock_get_target_svc.return_value.get_target_object.return_value = request_target
+
+            attack_service._validate_target_match(attack_identifier=attack_identifier, request=request)
+
+    @pytest.mark.parametrize(
+        ("second_model_name", "weights"),
+        [
+            ("different-model", (1, 1)),
+            ("e2e-dummy-model", (2, 1)),
+        ],
+        ids=["inner-target", "weights"],
+    )
+    def test_rejects_incompatible_round_robin_target(
+        self,
+        attack_service,
+        second_model_name: str,
+        weights: tuple[int, int],
+    ) -> None:
+        """Composite differences should be rejected despite identical nullable root fields."""
+        stored_target_id = _make_round_robin_identifier()
+        request_target = MagicMock()
+        request_target.get_identifier.return_value = _make_round_robin_identifier(
+            second_model_name=second_model_name,
+            weights=weights,
+        )
+        attack_identifier = ComponentIdentifier(
+            class_name="ManualAttack",
+            class_module="pyrit.executor.attack",
+            children={"objective_target": stored_target_id},
+        )
+        request = AddMessageRequest(
+            pieces=[MessagePieceRequest(original_value="Hello")],
+            target_conversation_id="attack-1",
+            send=True,
+            target_registry_name="round-robin",
+        )
+
+        with patch("pyrit.backend.services.attack_service.get_target_service") as mock_get_target_svc:
+            mock_get_target_svc.return_value.get_target_object.return_value = request_target
+
+            with pytest.raises(ValueError, match="Target mismatch"):
+                attack_service._validate_target_match(attack_identifier=attack_identifier, request=request)
+
     async def test_rejects_mismatched_operator(self, attack_service, mock_memory) -> None:
         """Should raise ValueError when request operator differs from attack operator."""
         ar = make_attack_result(conversation_id="test-id")
diff --git a/tests/unit/backend/test_mappers.py b/tests/unit/backend/test_mappers.py
index fd3961652d..667242c613 100644
--- a/tests/unit/backend/test_mappers.py
+++ b/tests/unit/backend/test_mappers.py
@@ -50,24 +50,23 @@ def _make_attack_result(
     *,
     conversation_id: str = "attack-1",
     has_target: bool = True,
+    target_identifier: ComponentIdentifier | None = None,
     name: str = "Test Attack",
     outcome: AttackOutcome = AttackOutcome.UNDETERMINED,
 ) -> AttackResult:
     """Create an AttackResult for mapper tests."""
     now = datetime.now(timezone.utc)
 
-    target_identifier = (
-        ComponentIdentifier(
+    effective_target_identifier = None
+    if has_target:
+        effective_target_identifier = target_identifier or ComponentIdentifier(
             class_name="TextTarget",
             class_module="pyrit.prompt_target",
         )
-        if has_target
-        else None
-    )
 
     children = {}
-    if target_identifier:
-        children["objective_target"] = target_identifier
+    if effective_target_identifier:
+        children["objective_target"] = effective_target_identifier
 
     return AttackResult(
         conversation_id=conversation_id,
@@ -157,6 +156,36 @@ async def test_basic_mapping(self) -> None:
         assert summary.target is not None
         assert summary.target.target_type == "TextTarget"
 
+    async def test_round_robin_target_includes_canonical_identifier_hash(self) -> None:
+        """Composite targets retain their full identity even when root display fields are absent."""
+        target_identifier = ComponentIdentifier(
+            class_name="RoundRobinTarget",
+            class_module="pyrit.prompt_target.round_robin_target",
+            params={"weights": [1, 1]},
+            children={
+                "targets": [
+                    ComponentIdentifier(
+                        class_name="TextTarget",
+                        class_module="pyrit.prompt_target",
+                        params={"model_name": "e2e-dummy-model"},
+                    ),
+                    ComponentIdentifier(
+                        class_name="TextTarget",
+                        class_module="pyrit.prompt_target",
+                        params={"model_name": "e2e-dummy-model"},
+                    ),
+                ]
+            },
+        )
+        ar = _make_attack_result(target_identifier=target_identifier)
+
+        summary = await attack_result_to_summary_async(ar, stats=ConversationStats(message_count=0))
+
+        assert summary.target is not None
+        assert summary.target.target_type == "RoundRobinTarget"
+        assert summary.target.model_name is None
+        assert summary.target.identifier_hash == target_identifier.hash
+
     async def test_empty_pieces_gives_zero_messages(self) -> None:
         """Test mapping with no message pieces."""
         ar = _make_attack_result()

From 61b4b896434ca1372838f91afd12d426096166b0 Mon Sep 17 00:00:00 2001
From: Copilot <223556219+Copilot@users.noreply.github.com>
Date: Mon, 20 Jul 2026 14:56:09 -0700
Subject: [PATCH 2/2] Align frontend target identity contract

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 0162bbcb-1620-4d09-ac1c-7cfa9ae5046f
---
 frontend/src/types/index.ts               |  2 +-
 frontend/src/utils/targetIdentity.test.ts | 18 ------------------
 frontend/src/utils/targetIdentity.ts      |  8 +++-----
 3 files changed, 4 insertions(+), 24 deletions(-)

diff --git a/frontend/src/types/index.ts b/frontend/src/types/index.ts
index ed0df1d282..a3da01bd0a 100644
--- a/frontend/src/types/index.ts
+++ b/frontend/src/types/index.ts
@@ -170,7 +170,7 @@ export interface TargetInfo {
   target_type: string
   endpoint?: string | null
   model_name?: string | null
-  identifier_hash?: string | null
+  identifier_hash: string
 }
 
 export interface AttackSummary {
diff --git a/frontend/src/utils/targetIdentity.test.ts b/frontend/src/utils/targetIdentity.test.ts
index cb6be17f9e..a424c73b9c 100644
--- a/frontend/src/utils/targetIdentity.test.ts
+++ b/frontend/src/utils/targetIdentity.test.ts
@@ -88,24 +88,6 @@ describe('targetIdentity', () => {
         ),
       ).toBe(false)
     })
-
-    it('fails closed when persisted target identity is unavailable', () => {
-      const target = makeTarget({
-        target_registry_name: 'text_1',
-        identifier_hash: 'active-target-hash',
-      })
-
-      expect(
-        targetInfoMatchesTarget(
-          {
-            target_type: target.identifier.class_name,
-            endpoint: target.identifier.endpoint,
-            model_name: target.identifier.model_name,
-          },
-          target,
-        ),
-      ).toBe(false)
-    })
   })
 
   describe('targetModelName / targetUnderlyingModelName', () => {
diff --git a/frontend/src/utils/targetIdentity.ts b/frontend/src/utils/targetIdentity.ts
index f71b3b9431..27ca9e894d 100644
--- a/frontend/src/utils/targetIdentity.ts
+++ b/frontend/src/utils/targetIdentity.ts
@@ -46,13 +46,11 @@ export function targetEndpoint(target: TargetInstance): string | null {
 }
 
 /** The ComponentIdentifier content hash used for duplicate detection. */
-export function targetIdentifierHash(target: TargetInstance): string | null {
-  return target.identifier.hash ?? null
+export function targetIdentifierHash(target: TargetInstance): string {
+  return target.identifier.hash
 }
 
 /** Whether persisted attack target information identifies the active target. */
 export function targetInfoMatchesTarget(targetInfo: TargetInfo, target: TargetInstance): boolean {
-  const persistedHash = targetInfo.identifier_hash
-  const activeHash = targetIdentifierHash(target)
-  return Boolean(persistedHash && activeHash && persistedHash === activeHash)
+  return targetInfo.identifier_hash === targetIdentifierHash(target)
 }