From 8a197aa73625bfa07e177f6f3596786bb3c9e83f Mon Sep 17 00:00:00 2001
From: Behnam Ousat <behnamousat@microsoft.com>
Date: Thu, 3 Sep 2026 16:30:19 -0700
Subject: [PATCH 1/4] Add manual message scoring

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 097eaf76-ae49-44f8-b44d-9841fa2cc1cb
---
 .../src/components/Chat/ChatWindow.test.tsx   |   3 +
 frontend/src/components/Chat/ChatWindow.tsx   |  14 +-
 .../src/components/Chat/MessageList.styles.ts |  23 ++++
 .../src/components/Chat/MessageList.test.tsx  |  39 +++++-
 frontend/src/components/Chat/MessageList.tsx  | 129 +++++++++++++++++-
 frontend/src/services/api.ts                  |   9 ++
 frontend/src/types/index.ts                   |   6 +
 pyrit/backend/main.py                         |   2 +
 pyrit/backend/models/scores.py                |  16 +++
 pyrit/backend/routes/scores.py                |  48 +++++++
 pyrit/score/__init__.py                       |   2 +
 pyrit/score/float_scale/manual_scorer.py      |  73 ++++++++++
 tests/unit/backend/test_api_routes.py         |  71 +++++++++-
 tests/unit/score/test_manual_scorer.py        |  44 ++++++
 14 files changed, 469 insertions(+), 10 deletions(-)
 create mode 100644 pyrit/backend/models/scores.py
 create mode 100644 pyrit/backend/routes/scores.py
 create mode 100644 pyrit/score/float_scale/manual_scorer.py
 create mode 100644 tests/unit/score/test_manual_scorer.py

diff --git a/frontend/src/components/Chat/ChatWindow.test.tsx b/frontend/src/components/Chat/ChatWindow.test.tsx
index b932a1e230..5ba7f8ec82 100644
--- a/frontend/src/components/Chat/ChatWindow.test.tsx
+++ b/frontend/src/components/Chat/ChatWindow.test.tsx
@@ -35,6 +35,9 @@ jest.mock("../../services/api", () => ({
     createConversation: jest.fn(),
     changeMainConversation: jest.fn(),
   },
+  scoresApi: {
+    createManualScore: jest.fn(),
+  },
   convertersApi: {
     listConverterCatalog: jest.fn(),
     listConverters: jest.fn(),
diff --git a/frontend/src/components/Chat/ChatWindow.tsx b/frontend/src/components/Chat/ChatWindow.tsx
index bc7286d86e..a894f6601e 100644
--- a/frontend/src/components/Chat/ChatWindow.tsx
+++ b/frontend/src/components/Chat/ChatWindow.tsx
@@ -33,7 +33,7 @@ import type { PieceConversion } from './converterTypes'
 import { PIECE_TYPE_TO_DATA_TYPE, basenameFromValue, buildMediaUrl, dataTypeToAttachmentKind, isPathDataType } from './converterTypes'
 import LabelsBar from '../Labels/LabelsBar'
 import type { ChatInputAreaHandle } from './ChatInputArea'
-import { attacksApi } from '../../services/api'
+import { attacksApi, scoresApi } from '../../services/api'
 import { toApiError } from '../../services/errors'
 import { buildMessagePieces, backendMessagesToFrontend } from '../../utils/messageMapper'
 import { exportConversation } from '../../utils/conversationExport'
@@ -690,6 +690,17 @@ export default function ChatWindow({
     isMutationLocked,
   ])
 
+  const handleManualScore = useCallback(async (messageId: string, value: number, rationale: string) => {
+    if (!attackResultId || !activeConversationId || isMutationLocked) return
+
+    await scoresApi.createManualScore({
+      message_id: messageId,
+      value,
+      rationale,
+    })
+    await loadConversation(attackResultId, activeConversationId)
+  }, [activeConversationId, attackResultId, isMutationLocked, loadConversation])
+
   const singleTurnLimitReached = activeTarget?.capabilities?.supports_multi_turn === false && messages.some(m => m.role === 'user')
 
   // "Continue with your target" — clone the current conversation into a new attack
@@ -883,6 +894,7 @@ export default function ChatWindow({
           isCrossTarget={isCrossTargetLocked || isTargetResolutionLocked}
           noTargetSelected={!activeTarget}
           globalMarkdown={globalMarkdown}
+          onManualScore={!isMutationLocked && attackResultId ? handleManualScore : undefined}
         />
         <ChatInputArea
           ref={inputBoxRef}
diff --git a/frontend/src/components/Chat/MessageList.styles.ts b/frontend/src/components/Chat/MessageList.styles.ts
index 74bab6e709..4f80d5ae25 100644
--- a/frontend/src/components/Chat/MessageList.styles.ts
+++ b/frontend/src/components/Chat/MessageList.styles.ts
@@ -101,6 +101,29 @@ export const useMessageListStyles = makeStyles({
     flexShrink: 0,
     alignSelf: 'flex-end',
   },
+  scoreControls: {
+    display: 'flex',
+    alignItems: 'center',
+    justifyContent: 'flex-end',
+    flexWrap: 'wrap',
+    gap: tokens.spacingHorizontalXXS,
+  },
+  manualScorePopover: {
+    display: 'flex',
+    flexDirection: 'column',
+    gap: tokens.spacingVerticalS,
+    width: 'min(320px, calc(100vw - 32px))',
+  },
+  manualScorePresets: {
+    display: 'flex',
+    flexWrap: 'wrap',
+    gap: tokens.spacingHorizontalXXS,
+  },
+  manualScoreActions: {
+    display: 'flex',
+    justifyContent: 'flex-end',
+    gap: tokens.spacingHorizontalS,
+  },
   scoreChip: {
     minWidth: '32px',
     maxWidth: 'min(160px, calc(100vw - 64px))',
diff --git a/frontend/src/components/Chat/MessageList.test.tsx b/frontend/src/components/Chat/MessageList.test.tsx
index 25defdd748..99b6a8a082 100644
--- a/frontend/src/components/Chat/MessageList.test.tsx
+++ b/frontend/src/components/Chat/MessageList.test.tsx
@@ -1,4 +1,4 @@
-import { render, screen, fireEvent, within } from "@testing-library/react";
+import { render, screen, fireEvent, waitFor, within } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { FluentProvider, webLightTheme } from "@fluentui/react-components";
 import MessageList from "./MessageList";
@@ -117,6 +117,43 @@ describe("MessageList", () => {
     expect(screen.getByText("Assistant message test")).toBeInTheDocument();
   });
 
+  it("should submit a manual score for a persisted message piece", async () => {
+    const user = userEvent.setup();
+    const onManualScore = jest.fn().mockResolvedValue(undefined);
+    const messages: Message[] = [
+      {
+        role: "assistant",
+        content: "Response to score",
+        timestamp: new Date().toISOString(),
+        displayPieces: [
+          {
+            type: "text",
+            pieceId: "piece-manual",
+            pieceIndex: 0,
+            content: "Response to score",
+            scores: [],
+          },
+        ],
+      },
+    ];
+
+    render(
+      <TestWrapper>
+        <MessageList messages={messages} onManualScore={onManualScore} />
+      </TestWrapper>
+    );
+
+    await user.click(screen.getByRole("button", { name: "Add manual score" }));
+    await user.click(screen.getByRole("button", { name: "0.33" }));
+    await user.type(screen.getByLabelText("Manual score rationale"), "Partially satisfied");
+    await user.click(screen.getByRole("button", { name: "Save" }));
+
+    await waitFor(() => {
+      expect(onManualScore).toHaveBeenCalledWith("piece-manual", 0.33, "Partially satisfied");
+    });
+    expect(screen.queryByText("Manual score")).not.toBeInTheDocument();
+  });
+
   it("should show the message score and its details when present", async () => {
     const user = userEvent.setup();
     const scoredMessages: Message[] = [
diff --git a/frontend/src/components/Chat/MessageList.tsx b/frontend/src/components/Chat/MessageList.tsx
index f7f670e210..1295a58ef8 100644
--- a/frontend/src/components/Chat/MessageList.tsx
+++ b/frontend/src/components/Chat/MessageList.tsx
@@ -7,6 +7,8 @@ import {
   MessageBarBody,
   Button,
   Badge,
+  Field,
+  Input,
   Menu,
   MenuItem,
   MenuList,
@@ -19,6 +21,7 @@ import {
   TabList,
   Tooltip,
   Spinner,
+  Textarea,
   mergeClasses,
 } from '@fluentui/react-components'
 import {
@@ -27,6 +30,7 @@ import {
   ArrowReplyRegular,
   BranchForkRegular,
   ChatAddRegular,
+  GaugeRegular,
   MoreHorizontalRegular,
   OpenRegular,
 } from '@fluentui/react-icons'
@@ -57,6 +61,8 @@ interface MessageListProps {
   noTargetSelected?: boolean
   /** Conversation-wide default: render message text as Markdown. */
   globalMarkdown?: boolean
+  /** Persist a manual score for a message piece. */
+  onManualScore?: (messageId: string, value: number, rationale: string) => Promise<void>
 }
 
 /** Image that shows a spinner while loading. */
@@ -113,6 +119,105 @@ function scoreDisplayLabel(score: DisplayScore): string {
   return `Score: ${scoreDisplayValue(score)}`
 }
 
+const MANUAL_SCORE_PRESETS = [0, 0.25, 0.33, 0.5, 0.66, 0.75, 1]
+
+interface ManualScorePopoverProps {
+  messageId: string
+  onSave: (messageId: string, value: number, rationale: string) => Promise<void>
+}
+
+function ManualScorePopover({ messageId, onSave }: ManualScorePopoverProps) {
+  const styles = useMessageListStyles()
+  const [isOpen, setIsOpen] = useState(false)
+  const [value, setValue] = useState('0.5')
+  const [rationale, setRationale] = useState('')
+  const [isSaving, setIsSaving] = useState(false)
+  const [error, setError] = useState('')
+  const numericValue = Number(value)
+  const isValueValid = value.trim() !== '' && Number.isFinite(numericValue) && numericValue >= 0 && numericValue <= 1
+
+  const handleSave = async () => {
+    if (!isValueValid) return
+
+    setIsSaving(true)
+    setError('')
+    try {
+      await onSave(messageId, numericValue, rationale)
+      setIsOpen(false)
+      setRationale('')
+    } catch {
+      setError('Unable to save the manual score.')
+    } finally {
+      setIsSaving(false)
+    }
+  }
+
+  return (
+    <Popover
+      withArrow
+      open={isOpen}
+      onOpenChange={(_event: unknown, data: { open: boolean }) => {
+        setIsOpen(data.open)
+        if (!data.open) setError('')
+      }}
+    >
+      <Tooltip content="Add manual score" relationship="label">
+        <PopoverTrigger disableButtonEnhancement>
+          <Button
+            appearance="subtle"
+            size="small"
+            icon={<GaugeRegular />}
+            aria-label="Add manual score"
+            className={styles.messageActionButton}
+          />
+        </PopoverTrigger>
+      </Tooltip>
+      <PopoverSurface className={styles.manualScorePopover}>
+        <Text weight="semibold">Manual score</Text>
+        <div className={styles.manualScorePresets} aria-label="Score presets">
+          {MANUAL_SCORE_PRESETS.map((preset) => (
+            <Button key={preset} size="small" onClick={() => setValue(String(preset))}>
+              {preset}
+            </Button>
+          ))}
+        </div>
+        <Field
+          label="Value"
+          validationState={value && !isValueValid ? 'error' : 'none'}
+          validationMessage={value && !isValueValid ? 'Enter a number from 0 to 1.' : undefined}
+        >
+          <Input
+            type="number"
+            min={0}
+            max={1}
+            step="any"
+            value={value}
+            onChange={(_event, data) => setValue(data.value)}
+            aria-label="Manual score value"
+          />
+        </Field>
+        <Field label="Rationale">
+          <Textarea
+            value={rationale}
+            onChange={(_event, data) => setRationale(data.value)}
+            aria-label="Manual score rationale"
+            resize="vertical"
+          />
+        </Field>
+        {error && <Text role="alert">{error}</Text>}
+        <div className={styles.manualScoreActions}>
+          <Button appearance="secondary" onClick={() => setIsOpen(false)} disabled={isSaving}>
+            Cancel
+          </Button>
+          <Button appearance="primary" onClick={handleSave} disabled={!isValueValid || isSaving}>
+            {isSaving ? 'Saving...' : 'Save'}
+          </Button>
+        </div>
+      </PopoverSurface>
+    </Popover>
+  )
+}
+
 function ScoreDetails({ score, testId }: { score: DisplayScore; testId: string }) {
   const styles = useMessageListStyles()
   const categories = score.score_category?.filter(Boolean) ?? []
@@ -541,7 +646,7 @@ function getRenderMessagePieces(message: Message, messageIndex: number): RenderM
   return pieces
 }
 
-export default function MessageList({ messages, onCopyToInput, onCopyToNewConversation, onBranchConversation, onBranchAttack, isLoading, isSingleTurn, isOperatorLocked, isCrossTarget, noTargetSelected, globalMarkdown = false }: MessageListProps) {
+export default function MessageList({ messages, onCopyToInput, onCopyToNewConversation, onBranchConversation, onBranchAttack, isLoading, isSingleTurn, isOperatorLocked, isCrossTarget, noTargetSelected, globalMarkdown = false, onManualScore }: MessageListProps) {
   const styles = useMessageListStyles()
   const messagesEndRef = useRef<HTMLDivElement>(null)
 
@@ -698,9 +803,14 @@ export default function MessageList({ messages, onCopyToInput, onCopyToNewConver
                           ) : (
                             <Text className={styles.messageText}>{piece.content}</Text>
                           )}
-                          {piece.scores && piece.scores.length > 0 && (
-                            <MessageScores scores={piece.scores} groupId={groupId} />
-                          )}
+                          <div className={styles.scoreControls}>
+                            {piece.scores && piece.scores.length > 0 && (
+                              <MessageScores scores={piece.scores} groupId={groupId} />
+                            )}
+                            {message.displayPieces && onManualScore && (
+                              <ManualScorePopover messageId={piece.pieceId} onSave={onManualScore} />
+                            )}
+                          </div>
                         </div>
                       )
                     }
@@ -747,9 +857,14 @@ export default function MessageList({ messages, onCopyToInput, onCopyToNewConver
                             )}
                           </div>
                         )}
-                        {piece.scores && piece.scores.length > 0 && (
-                          <MessageScores scores={piece.scores} groupId={groupId} />
-                        )}
+                        <div className={styles.scoreControls}>
+                          {piece.scores && piece.scores.length > 0 && (
+                            <MessageScores scores={piece.scores} groupId={groupId} />
+                          )}
+                          {message.displayPieces && onManualScore && (
+                            <ManualScorePopover messageId={piece.pieceId} onSave={onManualScore} />
+                          )}
+                        </div>
                       </div>
                     )
                   })}
diff --git a/frontend/src/services/api.ts b/frontend/src/services/api.ts
index 7a9544ae3a..5847c33a53 100644
--- a/frontend/src/services/api.ts
+++ b/frontend/src/services/api.ts
@@ -38,6 +38,8 @@ import type {
   EnvironmentFileListResponse,
   UpdateConfigurationFileRequest,
   AuthAccess,
+  BackendScore,
+  ManualScoreRequest,
 } from '../types'
 
 const API_BASE_URL = import.meta.env.VITE_API_URL || '/api'
@@ -360,6 +362,13 @@ export const attacksApi = {
   },
 }
 
+export const scoresApi = {
+  createManualScore: async (request: ManualScoreRequest): Promise<BackendScore> => {
+    const response = await apiClient.post('/scores/manual', request)
+    return response.data
+  },
+}
+
 export const labelsApi = {
   getLabels: async (source: string = 'attacks'): Promise<{ source: string; labels: Record<string, string[]> }> => {
     const response = await apiClient.get('/labels', { params: { source } })
diff --git a/frontend/src/types/index.ts b/frontend/src/types/index.ts
index ebaf8caeb8..e08d50a6be 100644
--- a/frontend/src/types/index.ts
+++ b/frontend/src/types/index.ts
@@ -343,6 +343,12 @@ export interface BackendScore {
   timestamp: string
 }
 
+export interface ManualScoreRequest {
+  message_id: string
+  value: number
+  rationale: string
+}
+
 /** Score enriched with message-piece presentation fields for transcript rendering. */
 export interface DisplayScore extends BackendScore {
   pieceIndex: number
diff --git a/pyrit/backend/main.py b/pyrit/backend/main.py
index b0df310797..2f8508ebb2 100644
--- a/pyrit/backend/main.py
+++ b/pyrit/backend/main.py
@@ -34,6 +34,7 @@
     labels,
     media,
     scenarios,
+    scores,
     targets,
     version,
 )
@@ -162,6 +163,7 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
 app.include_router(health.router, prefix="/api", tags=["health"])
 app.include_router(auth.router, prefix="/api", tags=["auth"])
 app.include_router(media.router, prefix="/api", tags=["media"])
+app.include_router(scores.router, prefix="/api", tags=["scores"])
 app.include_router(version.router, tags=["version"])
 
 
diff --git a/pyrit/backend/models/scores.py b/pyrit/backend/models/scores.py
new file mode 100644
index 0000000000..69fc8b43a9
--- /dev/null
+++ b/pyrit/backend/models/scores.py
@@ -0,0 +1,16 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+"""Score-related API request models."""
+
+import uuid
+
+from pydantic import BaseModel, Field
+
+
+class ManualScoreRequest(BaseModel):
+    """Request to attach a user-supplied score to a message piece."""
+
+    message_id: uuid.UUID = Field(..., description="ID of the message piece to score")
+    value: float = Field(..., ge=0, le=1, description="Score value between 0 and 1")
+    rationale: str = Field(..., description="Explanation for the score")
diff --git a/pyrit/backend/routes/scores.py b/pyrit/backend/routes/scores.py
new file mode 100644
index 0000000000..1ab5518733
--- /dev/null
+++ b/pyrit/backend/routes/scores.py
@@ -0,0 +1,48 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+"""Score API routes."""
+
+import asyncio
+
+from fastapi import APIRouter, HTTPException, status
+
+from pyrit.backend.models.attacks import ScoreView
+from pyrit.backend.models.common import ProblemDetail
+from pyrit.backend.models.scores import ManualScoreRequest
+from pyrit.memory import CentralMemory
+from pyrit.models import MessageScorable
+from pyrit.score import ManualScorer
+
+router = APIRouter(prefix="/scores", tags=["scores"])
+
+
+@router.post(
+    "/manual",
+    response_model=ScoreView,
+    status_code=status.HTTP_201_CREATED,
+    responses={
+        404: {"model": ProblemDetail, "description": "Message not found"},
+        422: {"model": ProblemDetail, "description": "Validation error"},
+    },
+)
+async def create_manual_score(request: ManualScoreRequest) -> ScoreView:  # pyrit-async-suffix-exempt
+    """
+    Create and persist a manual score for a message piece.
+
+    Returns:
+        ScoreView: The persisted manual score.
+    """
+    memory = CentralMemory.get_memory_instance()
+    pieces = await asyncio.to_thread(memory.get_message_pieces, prompt_ids=[request.message_id])
+    if not any(str(piece.id) == str(request.message_id) for piece in pieces):
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Message '{request.message_id}' not found",
+        )
+
+    scorer = ManualScorer(value=request.value, rationale=request.rationale)
+    scores = await scorer.score_async(
+        scorable=MessageScorable(message_piece_ids=(request.message_id,)),
+    )
+    return ScoreView.from_domain(scores[0])
diff --git a/pyrit/score/__init__.py b/pyrit/score/__init__.py
index af0ecd59c9..da68957fa5 100644
--- a/pyrit/score/__init__.py
+++ b/pyrit/score/__init__.py
@@ -25,6 +25,7 @@
     from pyrit.score.float_scale.float_scale_scorer import FloatScaleScorer, MessageFloatScaleScorer
     from pyrit.score.float_scale.insecure_code_scorer import InsecureCodeScorer, render_insecure_code_system_prompt
     from pyrit.score.float_scale.likert_scale import LikertScale, LikertScaleEntry
+    from pyrit.score.float_scale.manual_scorer import ManualScorer
     from pyrit.score.float_scale.numeric_scale import NumericRange, NumericRubric
     from pyrit.score.float_scale.plagiarism_scorer import PlagiarismMetric, PlagiarismScorer
     from pyrit.score.float_scale.roblox_pii_scorer import RobloxPiiCategory, RobloxPiiScorer
@@ -173,6 +174,7 @@
     "LlamaGuardPolicy": "pyrit.score.true_false.llamaguard_policy",
     "LlamaGuardScorer": "pyrit.score.true_false.llamaguard_scorer",
     "MarkdownInjectionScorer": "pyrit.score.true_false.regex.markdown_injection",
+    "ManualScorer": "pyrit.score.float_scale.manual_scorer",
     "MessageScorableResolver": "pyrit.score.message_scorable_resolver",
     "MessageScorable": "pyrit.score.scorable",
     "MessageScorer": "pyrit.score.message_scorer",
diff --git a/pyrit/score/float_scale/manual_scorer.py b/pyrit/score/float_scale/manual_scorer.py
new file mode 100644
index 0000000000..d7673cad60
--- /dev/null
+++ b/pyrit/score/float_scale/manual_scorer.py
@@ -0,0 +1,73 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+from __future__ import annotations
+
+from pyrit.models import ComponentIdentifier, MessageScorable, Scorable, Score, ScoringExpectation
+from pyrit.score.float_scale.float_scale_scorer import FloatScaleScorer
+
+
+class ManualScorer(FloatScaleScorer):
+    """Create a user-supplied score for one persisted message piece."""
+
+    def __init__(self, *, value: float, rationale: str) -> None:
+        """
+        Initialize the scorer.
+
+        Args:
+            value (float): User-supplied score in the range [0, 1].
+            rationale (str): User-supplied explanation for the score.
+
+        Raises:
+            ValueError: If ``value`` is outside the range [0, 1].
+        """
+        if not 0 <= value <= 1:
+            raise ValueError("Manual score value must be between 0 and 1.")
+
+        self._value = value
+        self._rationale = rationale
+        super().__init__()
+
+    def _build_identifier(self) -> ComponentIdentifier:
+        """
+        Build the scorer identifier.
+
+        Returns:
+            ComponentIdentifier: The scorer identifier.
+        """
+        return self._create_identifier(params={"value": self._value, "rationale": self._rationale})
+
+    async def _score_scorable_async(
+        self,
+        *,
+        scorable: Scorable,
+        expectation: ScoringExpectation | None,
+    ) -> list[Score]:
+        """
+        Create the configured score for a persisted message piece.
+
+        Returns:
+            list[Score]: A list containing the manual score.
+
+        Raises:
+            TypeError: If ``scorable`` does not identify a message piece.
+            ValueError: If ``scorable`` identifies more than one message piece.
+        """
+        if not isinstance(scorable, MessageScorable):
+            raise TypeError("ManualScorer requires a MessageScorable.")
+        if len(scorable.message_piece_ids) != 1:
+            raise ValueError("ManualScorer requires exactly one message piece.")
+
+        message_piece_id = scorable.message_piece_ids[0]
+        return [
+            Score(
+                score_value=format(self._value, "g"),
+                score_value_description="Manually assigned score",
+                score_type="float_scale",
+                score_rationale=self._rationale,
+                scorer_class_identifier=self.get_identifier(),
+                message_piece_id=message_piece_id,
+                scorable=scorable,
+                objective=expectation.objective if expectation else None,
+            )
+        ]
diff --git a/tests/unit/backend/test_api_routes.py b/tests/unit/backend/test_api_routes.py
index 90f3a512d2..1041aa3fae 100644
--- a/tests/unit/backend/test_api_routes.py
+++ b/tests/unit/backend/test_api_routes.py
@@ -8,6 +8,7 @@
 import json
 import os
 import tempfile
+import uuid
 from datetime import datetime, timezone
 from unittest.mock import AsyncMock, MagicMock, patch
 
@@ -40,7 +41,7 @@
 )
 from pyrit.backend.routes import version as version_routes
 from pyrit.backend.routes.labels import get_label_options
-from pyrit.models import ConverterIdentifier, MessagePiece, TargetCapabilities, TargetIdentifier
+from pyrit.models import ConverterIdentifier, MessagePiece, Score, TargetCapabilities, TargetIdentifier
 from pyrit.models.catalog.target import TargetInstance
 
 
@@ -1341,6 +1342,74 @@ def test_get_version_build_info_load_failure(self, client: TestClient) -> None:
         assert data["commit"] is None
 
 
+class TestScoreRoutes:
+    """Tests for score API routes."""
+
+    def test_create_manual_score(self, client: TestClient) -> None:
+        """Test creating and persisting a manual score."""
+        message_id = uuid.uuid4()
+        score = Score(
+            score_value="0.75",
+            score_type="float_scale",
+            score_rationale="Mostly satisfied",
+            message_piece_id=message_id,
+        )
+
+        with (
+            patch("pyrit.backend.routes.scores.CentralMemory") as mock_memory_class,
+            patch("pyrit.backend.routes.scores.ManualScorer") as mock_manual_scorer_class,
+        ):
+            mock_memory_class.get_memory_instance.return_value.get_message_pieces.return_value = [
+                MagicMock(id=message_id)
+            ]
+            mock_scorer = mock_manual_scorer_class.return_value
+            mock_scorer.score_async = AsyncMock(return_value=[score])
+
+            response = client.post(
+                "/api/scores/manual",
+                json={
+                    "message_id": str(message_id),
+                    "value": 0.75,
+                    "rationale": "Mostly satisfied",
+                },
+            )
+
+        assert response.status_code == status.HTTP_201_CREATED
+        assert response.json()["score_value"] == "0.75"
+        assert response.json()["score_rationale"] == "Mostly satisfied"
+        mock_manual_scorer_class.assert_called_once_with(value=0.75, rationale="Mostly satisfied")
+        scorable = mock_scorer.score_async.await_args.kwargs["scorable"]
+        assert scorable.message_piece_ids == (message_id,)
+
+    def test_create_manual_score_message_not_found(self, client: TestClient) -> None:
+        """Test that a missing message returns 404 without running the scorer."""
+        message_id = uuid.uuid4()
+
+        with (
+            patch("pyrit.backend.routes.scores.CentralMemory") as mock_memory_class,
+            patch("pyrit.backend.routes.scores.ManualScorer") as mock_manual_scorer_class,
+        ):
+            mock_memory_class.get_memory_instance.return_value.get_message_pieces.return_value = []
+
+            response = client.post(
+                "/api/scores/manual",
+                json={"message_id": str(message_id), "value": 0.5, "rationale": ""},
+            )
+
+        assert response.status_code == status.HTTP_404_NOT_FOUND
+        mock_manual_scorer_class.assert_not_called()
+
+    @pytest.mark.parametrize("value", [-0.01, 1.01])
+    def test_create_manual_score_rejects_value_outside_range(self, client: TestClient, value: float) -> None:
+        """Test request validation for the manual score range."""
+        response = client.post(
+            "/api/scores/manual",
+            json={"message_id": str(uuid.uuid4()), "value": value, "rationale": ""},
+        )
+
+        assert response.status_code == status.HTTP_422_UNPROCESSABLE_CONTENT
+
+
 # ============================================================================
 # Health Routes Tests
 # ============================================================================
diff --git a/tests/unit/score/test_manual_scorer.py b/tests/unit/score/test_manual_scorer.py
new file mode 100644
index 0000000000..6d96af77f0
--- /dev/null
+++ b/tests/unit/score/test_manual_scorer.py
@@ -0,0 +1,44 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+import uuid
+
+import pytest
+
+from pyrit.memory import MemoryInterface
+from pyrit.models import ContentScorable, MessagePiece, MessageScorable
+from pyrit.score import ManualScorer
+
+
+@pytest.mark.usefixtures("patch_central_database")
+async def test_manual_scorer_persists_value_and_rationale(sqlite_instance: MemoryInterface) -> None:
+    message = MessagePiece(
+        role="assistant",
+        original_value="response",
+        conversation_id=str(uuid.uuid4()),
+    ).to_message()
+    sqlite_instance.add_message_to_memory(request=message)
+    message_id = message.get_piece().id
+
+    scores = await ManualScorer(value=0.75, rationale="Mostly satisfied").score_async(
+        scorable=MessageScorable(message_piece_ids=(message_id,)),
+    )
+
+    assert len(scores) == 1
+    assert scores[0].get_value() == 0.75
+    assert scores[0].score_rationale == "Mostly satisfied"
+    assert scores[0].message_piece_id == message_id
+    assert sqlite_instance.get_prompt_scores(prompt_ids=[message_id])[0].id == scores[0].id
+
+
+@pytest.mark.parametrize("value", [-0.01, 1.01, float("nan")])
+def test_manual_scorer_rejects_value_outside_range(value: float) -> None:
+    with pytest.raises(ValueError, match="between 0 and 1"):
+        ManualScorer(value=value, rationale="")
+
+
+async def test_manual_scorer_rejects_non_message_scorable() -> None:
+    scorer = ManualScorer(value=0.5, rationale="")
+
+    with pytest.raises(RuntimeError, match="ManualScorer requires a MessageScorable"):
+        await scorer.score_async(scorable=ContentScorable(value="content"))

From 0f3f87172623ac73c69cee5af065903399f5b100 Mon Sep 17 00:00:00 2001
From: jbolor21 <86250273+jbolor21@users.noreply.github.com>
Date: Sun, 6 Sep 2026 17:03:28 -0700
Subject: [PATCH 2/4] initial draft

---
 frontend/src/App.tsx                          |   9 +-
 .../src/components/Chat/ChatWindow.test.tsx   |  86 ++++-
 frontend/src/components/Chat/ChatWindow.tsx   |  49 ++-
 .../src/components/Chat/MessageList.styles.ts |  41 ++-
 .../src/components/Chat/MessageList.test.tsx  | 175 +++++++++-
 frontend/src/components/Chat/MessageList.tsx  | 217 +++++++++---
 .../components/Chat/ObjectiveHeader.styles.ts |   7 +
 .../components/Chat/ObjectiveHeader.test.tsx  |  32 ++
 .../src/components/Chat/ObjectiveHeader.tsx   | 111 ++++++-
 frontend/src/services/api.ts                  |   6 +
 frontend/src/types/index.ts                   |  28 +-
 pyrit/backend/models/attacks.py               |  24 +-
 pyrit/backend/models/scores.py                |  43 ++-
 pyrit/backend/routes/attacks.py               |   4 +-
 pyrit/backend/routes/scores.py                |  92 +++++-
 pyrit/backend/services/attack_service.py      |  28 +-
 pyrit/score/__init__.py                       |   2 +
 pyrit/score/float_scale/manual_scorer.py      |  17 +-
 tests/unit/backend/test_api_routes.py         | 308 +++++++++++++++++-
 tests/unit/backend/test_attack_service.py     |  16 +
 tests/unit/score/test_manual_scorer.py        |  28 +-
 21 files changed, 1210 insertions(+), 113 deletions(-)

diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index 831e960d8d..c11824ae4f 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -375,7 +375,7 @@ function App() {
     navigate(VIEW_PATHS.chat)
   }, [navigate])
 
-  const handleConversationCreated = useCallback((arId: string, convId: string) => {
+  const handleConversationCreated = useCallback((arId: string, convId: string, objective?: string) => {
     // Seed the freshly-created attack synchronously and tell the loader to skip
     // its next fetch for this id, so the attack opens without a redundant load.
     if (activeTarget) {
@@ -404,7 +404,7 @@ function App() {
       labels: null,
       target,
       relatedConversationIds: [],
-      objective: '',
+      objective: objective ?? '',
       status: 'success',
     })
     // Replace when promoting an empty /chat to its attack url (first message);
@@ -412,6 +412,10 @@ function App() {
     navigate(attackRoutePath(arId), { replace: routeAttackId === null })
   }, [activeTarget, handleSetActiveTarget, routeAttackId, navigate])
 
+  const handleObjectiveChange = useCallback((objective: string) => {
+    setLoadedAttack((current) => current ? { ...current, objective } : current)
+  }, [])
+
   const handleSelectConversation = useCallback((convId: string) => {
     if (!routeAttackId) return
     navigate(attackConversationRoutePath(routeAttackId, convId, scenarioResultId))
@@ -437,6 +441,7 @@ function App() {
       activeConversationId={activeConversationId}
       onConversationCreated={handleConversationCreated}
       onSelectConversation={handleSelectConversation}
+      onObjectiveChange={handleObjectiveChange}
       labels={globalLabels}
       onLabelsChange={handleGlobalLabelsChange}
       onNavigate={handleNavigate}
diff --git a/frontend/src/components/Chat/ChatWindow.test.tsx b/frontend/src/components/Chat/ChatWindow.test.tsx
index 5ba7f8ec82..c61885a601 100644
--- a/frontend/src/components/Chat/ChatWindow.test.tsx
+++ b/frontend/src/components/Chat/ChatWindow.test.tsx
@@ -28,6 +28,7 @@ jest.setTimeout(60000);
 jest.mock("../../services/api", () => ({
   attacksApi: {
     createAttack: jest.fn(),
+    updateAttack: jest.fn(),
     addMessage: jest.fn(),
     getMessages: jest.fn(),
     getRelatedConversations: jest.fn(),
@@ -529,6 +530,7 @@ describe("ChatWindow Integration", () => {
     // Banner in ChatInputArea area
     expect(screen.getByTestId("no-target-banner")).toBeInTheDocument();
     expect(screen.getByTestId("configure-target-input-btn")).toBeInTheDocument();
+    expect(screen.queryByRole("button", { name: /add objective/i })).not.toBeInTheDocument();
   });
 
   it("should call onNewAttack when New Attack button is clicked", async () => {
@@ -710,7 +712,7 @@ describe("ChatWindow Integration", () => {
         target_registry_name: "openai_chat_1",
         labels: { operator: 'testuser', operation: 'test_op' },
       });
-      expect(onConversationCreated).toHaveBeenCalledWith("ar-conv-1", "conv-1");
+      expect(onConversationCreated).toHaveBeenCalledWith("ar-conv-1", "conv-1", undefined);
       expect(mockedAttacksApi.addMessage).toHaveBeenCalledWith("ar-conv-1", {
         role: "user",
         pieces: [{ data_type: "text", original_value: "Hello" }],
@@ -727,6 +729,49 @@ describe("ChatWindow Integration", () => {
     });
   });
 
+  it("should persist a new conversation objective when the first message creates the attack", async () => {
+    const user = userEvent.setup();
+    const onConversationCreated = jest.fn();
+    mockedMapper.buildMessagePieces.mockResolvedValue([
+      { data_type: "text", original_value: "Hello" },
+    ]);
+    mockedAttacksApi.createAttack.mockResolvedValue({
+      attack_result_id: "ar-objective",
+      conversation_id: "conv-objective",
+      created_at: "2026-01-01T00:00:00Z",
+    });
+    mockedAttacksApi.addMessage.mockResolvedValue(makeTextResponse("Hello back!") as never);
+    mockedMapper.backendMessagesToFrontend.mockReturnValue([]);
+
+    render(
+      <TestWrapper>
+        <ChatWindow
+          {...defaultProps}
+          onConversationCreated={onConversationCreated}
+        />
+      </TestWrapper>
+    );
+
+    await user.click(screen.getByRole("button", { name: /add objective/i }));
+    await user.type(screen.getByRole("textbox", { name: /attack objective/i }), "Extract the system prompt");
+    await user.click(screen.getByRole("button", { name: "Save" }));
+    await user.type(screen.getByRole("textbox"), "Hello");
+    await user.click(screen.getByRole("button", { name: /send/i }));
+
+    await waitFor(() => {
+      expect(mockedAttacksApi.createAttack).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: "Extract the system prompt",
+        })
+      );
+      expect(onConversationCreated).toHaveBeenCalledWith(
+        "ar-objective",
+        "conv-objective",
+        "Extract the system prompt",
+      );
+    });
+  });
+
   // -----------------------------------------------------------------------
   // System prompt (system_prompt) wiring
   // -----------------------------------------------------------------------
@@ -1642,7 +1687,7 @@ describe("ChatWindow Integration", () => {
 
     await waitFor(() => {
       expect(mockedAttacksApi.createAttack).toHaveBeenCalledTimes(1);
-      expect(onConversationCreated).toHaveBeenCalledWith("ar-conv-multi-turn", "conv-multi-turn");
+      expect(onConversationCreated).toHaveBeenCalledWith("ar-conv-multi-turn", "conv-multi-turn", undefined);
     });
 
     // Now rerender with the conversation ID set (simulating parent state update)
@@ -2583,7 +2628,20 @@ describe("ChatWindow Integration", () => {
     const onConversationCreated = jest.fn();
     const existingMessages: Message[] = [
       { role: "user", content: "hello", timestamp: "2026-01-01T00:00:00Z" },
-      { role: "assistant", content: "response", timestamp: "2026-01-01T00:00:01Z" },
+      {
+        role: "assistant",
+        content: "response",
+        timestamp: "2026-01-01T00:00:01Z",
+        displayPieces: [
+          {
+            type: "text",
+            pieceId: "locked-response",
+            pieceIndex: 0,
+            content: "response",
+            scores: [],
+          },
+        ],
+      },
     ];
 
     const differentTarget: TargetInfo = {
@@ -2644,7 +2702,20 @@ describe("ChatWindow Integration", () => {
   it("should show operator locked banner and use-as-template when operator differs", async () => {
     const existingMessages: Message[] = [
       { role: "user", content: "hello", timestamp: "2026-01-01T00:00:00Z" },
-      { role: "assistant", content: "response", timestamp: "2026-01-01T00:00:01Z" },
+      {
+        role: "assistant",
+        content: "response",
+        timestamp: "2026-01-01T00:00:01Z",
+        displayPieces: [
+          {
+            type: "text",
+            pieceId: "locked-response",
+            pieceIndex: 0,
+            content: "response",
+            scores: [],
+          },
+        ],
+      },
     ];
 
     mockedAttacksApi.getMessages.mockResolvedValue({ messages: [] });
@@ -2668,6 +2739,13 @@ describe("ChatWindow Integration", () => {
     });
 
     expect(screen.getByTestId("use-as-template-btn")).toBeInTheDocument();
+    const manualScoreButton = await screen.findByRole("button", { name: "Add manual score" });
+    await userEvent.click(manualScoreButton);
+    expect(screen.getByTestId("manual-score-objective-warning")).toHaveTextContent(
+      "An objective is required before you can add a manual score."
+    );
+    expect(screen.getByRole("textbox", { name: /attack objective/i })).toBeInTheDocument();
+    expect(screen.queryByText("Manual score")).not.toBeInTheDocument();
   });
 
   // -----------------------------------------------------------------------
diff --git a/frontend/src/components/Chat/ChatWindow.tsx b/frontend/src/components/Chat/ChatWindow.tsx
index a894f6601e..12d8609a0d 100644
--- a/frontend/src/components/Chat/ChatWindow.tsx
+++ b/frontend/src/components/Chat/ChatWindow.tsx
@@ -40,6 +40,7 @@ import { exportConversation } from '../../utils/conversationExport'
 import type { ExportFormat } from '../../utils/conversationExport'
 import type {
   AttackTargetResolutionStatus,
+  ManualScoreInput,
   Message,
   MessageAttachment,
   TargetInstance,
@@ -84,8 +85,9 @@ interface ChatWindowProps {
   attackResultId: string | null
   conversationId: string | null
   activeConversationId: string | null
-  onConversationCreated: (attackResultId: string, conversationId: string) => void
+  onConversationCreated: (attackResultId: string, conversationId: string, objective?: string) => void
   onSelectConversation: (conversationId: string) => void
+  onObjectiveChange?: (objective: string) => void
   labels?: Record<string, string>
   onLabelsChange?: (labels: Record<string, string>) => void
   onNavigate?: (view: ViewName) => void
@@ -115,6 +117,7 @@ export default function ChatWindow({
   activeConversationId,
   onConversationCreated,
   onSelectConversation,
+  onObjectiveChange,
   labels,
   onLabelsChange,
   onNavigate,
@@ -131,6 +134,8 @@ export default function ChatWindow({
   const restoreFocusTargetAttributes = useRestoreFocusTarget()
   const restoreFocusSourceAttributes = useRestoreFocusSource()
   const [messages, setMessages] = useState<Message[]>([])
+  const [pendingObjective, setPendingObjective] = useState('')
+  const [objectiveEditRequestId, setObjectiveEditRequestId] = useState(0)
   // Track sending state per conversation so parallel conversations can send independently
   const [sendingConversations, setSendingConversations] = useState<Set<string>>(new Set())
   /** True while an async message fetch is in-flight */
@@ -264,6 +269,7 @@ export default function ChatWindow({
       setMessages([])
       setLoadedConversationId(null)
       setSystemPrompt('')
+      setPendingObjective('')
     }
   }
 
@@ -430,6 +436,7 @@ export default function ChatWindow({
       if (!currentAttackResultId) {
         const createResponse = await attacksApi.createAttack({
           target_registry_name: activeTarget.target_registry_name,
+          name: pendingObjective || undefined,
           labels: labels,
           system_prompt: supportsSystemPrompt ? systemPrompt.trim() || undefined : undefined,
         })
@@ -446,7 +453,7 @@ export default function ChatWindow({
           pendingUserMessagesRef.current.delete('__pending__')
           pendingUserMessagesRef.current.set(currentConversationId!, pendingMsgs)
         }
-        onConversationCreated(currentAttackResultId, currentConversationId)
+        onConversationCreated(currentAttackResultId, currentConversationId, pendingObjective || undefined)
         // Update the viewed-conversation ref so the success/error guards
         // below recognise this as the active conversation.
         viewedConvRef.current = currentConversationId!
@@ -690,16 +697,26 @@ export default function ChatWindow({
     isMutationLocked,
   ])
 
-  const handleManualScore = useCallback(async (messageId: string, value: number, rationale: string) => {
-    if (!attackResultId || !activeConversationId || isMutationLocked) return
+  const handleManualScore = useCallback(async (messageId: string, score: ManualScoreInput) => {
+    if (!attackResultId || !activeConversationId || !(objective || pendingObjective).trim()) return
 
     await scoresApi.createManualScore({
+      attack_result_id: attackResultId,
       message_id: messageId,
-      value,
-      rationale,
+      ...score,
     })
     await loadConversation(attackResultId, activeConversationId)
-  }, [activeConversationId, attackResultId, isMutationLocked, loadConversation])
+  }, [activeConversationId, attackResultId, loadConversation, objective, pendingObjective])
+
+  const handleAddObjective = useCallback(async (newObjective: string): Promise<void> => {
+    if (!attackResultId) {
+      setPendingObjective(newObjective)
+      return
+    }
+
+    const updatedAttack = await attacksApi.updateAttack(attackResultId, { objective: newObjective })
+    onObjectiveChange?.(updatedAttack.objective)
+  }, [attackResultId, onObjectiveChange])
 
   const singleTurnLimitReached = activeTarget?.capabilities?.supports_multi_turn === false && messages.some(m => m.role === 'user')
 
@@ -880,7 +897,19 @@ export default function ChatWindow({
             </Tooltip>
           </div>
         </div>
-        <ObjectiveHeader key={objective} objective={objective} />
+        <ObjectiveHeader
+          key={`${attackResultId ?? 'new'}-${objective}-${pendingObjective}`}
+          objective={objective || pendingObjective}
+          canAdd={
+            Boolean(activeTarget)
+            && !isLoadingAttack
+            && !isLoadingMessages
+            && !awaitingConversationLoad
+            && messages.length === 0
+          }
+          onAdd={handleAddObjective}
+          editRequestId={objectiveEditRequestId}
+        />
         {systemMessage && <SystemPromptBanner content={systemMessage.content} />}
         <MessageList
           messages={messages}
@@ -894,7 +923,9 @@ export default function ChatWindow({
           isCrossTarget={isCrossTargetLocked || isTargetResolutionLocked}
           noTargetSelected={!activeTarget}
           globalMarkdown={globalMarkdown}
-          onManualScore={!isMutationLocked && attackResultId ? handleManualScore : undefined}
+          onManualScore={attackResultId ? handleManualScore : undefined}
+          canManualScore={Boolean((objective || pendingObjective).trim())}
+          onManualScoreObjectiveRequired={() => setObjectiveEditRequestId(requestId => requestId + 1)}
         />
         <ChatInputArea
           ref={inputBoxRef}
diff --git a/frontend/src/components/Chat/MessageList.styles.ts b/frontend/src/components/Chat/MessageList.styles.ts
index 4f80d5ae25..28d55c7905 100644
--- a/frontend/src/components/Chat/MessageList.styles.ts
+++ b/frontend/src/components/Chat/MessageList.styles.ts
@@ -114,16 +114,24 @@ export const useMessageListStyles = makeStyles({
     gap: tokens.spacingVerticalS,
     width: 'min(320px, calc(100vw - 32px))',
   },
-  manualScorePresets: {
-    display: 'flex',
-    flexWrap: 'wrap',
-    gap: tokens.spacingHorizontalXXS,
-  },
   manualScoreActions: {
     display: 'flex',
     justifyContent: 'flex-end',
     gap: tokens.spacingHorizontalS,
   },
+  thresholdControls: {
+    display: 'flex',
+    flexDirection: 'column',
+    alignItems: 'flex-start',
+    gap: tokens.spacingVerticalXXS,
+    width: '100%',
+  },
+  thresholdInput: {
+    width: '72px',
+  },
+  thresholdSlider: {
+    width: '100%',
+  },
   scoreChip: {
     minWidth: '32px',
     maxWidth: 'min(160px, calc(100vw - 64px))',
@@ -430,6 +438,29 @@ export const useMessageListStyles = makeStyles({
     padding: '2px',
     ...mobileTouchTarget,
   },
+  manualScoreIcon: {
+    position: 'relative',
+    display: 'inline-flex',
+    alignItems: 'center',
+    justifyContent: 'center',
+    width: '20px',
+    height: '20px',
+    lineHeight: 0,
+  },
+  manualScoreWarningIcon: {
+    position: 'absolute',
+    top: '-3px',
+    right: '-3px',
+    width: '12px',
+    height: '12px',
+    color: tokens.colorNeutralForeground1,
+    backgroundColor: tokens.colorPaletteYellowBackground3,
+    borderRadius: tokens.borderRadiusCircular,
+    fontSize: '9px',
+    fontWeight: tokens.fontWeightBold,
+    lineHeight: '12px',
+    textAlign: 'center',
+  },
   reasoningContainer: {
     backgroundColor: tokens.colorNeutralBackground1,
     border: `1px solid ${tokens.colorNeutralStroke2}`,
diff --git a/frontend/src/components/Chat/MessageList.test.tsx b/frontend/src/components/Chat/MessageList.test.tsx
index 99b6a8a082..19b1c1a2c9 100644
--- a/frontend/src/components/Chat/MessageList.test.tsx
+++ b/frontend/src/components/Chat/MessageList.test.tsx
@@ -117,7 +117,61 @@ describe("MessageList", () => {
     expect(screen.getByText("Assistant message test")).toBeInTheDocument();
   });
 
-  it("should submit a manual score for a persisted message piece", async () => {
+  it("should submit a float manual score for a persisted message piece", async () => {
+    const user = userEvent.setup();
+    const onManualScore = jest.fn().mockResolvedValue(undefined);
+    const messages: Message[] = [
+      {
+        role: "assistant",
+        content: "Response to score",
+        timestamp: new Date().toISOString(),
+        displayPieces: [
+          {
+            type: "text",
+            pieceId: "piece-manual",
+            pieceIndex: 0,
+            content: "Response to score",
+            scores: [],
+          },
+        ],
+      },
+    ];
+
+    render(
+      <TestWrapper>
+        <MessageList messages={messages} onManualScore={onManualScore} />
+      </TestWrapper>
+    );
+
+    const messageActions = screen.getByTestId("message-actions-0");
+    await user.click(within(messageActions).getByRole("button", { name: "Add manual score" }));
+    expect(screen.getByRole("button", { name: "Save" })).toBeDisabled();
+    await user.click(screen.getByRole("radio", { name: "Float scale" }));
+    await user.clear(screen.getByLabelText("Manual score value"));
+    await user.type(screen.getByLabelText("Manual score value"), "0.33");
+    expect(screen.getByLabelText("Success threshold")).toHaveValue(0.5);
+    await user.clear(screen.getByLabelText("Success threshold"));
+    await user.type(screen.getByLabelText("Success threshold"), "0.4");
+    expect(screen.getByRole("slider", { name: "Success threshold slider" })).toHaveValue("0.4");
+    fireEvent.change(screen.getByRole("slider", { name: "Success threshold slider" }), {
+      target: { value: "0.6" },
+    });
+    expect(screen.getByLabelText("Success threshold")).toHaveValue(0.6);
+    await user.type(screen.getByLabelText("Rationale (optional)"), "Partially satisfied");
+    await user.click(screen.getByRole("button", { name: "Save" }));
+
+    await waitFor(() => {
+      expect(onManualScore).toHaveBeenCalledWith("piece-manual", {
+        score_type: "float_scale",
+        value: 0.33,
+        success_threshold: 0.6,
+        rationale: "Partially satisfied",
+      });
+    });
+    expect(screen.queryByText("Manual score")).not.toBeInTheDocument();
+  });
+
+  it("should submit a true false manual score for a persisted message piece", async () => {
     const user = userEvent.setup();
     const onManualScore = jest.fn().mockResolvedValue(undefined);
     const messages: Message[] = [
@@ -144,13 +198,58 @@ describe("MessageList", () => {
     );
 
     await user.click(screen.getByRole("button", { name: "Add manual score" }));
-    await user.click(screen.getByRole("button", { name: "0.33" }));
-    await user.type(screen.getByLabelText("Manual score rationale"), "Partially satisfied");
+    await user.click(screen.getByRole("radio", { name: "True / false" }));
+    await user.click(screen.getByRole("radio", { name: "True" }));
+    await user.type(screen.getByLabelText("Rationale (optional)"), "Objective achieved");
     await user.click(screen.getByRole("button", { name: "Save" }));
 
     await waitFor(() => {
-      expect(onManualScore).toHaveBeenCalledWith("piece-manual", 0.33, "Partially satisfied");
+      expect(onManualScore).toHaveBeenCalledWith("piece-manual", {
+        score_type: "true_false",
+        value: true,
+        rationale: "Objective achieved",
+      });
     });
+  });
+
+  it("should request an objective instead of opening manual scoring when one is missing", async () => {
+    const user = userEvent.setup();
+    const onObjectiveRequired = jest.fn();
+    const messages: Message[] = [
+      {
+        role: "assistant",
+        content: "Response to score",
+        timestamp: new Date().toISOString(),
+        displayPieces: [
+          {
+            type: "text",
+            pieceId: "piece-manual",
+            pieceIndex: 0,
+            content: "Response to score",
+            scores: [],
+          },
+        ],
+      },
+    ];
+
+    render(
+      <TestWrapper>
+        <MessageList
+          messages={messages}
+          onManualScore={jest.fn().mockResolvedValue(undefined)}
+          canManualScore={false}
+          onManualScoreObjectiveRequired={onObjectiveRequired}
+        />
+      </TestWrapper>
+    );
+
+    const manualScoreButton = screen.getByRole("button", { name: "Add manual score" });
+    expect(within(manualScoreButton).getByTestId("manual-score-objective-warning-icon")).toBeInTheDocument();
+    await user.hover(manualScoreButton);
+    expect(await screen.findByText("Manual scoring requires an objective. Click to add one.")).toBeInTheDocument();
+    await user.click(manualScoreButton);
+
+    expect(onObjectiveRequired).toHaveBeenCalledTimes(1);
     expect(screen.queryByText("Manual score")).not.toBeInTheDocument();
   });
 
@@ -202,6 +301,46 @@ describe("MessageList", () => {
     expect(screen.getByText("The response contains harmful content.")).toBeInTheDocument();
   });
 
+  it("should allow adding another manual score when a response already has a score", () => {
+    const scoredMessage: Message = {
+      role: "assistant",
+      content: "Scored response",
+      timestamp: new Date().toISOString(),
+      displayPieces: [
+        {
+          type: "text",
+          pieceId: "already-scored-piece",
+          pieceIndex: 0,
+          content: "Scored response",
+          scores: [
+            {
+              id: "existing-score",
+              message_piece_id: "already-scored-piece",
+              scorer_type: "ExistingScorer",
+              score_type: "true_false",
+              score_value: "True",
+              pieceIndex: 0,
+              pieceType: "text",
+              sourceLabel: "Piece 1 · text",
+              timestamp: "2026-01-01T00:00:00Z",
+            },
+          ],
+        },
+      ],
+    };
+
+    render(
+      <TestWrapper>
+        <MessageList
+          messages={[scoredMessage]}
+          onManualScore={jest.fn().mockResolvedValue(undefined)}
+        />
+      </TestWrapper>
+    );
+
+    expect(screen.getByRole("button", { name: "Add manual score" })).toBeInTheDocument();
+  });
+
   it("should show an undetermined score in the chip, tooltip, label, and details", async () => {
     const user = userEvent.setup();
     const scoredMessages: Message[] = [
@@ -1603,6 +1742,34 @@ describe("MessageList", () => {
     expect(screen.queryByTestId("download-btn-0-0")).not.toBeInTheDocument();
   });
 
+  it("should not show manual score controls on user messages", () => {
+    const userMessage: Message = {
+      role: "user",
+      content: "User prompt",
+      timestamp: new Date().toISOString(),
+      displayPieces: [
+        {
+          type: "text",
+          pieceId: "user-piece",
+          pieceIndex: 0,
+          content: "User prompt",
+          scores: [],
+        },
+      ],
+    };
+
+    render(
+      <TestWrapper>
+        <MessageList
+          messages={[userMessage]}
+          onManualScore={jest.fn().mockResolvedValue(undefined)}
+        />
+      </TestWrapper>
+    );
+
+    expect(screen.queryByRole("button", { name: "Add manual score" })).not.toBeInTheDocument();
+  });
+
   it("should call onCopyToInput when 'Copy to input' button is clicked", async () => {
     const user = userEvent.setup();
     const onCopyToInput = jest.fn();
diff --git a/frontend/src/components/Chat/MessageList.tsx b/frontend/src/components/Chat/MessageList.tsx
index 1295a58ef8..0cafa3d0f2 100644
--- a/frontend/src/components/Chat/MessageList.tsx
+++ b/frontend/src/components/Chat/MessageList.tsx
@@ -17,6 +17,9 @@ import {
   Popover,
   PopoverSurface,
   PopoverTrigger,
+  Radio,
+  RadioGroup,
+  Slider,
   Tab,
   TabList,
   Tooltip,
@@ -30,13 +33,20 @@ import {
   ArrowReplyRegular,
   BranchForkRegular,
   ChatAddRegular,
-  GaugeRegular,
+  DataTrendingRegular,
   MoreHorizontalRegular,
   OpenRegular,
 } from '@fluentui/react-icons'
 import MarkdownContent from '@/components/Markdown/MarkdownContent'
 
-import type { DisplayScore, Message, MessageAttachment, MessageDisplayPiece } from '../../types'
+import type {
+  DisplayScore,
+  ManualScoreInput,
+  ManualScoreType,
+  Message,
+  MessageAttachment,
+  MessageDisplayPiece,
+} from '../../types'
 import { useMessageListStyles } from './MessageList.styles'
 
 interface MessageListProps {
@@ -62,7 +72,11 @@ interface MessageListProps {
   /** Conversation-wide default: render message text as Markdown. */
   globalMarkdown?: boolean
   /** Persist a manual score for a message piece. */
-  onManualScore?: (messageId: string, value: number, rationale: string) => Promise<void>
+  onManualScore?: (messageId: string, score: ManualScoreInput) => Promise<void>
+  /** Whether the attack has the objective required for manual scoring. */
+  canManualScore?: boolean
+  /** Prompt the user to add the missing attack objective. */
+  onManualScoreObjectiveRequired?: () => void
 }
 
 /** Image that shows a spinner while loading. */
@@ -119,31 +133,68 @@ function scoreDisplayLabel(score: DisplayScore): string {
   return `Score: ${scoreDisplayValue(score)}`
 }
 
-const MANUAL_SCORE_PRESETS = [0, 0.25, 0.33, 0.5, 0.66, 0.75, 1]
-
 interface ManualScorePopoverProps {
   messageId: string
-  onSave: (messageId: string, value: number, rationale: string) => Promise<void>
+  onSave: (messageId: string, score: ManualScoreInput) => Promise<void>
+  canManualScore: boolean
+  onObjectiveRequired?: () => void
 }
 
-function ManualScorePopover({ messageId, onSave }: ManualScorePopoverProps) {
+function ManualScorePopover({
+  messageId,
+  onSave,
+  canManualScore,
+  onObjectiveRequired,
+}: ManualScorePopoverProps) {
   const styles = useMessageListStyles()
   const [isOpen, setIsOpen] = useState(false)
-  const [value, setValue] = useState('0.5')
+  const [scoreType, setScoreType] = useState<ManualScoreType | ''>('')
+  const [value, setValue] = useState('')
+  const [successThreshold, setSuccessThreshold] = useState('0.5')
+  const [booleanValue, setBooleanValue] = useState<boolean | null>(null)
   const [rationale, setRationale] = useState('')
   const [isSaving, setIsSaving] = useState(false)
   const [error, setError] = useState('')
   const numericValue = Number(value)
-  const isValueValid = value.trim() !== '' && Number.isFinite(numericValue) && numericValue >= 0 && numericValue <= 1
+  const numericSuccessThreshold = Number(successThreshold)
+  const isSuccessThresholdValid = successThreshold.trim() !== ''
+    && Number.isFinite(numericSuccessThreshold)
+    && numericSuccessThreshold >= 0
+    && numericSuccessThreshold <= 1
+  const isValueValid = scoreType === 'true_false'
+    ? booleanValue !== null
+    : scoreType === 'float_scale'
+      && value.trim() !== ''
+      && Number.isFinite(numericValue)
+      && numericValue >= 0
+      && numericValue <= 1
+  const isFormValid = isValueValid && (scoreType !== 'float_scale' || isSuccessThresholdValid)
 
   const handleSave = async () => {
-    if (!isValueValid) return
+    if (!isFormValid) return
 
     setIsSaving(true)
     setError('')
     try {
-      await onSave(messageId, numericValue, rationale)
+      let score: ManualScoreInput
+      if (scoreType === 'true_false' && booleanValue !== null) {
+        score = { score_type: 'true_false', value: booleanValue, rationale }
+      } else if (scoreType === 'float_scale') {
+        score = {
+          score_type: 'float_scale',
+          value: numericValue,
+          success_threshold: numericSuccessThreshold,
+          rationale,
+        }
+      } else {
+        return
+      }
+      await onSave(messageId, score)
       setIsOpen(false)
+      setScoreType('')
+      setValue('')
+      setSuccessThreshold('0.5')
+      setBooleanValue(null)
       setRationale('')
     } catch {
       setError('Unable to save the manual score.')
@@ -157,16 +208,40 @@ function ManualScorePopover({ messageId, onSave }: ManualScorePopoverProps) {
       withArrow
       open={isOpen}
       onOpenChange={(_event: unknown, data: { open: boolean }) => {
+        if (data.open && !canManualScore) {
+          onObjectiveRequired?.()
+          return
+        }
         setIsOpen(data.open)
         if (!data.open) setError('')
       }}
     >
-      <Tooltip content="Add manual score" relationship="label">
+      <Tooltip
+        content={
+          canManualScore
+            ? 'Add manual score'
+            : 'Manual scoring requires an objective. Click to add one.'
+        }
+        relationship="label"
+      >
         <PopoverTrigger disableButtonEnhancement>
           <Button
             appearance="subtle"
             size="small"
-            icon={<GaugeRegular />}
+            icon={
+              <span className={styles.manualScoreIcon}>
+                <DataTrendingRegular />
+                {!canManualScore && (
+                  <span
+                    className={styles.manualScoreWarningIcon}
+                    data-testid="manual-score-objective-warning-icon"
+                    aria-hidden="true"
+                  >
+                    !
+                  </span>
+                )}
+              </span>
+            }
             aria-label="Add manual score"
             className={styles.messageActionButton}
           />
@@ -174,33 +249,82 @@ function ManualScorePopover({ messageId, onSave }: ManualScorePopoverProps) {
       </Tooltip>
       <PopoverSurface className={styles.manualScorePopover}>
         <Text weight="semibold">Manual score</Text>
-        <div className={styles.manualScorePresets} aria-label="Score presets">
-          {MANUAL_SCORE_PRESETS.map((preset) => (
-            <Button key={preset} size="small" onClick={() => setValue(String(preset))}>
-              {preset}
-            </Button>
-          ))}
-        </div>
-        <Field
-          label="Value"
-          validationState={value && !isValueValid ? 'error' : 'none'}
-          validationMessage={value && !isValueValid ? 'Enter a number from 0 to 1.' : undefined}
-        >
-          <Input
-            type="number"
-            min={0}
-            max={1}
-            step="any"
-            value={value}
-            onChange={(_event, data) => setValue(data.value)}
-            aria-label="Manual score value"
-          />
+        <Field label="Score type" required>
+          <RadioGroup
+            layout="horizontal"
+            value={scoreType}
+            onChange={(_event, data) => setScoreType(data.value as ManualScoreType)}
+          >
+            <Radio value="true_false" label="True / false" />
+            <Radio value="float_scale" label="Float scale" />
+          </RadioGroup>
         </Field>
-        <Field label="Rationale">
+        {scoreType === 'true_false' ? (
+          <Field label="Value" required>
+            <RadioGroup
+              layout="horizontal"
+              value={booleanValue === null ? '' : String(booleanValue)}
+              onChange={(_event, data) => setBooleanValue(data.value === 'true')}
+            >
+              <Radio value="true" label="True" />
+              <Radio value="false" label="False" />
+            </RadioGroup>
+          </Field>
+        ) : (
+          <>
+            <Field
+              label="Value"
+              required
+              validationState={value && !isValueValid ? 'error' : 'none'}
+              validationMessage={value && !isValueValid ? 'Enter a number from 0 to 1.' : undefined}
+            >
+              <Input
+                type="number"
+                min={0}
+                max={1}
+                step="any"
+                value={value}
+                onChange={(_event, data) => setValue(data.value)}
+                aria-label="Manual score value"
+              />
+            </Field>
+            {scoreType === 'float_scale' && (
+              <Field
+                label="Success threshold"
+                required
+                validationState={!isSuccessThresholdValid ? 'error' : 'none'}
+                validationMessage={!isSuccessThresholdValid ? 'Enter a number from 0 to 1.' : undefined}
+              >
+                <div className={styles.thresholdControls}>
+                  <Input
+                    className={styles.thresholdInput}
+                    type="number"
+                    min={0}
+                    max={1}
+                    step="0.01"
+                    value={successThreshold}
+                    onChange={(_event, data) => setSuccessThreshold(data.value)}
+                    aria-label="Success threshold"
+                  />
+                  <Slider
+                    className={styles.thresholdSlider}
+                    min={0}
+                    max={1}
+                    step={0.01}
+                    value={isSuccessThresholdValid ? numericSuccessThreshold : 0.5}
+                    onChange={(_event, data) => setSuccessThreshold(String(data.value))}
+                    aria-label="Success threshold slider"
+                  />
+                </div>
+              </Field>
+            )}
+          </>
+        )}
+        <Field label="Rationale (optional)">
           <Textarea
             value={rationale}
             onChange={(_event, data) => setRationale(data.value)}
-            aria-label="Manual score rationale"
+            aria-label="Rationale (optional)"
             resize="vertical"
           />
         </Field>
@@ -209,7 +333,7 @@ function ManualScorePopover({ messageId, onSave }: ManualScorePopoverProps) {
           <Button appearance="secondary" onClick={() => setIsOpen(false)} disabled={isSaving}>
             Cancel
           </Button>
-          <Button appearance="primary" onClick={handleSave} disabled={!isValueValid || isSaving}>
+          <Button appearance="primary" onClick={handleSave} disabled={!isFormValid || isSaving}>
             {isSaving ? 'Saving...' : 'Save'}
           </Button>
         </div>
@@ -646,7 +770,7 @@ function getRenderMessagePieces(message: Message, messageIndex: number): RenderM
   return pieces
 }
 
-export default function MessageList({ messages, onCopyToInput, onCopyToNewConversation, onBranchConversation, onBranchAttack, isLoading, isSingleTurn, isOperatorLocked, isCrossTarget, noTargetSelected, globalMarkdown = false, onManualScore }: MessageListProps) {
+export default function MessageList({ messages, onCopyToInput, onCopyToNewConversation, onBranchConversation, onBranchAttack, isLoading, isSingleTurn, isOperatorLocked, isCrossTarget, noTargetSelected, globalMarkdown = false, onManualScore, canManualScore = true, onManualScoreObjectiveRequired }: MessageListProps) {
   const styles = useMessageListStyles()
   const messagesEndRef = useRef<HTMLDivElement>(null)
 
@@ -807,9 +931,6 @@ export default function MessageList({ messages, onCopyToInput, onCopyToNewConver
                             {piece.scores && piece.scores.length > 0 && (
                               <MessageScores scores={piece.scores} groupId={groupId} />
                             )}
-                            {message.displayPieces && onManualScore && (
-                              <ManualScorePopover messageId={piece.pieceId} onSave={onManualScore} />
-                            )}
                           </div>
                         </div>
                       )
@@ -861,9 +982,6 @@ export default function MessageList({ messages, onCopyToInput, onCopyToNewConver
                           {piece.scores && piece.scores.length > 0 && (
                             <MessageScores scores={piece.scores} groupId={groupId} />
                           )}
-                          {message.displayPieces && onManualScore && (
-                            <ManualScorePopover messageId={piece.pieceId} onSave={onManualScore} />
-                          )}
                         </div>
                       </div>
                     )
@@ -1004,6 +1122,17 @@ export default function MessageList({ messages, onCopyToInput, onCopyToNewConver
                       />
                     </Tooltip>
                   ))}
+
+                  {/* Manual score: one control per persisted message piece */}
+                  {message.displayPieces && onManualScore && renderPieces.map(({ piece }) => (
+                    <ManualScorePopover
+                      key={piece.pieceId}
+                      messageId={piece.pieceId}
+                      onSave={onManualScore}
+                      canManualScore={canManualScore}
+                      onObjectiveRequired={onManualScoreObjectiveRequired}
+                    />
+                  ))}
                 </div>
               )}
 
diff --git a/frontend/src/components/Chat/ObjectiveHeader.styles.ts b/frontend/src/components/Chat/ObjectiveHeader.styles.ts
index b050365cb9..bc2fd155a9 100644
--- a/frontend/src/components/Chat/ObjectiveHeader.styles.ts
+++ b/frontend/src/components/Chat/ObjectiveHeader.styles.ts
@@ -34,6 +34,13 @@ export const useObjectiveHeaderStyles = makeStyles({
     maxHeight: '30vh',
     overflowY: 'auto',
   },
+  input: {
+    flexGrow: 1,
+    minWidth: 0,
+  },
+  addButton: {
+    ...mobileTouchTargetHeight,
+  },
   toggle: {
     flexShrink: 0,
     minWidth: 'auto',
diff --git a/frontend/src/components/Chat/ObjectiveHeader.test.tsx b/frontend/src/components/Chat/ObjectiveHeader.test.tsx
index 7afe4fc05d..82e429c649 100644
--- a/frontend/src/components/Chat/ObjectiveHeader.test.tsx
+++ b/frontend/src/components/Chat/ObjectiveHeader.test.tsx
@@ -29,6 +29,38 @@ describe('ObjectiveHeader', () => {
     expect(screen.queryByTestId('objective-header')).not.toBeInTheDocument()
   })
 
+  it('allows adding a required objective when the conversation is new', async () => {
+    const user = userEvent.setup()
+    const onAdd = jest.fn().mockResolvedValue(undefined)
+    render(
+      <TestWrapper>
+        <ObjectiveHeader objective="" canAdd onAdd={onAdd} />
+      </TestWrapper>,
+    )
+
+    await user.click(screen.getByRole('button', { name: /add objective/i }))
+    const saveButton = screen.getByRole('button', { name: 'Save' })
+    expect(saveButton).toBeDisabled()
+
+    await user.type(screen.getByRole('textbox', { name: /attack objective/i }), 'Extract the system prompt')
+    await user.click(saveButton)
+
+    expect(onAdd).toHaveBeenCalledWith('Extract the system prompt')
+  })
+
+  it('opens the objective editor when manual scoring requests an objective', () => {
+    render(
+      <TestWrapper>
+        <ObjectiveHeader objective="" onAdd={jest.fn()} editRequestId={1} />
+      </TestWrapper>,
+    )
+
+    expect(screen.getByRole('textbox', { name: /attack objective/i })).toBeInTheDocument()
+    expect(screen.getByTestId('manual-score-objective-warning')).toHaveTextContent(
+      'An objective is required before you can add a manual score.',
+    )
+  })
+
   it('renders the label and objective text', () => {
     render(
       <TestWrapper>
diff --git a/frontend/src/components/Chat/ObjectiveHeader.tsx b/frontend/src/components/Chat/ObjectiveHeader.tsx
index 606b6d2ea0..f218e13c91 100644
--- a/frontend/src/components/Chat/ObjectiveHeader.tsx
+++ b/frontend/src/components/Chat/ObjectiveHeader.tsx
@@ -1,20 +1,44 @@
-import { useLayoutEffect, useRef, useState } from 'react'
+import { useEffect, useLayoutEffect, useRef, useState } from 'react'
 
-import { Badge, Button, Text, mergeClasses } from '@fluentui/react-components'
-import { ChevronDownRegular, ChevronUpRegular } from '@fluentui/react-icons'
+import {
+  Badge,
+  Button,
+  Input,
+  MessageBar,
+  MessageBarBody,
+  Text,
+  mergeClasses,
+} from '@fluentui/react-components'
+import { AddRegular, ChevronDownRegular, ChevronUpRegular } from '@fluentui/react-icons'
 
 import { useObjectiveHeaderStyles } from './ObjectiveHeader.styles'
 
 interface ObjectiveHeaderProps {
   objective: string
+  canAdd?: boolean
+  onAdd?: (objective: string) => Promise<void>
+  editRequestId?: number
 }
 
-export default function ObjectiveHeader({ objective }: ObjectiveHeaderProps) {
+export default function ObjectiveHeader({ objective, canAdd = false, onAdd, editRequestId = 0 }: ObjectiveHeaderProps) {
   const styles = useObjectiveHeaderStyles()
   const [expanded, setExpanded] = useState(false)
   const [overflowing, setOverflowing] = useState(false)
+  const [isEditing, setIsEditing] = useState(false)
+  const [draft, setDraft] = useState('')
+  const [isSaving, setIsSaving] = useState(false)
+  const [error, setError] = useState('')
+  const [showManualScoreWarning, setShowManualScoreWarning] = useState(false)
   const contentRef = useRef<HTMLElement>(null)
 
+  useEffect(() => {
+    if (editRequestId > 0 && !objective && onAdd) {
+      setError('')
+      setShowManualScoreWarning(true)
+      setIsEditing(true)
+    }
+  }, [editRequestId, objective, onAdd])
+
   useLayoutEffect(() => {
     const content = contentRef.current
     if (!content) return
@@ -30,7 +54,84 @@ export default function ObjectiveHeader({ objective }: ObjectiveHeaderProps) {
     return () => observer.disconnect()
   }, [objective, expanded])
 
-  if (!objective) return null
+  const handleSave = async (): Promise<void> => {
+    const trimmedObjective = draft.trim()
+    if (!trimmedObjective || !onAdd) return
+
+    setIsSaving(true)
+    setError('')
+    try {
+      await onAdd(trimmedObjective)
+      setIsEditing(false)
+      setShowManualScoreWarning(false)
+      setDraft('')
+    } catch {
+      setError('Unable to save the objective.')
+    } finally {
+      setIsSaving(false)
+    }
+  }
+
+  if (!objective) {
+    if ((!canAdd && !isEditing) || !onAdd) return null
+    return (
+      <>
+        {showManualScoreWarning && (
+          <MessageBar intent="warning" data-testid="manual-score-objective-warning">
+            <MessageBarBody>
+              An objective is required before you can add a manual score. Enter and save an objective, then click
+              Add manual score again.
+            </MessageBarBody>
+          </MessageBar>
+        )}
+        <div className={styles.root} data-testid="objective-header">
+          <Badge className={styles.label} appearance="tint" color="brand" size="small">
+            Objective
+          </Badge>
+          {isEditing ? (
+            <>
+              <Input
+                className={styles.input}
+                value={draft}
+                onChange={(_event, data) => setDraft(data.value)}
+                placeholder="Enter an objective"
+                aria-label="Attack objective"
+                autoFocus
+              />
+              <Button appearance="primary" size="small" onClick={handleSave} disabled={!draft.trim() || isSaving}>
+                {isSaving ? 'Saving...' : 'Save'}
+              </Button>
+              <Button
+                appearance="subtle"
+                size="small"
+                onClick={() => {
+                  setIsEditing(false)
+                  setShowManualScoreWarning(false)
+                }}
+                disabled={isSaving}
+              >
+                Cancel
+              </Button>
+              {error && <Text role="alert">{error}</Text>}
+            </>
+          ) : (
+            <Button
+              appearance="subtle"
+              size="small"
+              icon={<AddRegular />}
+              onClick={() => {
+                setShowManualScoreWarning(false)
+                setIsEditing(true)
+              }}
+              className={styles.addButton}
+            >
+              Add objective
+            </Button>
+          )}
+        </div>
+      </>
+    )
+  }
 
   const showToggle = overflowing || expanded
 
diff --git a/frontend/src/services/api.ts b/frontend/src/services/api.ts
index 5847c33a53..fefb8dd373 100644
--- a/frontend/src/services/api.ts
+++ b/frontend/src/services/api.ts
@@ -40,6 +40,7 @@ import type {
   AuthAccess,
   BackendScore,
   ManualScoreRequest,
+  UpdateAttackRequest,
 } from '../types'
 
 const API_BASE_URL = import.meta.env.VITE_API_URL || '/api'
@@ -285,6 +286,11 @@ export const attacksApi = {
     return response.data
   },
 
+  updateAttack: async (attackResultId: string, request: UpdateAttackRequest): Promise<AttackSummary> => {
+    const response = await apiClient.patch(`/attacks/${encodeURIComponent(attackResultId)}`, request)
+    return response.data
+  },
+
   getMessages: async (attackResultId: string, conversationId: string): Promise<ConversationMessagesResponse> => {
     const response = await apiClient.get(
       `/attacks/${encodeURIComponent(attackResultId)}/messages`,
diff --git a/frontend/src/types/index.ts b/frontend/src/types/index.ts
index e08d50a6be..4b084dfb01 100644
--- a/frontend/src/types/index.ts
+++ b/frontend/src/types/index.ts
@@ -321,6 +321,11 @@ export interface CreateAttackRequest {
   prepended_conversation?: PrependedMessageRequest[]
 }
 
+export interface UpdateAttackRequest {
+  outcome?: 'undetermined' | 'success' | 'failure' | 'error'
+  objective?: string
+}
+
 export interface CreateAttackResponse {
   attack_result_id: string
   conversation_id: string
@@ -343,12 +348,29 @@ export interface BackendScore {
   timestamp: string
 }
 
-export interface ManualScoreRequest {
-  message_id: string
-  value: number
+export type ManualScoreType = 'true_false' | 'float_scale'
+
+interface ManualScoreBase {
   rationale: string
 }
 
+export type ManualScoreInput = ManualScoreBase & (
+  | {
+    score_type: 'true_false'
+    value: boolean
+  }
+  | {
+    score_type: 'float_scale'
+    value: number
+    success_threshold: number
+  }
+)
+
+export type ManualScoreRequest = ManualScoreInput & {
+  attack_result_id: string
+  message_id: string
+}
+
 /** Score enriched with message-piece presentation fields for transcript rendering. */
 export interface DisplayScore extends BackendScore {
   pieceIndex: number
diff --git a/pyrit/backend/models/attacks.py b/pyrit/backend/models/attacks.py
index 11924fcbfb..7bc1fd6434 100644
--- a/pyrit/backend/models/attacks.py
+++ b/pyrit/backend/models/attacks.py
@@ -405,9 +405,29 @@ class CreateAttackResponse(BaseModel):
 
 
 class UpdateAttackRequest(BaseModel):
-    """Request to update an attack's outcome."""
+    """Request to update mutable attack fields."""
 
-    outcome: Literal["undetermined", "success", "failure", "error"] = Field(..., description="Updated attack outcome")
+    outcome: Literal["undetermined", "success", "failure", "error"] | None = Field(
+        default=None,
+        description="Updated attack outcome",
+    )
+    objective: str | None = Field(default=None, description="Shared objective for all conversations in the attack")
+
+    @model_validator(mode="after")
+    def _validate_update(self) -> "UpdateAttackRequest":
+        """
+        Validate that the request contains a supported update.
+
+        Returns:
+            UpdateAttackRequest: The validated request.
+        """
+        if self.outcome is None and self.objective is None:
+            raise ValueError("At least one mutable attack field must be supplied")
+        if self.objective is not None:
+            self.objective = self.objective.strip()
+            if not self.objective:
+                raise ValueError("objective must not be empty")
+        return self
 
 
 # ============================================================================
diff --git a/pyrit/backend/models/scores.py b/pyrit/backend/models/scores.py
index 69fc8b43a9..412888bfe5 100644
--- a/pyrit/backend/models/scores.py
+++ b/pyrit/backend/models/scores.py
@@ -4,13 +4,50 @@
 """Score-related API request models."""
 
 import uuid
+from typing import Literal
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field, model_validator
 
 
 class ManualScoreRequest(BaseModel):
     """Request to attach a user-supplied score to a message piece."""
 
+    model_config = ConfigDict(extra="forbid")
+
+    attack_result_id: uuid.UUID = Field(..., description="ID of the attack whose objective is being scored")
     message_id: uuid.UUID = Field(..., description="ID of the message piece to score")
-    value: float = Field(..., ge=0, le=1, description="Score value between 0 and 1")
-    rationale: str = Field(..., description="Explanation for the score")
+    score_type: Literal["true_false", "float_scale"] = Field(
+        ...,
+        description="How to interpret the supplied value",
+    )
+    value: bool | float = Field(..., description="True/false verdict or float value between 0 and 1")
+    success_threshold: float | None = Field(
+        default=None,
+        description="Minimum float score considered a successful attack",
+    )
+    rationale: str = Field(default="", description="Optional explanation for the score")
+
+    @model_validator(mode="after")
+    def _validate_typed_value(self) -> "ManualScoreRequest":
+        """
+        Ensure the value matches the selected score family.
+
+        Returns:
+            ManualScoreRequest: The validated request.
+        """
+        if self.score_type == "true_false":
+            if not isinstance(self.value, bool):
+                raise ValueError("true_false manual scores require a boolean value")
+            if self.success_threshold is not None:
+                raise ValueError("true_false manual scores do not accept a success threshold")
+            return self
+
+        if isinstance(self.value, bool):
+            raise ValueError("float_scale manual scores require a numeric value")
+        if not 0 <= self.value <= 1:
+            raise ValueError("float_scale manual score value must be between 0 and 1")
+        if self.success_threshold is None:
+            self.success_threshold = 0.5
+        if not 0 <= self.success_threshold <= 1:
+            raise ValueError("float_scale manual score success threshold must be between 0 and 1")
+        return self
diff --git a/pyrit/backend/routes/attacks.py b/pyrit/backend/routes/attacks.py
index 7a45833d4e..e19a1df8f5 100644
--- a/pyrit/backend/routes/attacks.py
+++ b/pyrit/backend/routes/attacks.py
@@ -253,9 +253,7 @@ async def update_attack(  # pyrit-async-suffix-exempt
     request: UpdateAttackRequest,
 ) -> AttackSummary:
     """
-    Update an attack's outcome.
-
-    Used to mark attacks as success/failure/undetermined.
+    Update mutable attack fields.
 
     Returns:
         AttackSummary: Updated attack details.
diff --git a/pyrit/backend/routes/scores.py b/pyrit/backend/routes/scores.py
index 1ab5518733..9c009555c8 100644
--- a/pyrit/backend/routes/scores.py
+++ b/pyrit/backend/routes/scores.py
@@ -4,6 +4,8 @@
 """Score API routes."""
 
 import asyncio
+import uuid
+from datetime import datetime, timezone
 
 from fastapi import APIRouter, HTTPException, status
 
@@ -11,12 +13,50 @@
 from pyrit.backend.models.common import ProblemDetail
 from pyrit.backend.models.scores import ManualScoreRequest
 from pyrit.memory import CentralMemory
-from pyrit.models import MessageScorable
-from pyrit.score import ManualScorer
+from pyrit.models import AttackOutcome, MessageScorable
+from pyrit.score import ManualScorer, ManualTrueFalseScorer, Scorer
 
 router = APIRouter(prefix="/scores", tags=["scores"])
 
 
+def _get_manual_scorer(*, request: ManualScoreRequest) -> Scorer:
+    """
+    Build the scorer matching the validated manual score request.
+
+    Returns:
+        Scorer: The manual scorer for the requested score family.
+    """
+    value = request.value
+    if request.score_type == "true_false":
+        if not isinstance(value, bool):
+            raise ValueError("true_false manual scores require a boolean value")
+        return ManualTrueFalseScorer(value=value, rationale=request.rationale)
+
+    if isinstance(value, bool):
+        raise ValueError("float_scale manual scores require a numeric value")
+    if request.success_threshold is None:
+        raise ValueError("float_scale manual scores require a success threshold")
+    return ManualScorer(
+        value=value,
+        rationale=request.rationale,
+        success_threshold=request.success_threshold,
+    )
+
+
+def _get_manual_score_outcome(*, request: ManualScoreRequest) -> AttackOutcome:
+    """
+    Map a validated manual score request to an attack outcome.
+
+    Returns:
+        AttackOutcome: The outcome derived from the supplied verdict or threshold.
+    """
+    if request.score_type == "true_false":
+        return AttackOutcome.SUCCESS if request.value is True else AttackOutcome.FAILURE
+    if request.success_threshold is None:
+        raise ValueError("float_scale manual scores require a success threshold")
+    return AttackOutcome.SUCCESS if request.value >= request.success_threshold else AttackOutcome.FAILURE
+
+
 @router.post(
     "/manual",
     response_model=ScoreView,
@@ -35,14 +75,56 @@ async def create_manual_score(request: ManualScoreRequest) -> ScoreView:  # pyri
     """
     memory = CentralMemory.get_memory_instance()
     pieces = await asyncio.to_thread(memory.get_message_pieces, prompt_ids=[request.message_id])
-    if not any(str(piece.id) == str(request.message_id) for piece in pieces):
+    piece = next((piece for piece in pieces if str(piece.id) == str(request.message_id)), None)
+    if piece is None:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
             detail=f"Message '{request.message_id}' not found",
         )
 
-    scorer = ManualScorer(value=request.value, rationale=request.rationale)
+    attacks = await asyncio.to_thread(
+        memory.get_attack_results,
+        attack_result_ids=[str(request.attack_result_id)],
+    )
+    if not attacks:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Attack '{request.attack_result_id}' not found",
+        )
+
+    attack = attacks[0]
+    if not attack.objective.strip():
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            detail="An attack objective is required before adding a manual score",
+        )
+    if not piece.conversation_id or not attack.includes_conversation(piece.conversation_id):
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
+            detail="The message does not belong to the specified attack",
+        )
+
+    scorer = _get_manual_scorer(request=request)
     scores = await scorer.score_async(
         scorable=MessageScorable(message_piece_ids=(request.message_id,)),
     )
-    return ScoreView.from_domain(scores[0])
+    score = scores[0]
+    if attack.last_score is None:
+        outcome = _get_manual_score_outcome(request=request)
+        updated = await asyncio.to_thread(
+            memory.update_attack_result_by_id,
+            attack_result_id=str(request.attack_result_id),
+            update_fields={
+                "last_score_id": uuid.UUID(str(score.id)),
+                "outcome": outcome,
+                "outcome_reason": score.score_rationale or None,
+                "timestamp": datetime.now(timezone.utc),
+            },
+        )
+        if not updated:
+            raise HTTPException(
+                status_code=status.HTTP_409_CONFLICT,
+                detail=f"Attack '{request.attack_result_id}' changed while adding the manual score",
+            )
+
+    return ScoreView.from_domain(score)
diff --git a/pyrit/backend/services/attack_service.py b/pyrit/backend/services/attack_service.py
index fa20b36d1f..333e737fea 100644
--- a/pyrit/backend/services/attack_service.py
+++ b/pyrit/backend/services/attack_service.py
@@ -60,6 +60,7 @@
 from pyrit.backend.services.converter_service import get_converter_service
 from pyrit.backend.services.target_service import get_target_service
 from pyrit.common.deprecation import print_deprecation_message
+from pyrit.common.utils import to_sha256
 from pyrit.memory import AttackResultKeysetCursor, CentralMemory, data_serializer_factory
 from pyrit.models import (
     AtomicAttackIdentifier,
@@ -404,7 +405,7 @@ async def create_attack_async(self, *, request: CreateAttackRequest) -> CreateAt
 
     async def update_attack_async(self, *, attack_result_id: str, request: UpdateAttackRequest) -> AttackSummary | None:
         """
-        Update an attack's outcome.
+        Update an attack's mutable fields.
 
         Updates the AttackResult in the database.
 
@@ -415,21 +416,22 @@ async def update_attack_async(self, *, attack_result_id: str, request: UpdateAtt
         if not results:
             return None
 
-        # Map outcome
-        outcome_map = {
-            "undetermined": AttackOutcome.UNDETERMINED,
-            "success": AttackOutcome.SUCCESS,
-            "failure": AttackOutcome.FAILURE,
-            "error": AttackOutcome.ERROR,
-        }
-        new_outcome = outcome_map.get(request.outcome, AttackOutcome.UNDETERMINED)
+        update_fields: dict[str, Any] = {"timestamp": datetime.now(timezone.utc)}
+        if request.outcome is not None:
+            outcome_map = {
+                "undetermined": AttackOutcome.UNDETERMINED,
+                "success": AttackOutcome.SUCCESS,
+                "failure": AttackOutcome.FAILURE,
+                "error": AttackOutcome.ERROR,
+            }
+            update_fields["outcome"] = outcome_map[request.outcome].value
+        if request.objective is not None:
+            update_fields["objective"] = request.objective
+            update_fields["objective_sha256"] = to_sha256(request.objective)
 
         self._memory.update_attack_result_by_id(
             attack_result_id=attack_result_id,
-            update_fields={
-                "outcome": new_outcome.value,
-                "timestamp": datetime.now(timezone.utc),
-            },
+            update_fields=update_fields,
         )
 
         return await self.get_attack_async(attack_result_id=attack_result_id)
diff --git a/pyrit/score/__init__.py b/pyrit/score/__init__.py
index da68957fa5..4193ad8ca3 100644
--- a/pyrit/score/__init__.py
+++ b/pyrit/score/__init__.py
@@ -81,6 +81,7 @@
         LlamaGuardScorer,
         render_llamaguard_prompt,
     )
+    from pyrit.score.true_false.manual_true_false_scorer import ManualTrueFalseScorer
     from pyrit.score.true_false.prompt_shield_scorer import PromptShieldScorer
     from pyrit.score.true_false.question_answer_scorer import QuestionAnswerScorer
     from pyrit.score.true_false.regex.anthrax_keyword_scorer import AnthraxKeywordScorer
@@ -175,6 +176,7 @@
     "LlamaGuardScorer": "pyrit.score.true_false.llamaguard_scorer",
     "MarkdownInjectionScorer": "pyrit.score.true_false.regex.markdown_injection",
     "ManualScorer": "pyrit.score.float_scale.manual_scorer",
+    "ManualTrueFalseScorer": "pyrit.score.true_false.manual_true_false_scorer",
     "MessageScorableResolver": "pyrit.score.message_scorable_resolver",
     "MessageScorable": "pyrit.score.scorable",
     "MessageScorer": "pyrit.score.message_scorer",
diff --git a/pyrit/score/float_scale/manual_scorer.py b/pyrit/score/float_scale/manual_scorer.py
index d7673cad60..4efb6d570d 100644
--- a/pyrit/score/float_scale/manual_scorer.py
+++ b/pyrit/score/float_scale/manual_scorer.py
@@ -10,22 +10,26 @@
 class ManualScorer(FloatScaleScorer):
     """Create a user-supplied score for one persisted message piece."""
 
-    def __init__(self, *, value: float, rationale: str) -> None:
+    def __init__(self, *, value: float, rationale: str, success_threshold: float = 0.5) -> None:
         """
         Initialize the scorer.
 
         Args:
             value (float): User-supplied score in the range [0, 1].
             rationale (str): User-supplied explanation for the score.
+            success_threshold (float): Minimum score considered successful.
 
         Raises:
-            ValueError: If ``value`` is outside the range [0, 1].
+            ValueError: If ``value`` or ``success_threshold`` is outside the range [0, 1].
         """
         if not 0 <= value <= 1:
             raise ValueError("Manual score value must be between 0 and 1.")
+        if not 0 <= success_threshold <= 1:
+            raise ValueError("Manual score success threshold must be between 0 and 1.")
 
         self._value = value
         self._rationale = rationale
+        self._success_threshold = success_threshold
         super().__init__()
 
     def _build_identifier(self) -> ComponentIdentifier:
@@ -35,7 +39,13 @@ def _build_identifier(self) -> ComponentIdentifier:
         Returns:
             ComponentIdentifier: The scorer identifier.
         """
-        return self._create_identifier(params={"value": self._value, "rationale": self._rationale})
+        return self._create_identifier(
+            params={
+                "value": self._value,
+                "rationale": self._rationale,
+                "success_threshold": self._success_threshold,
+            }
+        )
 
     async def _score_scorable_async(
         self,
@@ -65,6 +75,7 @@ async def _score_scorable_async(
                 score_value_description="Manually assigned score",
                 score_type="float_scale",
                 score_rationale=self._rationale,
+                score_metadata={"success_threshold": self._success_threshold},
                 scorer_class_identifier=self.get_identifier(),
                 message_piece_id=message_piece_id,
                 scorable=scorable,
diff --git a/tests/unit/backend/test_api_routes.py b/tests/unit/backend/test_api_routes.py
index 1041aa3fae..d650f33302 100644
--- a/tests/unit/backend/test_api_routes.py
+++ b/tests/unit/backend/test_api_routes.py
@@ -41,7 +41,7 @@
 )
 from pyrit.backend.routes import version as version_routes
 from pyrit.backend.routes.labels import get_label_options
-from pyrit.models import ConverterIdentifier, MessagePiece, Score, TargetCapabilities, TargetIdentifier
+from pyrit.models import AttackOutcome, ConverterIdentifier, MessagePiece, Score, TargetCapabilities, TargetIdentifier
 from pyrit.models.catalog.target import TargetInstance
 
 
@@ -283,6 +283,31 @@ def test_update_attack_success(self, client: TestClient) -> None:
             data = response.json()
             assert data["outcome"] == "success"
 
+    def test_update_attack_objective_success(self, client: TestClient) -> None:
+        """Test adding an objective to an attack."""
+        now = datetime.now(timezone.utc)
+        with patch("pyrit.backend.routes.attacks.get_attack_service") as mock_get_service:
+            mock_get_service.return_value.update_attack_async = AsyncMock(
+                return_value=AttackSummary(
+                    attack_result_id="ar-attack-1",
+                    conversation_id="attack-1",
+                    objective="Extract the system prompt",
+                    outcome="undetermined",
+                    last_message_preview=None,
+                    message_count=0,
+                    created_at=now,
+                    updated_at=now,
+                )
+            )
+
+            response = client.patch(
+                "/api/attacks/ar-attack-1",
+                json={"objective": "Extract the system prompt"},
+            )
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.json()["objective"] == "Extract the system prompt"
+
     def test_add_message_success(self, client: TestClient) -> None:
         """Test adding a message to an attack."""
         now = datetime.now(timezone.utc)
@@ -1346,7 +1371,8 @@ class TestScoreRoutes:
     """Tests for score API routes."""
 
     def test_create_manual_score(self, client: TestClient) -> None:
-        """Test creating and persisting a manual score."""
+        """Test creating and persisting a float manual score."""
+        attack_result_id = uuid.uuid4()
         message_id = uuid.uuid4()
         score = Score(
             score_value="0.75",
@@ -1359,16 +1385,25 @@ def test_create_manual_score(self, client: TestClient) -> None:
             patch("pyrit.backend.routes.scores.CentralMemory") as mock_memory_class,
             patch("pyrit.backend.routes.scores.ManualScorer") as mock_manual_scorer_class,
         ):
-            mock_memory_class.get_memory_instance.return_value.get_message_pieces.return_value = [
-                MagicMock(id=message_id)
+            memory = mock_memory_class.get_memory_instance.return_value
+            memory.get_message_pieces.return_value = [MagicMock(id=message_id, conversation_id="conversation-id")]
+            memory.get_attack_results.return_value = [
+                MagicMock(
+                    objective="Evaluate the response",
+                    last_score=None,
+                    includes_conversation=MagicMock(return_value=True),
+                )
             ]
+            memory.update_attack_result_by_id.return_value = True
             mock_scorer = mock_manual_scorer_class.return_value
             mock_scorer.score_async = AsyncMock(return_value=[score])
 
             response = client.post(
                 "/api/scores/manual",
                 json={
+                    "attack_result_id": str(attack_result_id),
                     "message_id": str(message_id),
+                    "score_type": "float_scale",
                     "value": 0.75,
                     "rationale": "Mostly satisfied",
                 },
@@ -1377,9 +1412,147 @@ def test_create_manual_score(self, client: TestClient) -> None:
         assert response.status_code == status.HTTP_201_CREATED
         assert response.json()["score_value"] == "0.75"
         assert response.json()["score_rationale"] == "Mostly satisfied"
-        mock_manual_scorer_class.assert_called_once_with(value=0.75, rationale="Mostly satisfied")
+        mock_manual_scorer_class.assert_called_once_with(
+            value=0.75,
+            rationale="Mostly satisfied",
+            success_threshold=0.5,
+        )
         scorable = mock_scorer.score_async.await_args.kwargs["scorable"]
         assert scorable.message_piece_ids == (message_id,)
+        update_fields = memory.update_attack_result_by_id.call_args.kwargs["update_fields"]
+        assert update_fields["last_score_id"] == score.id
+        assert update_fields["outcome"] == AttackOutcome.SUCCESS
+        assert update_fields["outcome_reason"] == "Mostly satisfied"
+
+    def test_create_manual_true_false_score(self, client: TestClient) -> None:
+        """Test creating and persisting a true/false manual score."""
+        attack_result_id = uuid.uuid4()
+        message_id = uuid.uuid4()
+        score = Score(
+            score_value="True",
+            score_type="true_false",
+            score_rationale="Objective achieved",
+            message_piece_id=message_id,
+        )
+
+        with (
+            patch("pyrit.backend.routes.scores.CentralMemory") as mock_memory_class,
+            patch("pyrit.backend.routes.scores.ManualTrueFalseScorer") as mock_manual_scorer_class,
+        ):
+            memory = mock_memory_class.get_memory_instance.return_value
+            memory.get_message_pieces.return_value = [MagicMock(id=message_id, conversation_id="conversation-id")]
+            memory.get_attack_results.return_value = [
+                MagicMock(
+                    objective="Evaluate the response",
+                    last_score=None,
+                    includes_conversation=MagicMock(return_value=True),
+                )
+            ]
+            memory.update_attack_result_by_id.return_value = True
+            mock_scorer = mock_manual_scorer_class.return_value
+            mock_scorer.score_async = AsyncMock(return_value=[score])
+
+            response = client.post(
+                "/api/scores/manual",
+                json={
+                    "attack_result_id": str(attack_result_id),
+                    "message_id": str(message_id),
+                    "score_type": "true_false",
+                    "value": True,
+                    "rationale": "Objective achieved",
+                },
+            )
+
+        assert response.status_code == status.HTTP_201_CREATED
+        assert response.json()["score_type"] == "true_false"
+        assert response.json()["score_value"] == "True"
+        mock_manual_scorer_class.assert_called_once_with(value=True, rationale="Objective achieved")
+        update_fields = memory.update_attack_result_by_id.call_args.kwargs["update_fields"]
+        assert update_fields["last_score_id"] == score.id
+        assert update_fields["outcome"] == AttackOutcome.SUCCESS
+
+    def test_create_manual_score_preserves_existing_attack_score(self, client: TestClient) -> None:
+        """Test that a manual score does not replace an existing attack score."""
+        attack_result_id = uuid.uuid4()
+        message_id = uuid.uuid4()
+        score = Score(
+            score_value="False",
+            score_type="true_false",
+            score_rationale="Objective not achieved",
+            message_piece_id=message_id,
+        )
+
+        with (
+            patch("pyrit.backend.routes.scores.CentralMemory") as mock_memory_class,
+            patch("pyrit.backend.routes.scores.ManualTrueFalseScorer") as mock_manual_scorer_class,
+        ):
+            memory = mock_memory_class.get_memory_instance.return_value
+            memory.get_message_pieces.return_value = [MagicMock(id=message_id, conversation_id="conversation-id")]
+            memory.get_attack_results.return_value = [
+                MagicMock(
+                    objective="Evaluate the response",
+                    last_score=MagicMock(),
+                    includes_conversation=MagicMock(return_value=True),
+                )
+            ]
+            mock_manual_scorer_class.return_value.score_async = AsyncMock(return_value=[score])
+
+            response = client.post(
+                "/api/scores/manual",
+                json={
+                    "attack_result_id": str(attack_result_id),
+                    "message_id": str(message_id),
+                    "score_type": "true_false",
+                    "value": False,
+                    "rationale": "Objective not achieved",
+                },
+            )
+
+        assert response.status_code == status.HTTP_201_CREATED
+        memory.update_attack_result_by_id.assert_not_called()
+
+    def test_create_low_float_manual_score_sets_attack_failure(self, client: TestClient) -> None:
+        """Test that a non-zero float below the threshold is not treated as success."""
+        attack_result_id = uuid.uuid4()
+        message_id = uuid.uuid4()
+        score = Score(
+            score_value="0.1",
+            score_type="float_scale",
+            score_rationale="Objective mostly not achieved",
+            message_piece_id=message_id,
+        )
+
+        with (
+            patch("pyrit.backend.routes.scores.CentralMemory") as mock_memory_class,
+            patch("pyrit.backend.routes.scores.ManualScorer") as mock_manual_scorer_class,
+        ):
+            memory = mock_memory_class.get_memory_instance.return_value
+            memory.get_message_pieces.return_value = [MagicMock(id=message_id, conversation_id="conversation-id")]
+            memory.get_attack_results.return_value = [
+                MagicMock(
+                    objective="Evaluate the response",
+                    last_score=None,
+                    includes_conversation=MagicMock(return_value=True),
+                )
+            ]
+            memory.update_attack_result_by_id.return_value = True
+            mock_manual_scorer_class.return_value.score_async = AsyncMock(return_value=[score])
+
+            response = client.post(
+                "/api/scores/manual",
+                json={
+                    "attack_result_id": str(attack_result_id),
+                    "message_id": str(message_id),
+                    "score_type": "float_scale",
+                    "value": 0.1,
+                    "success_threshold": 0.5,
+                    "rationale": "Objective mostly not achieved",
+                },
+            )
+
+        assert response.status_code == status.HTTP_201_CREATED
+        update_fields = memory.update_attack_result_by_id.call_args.kwargs["update_fields"]
+        assert update_fields["outcome"] == AttackOutcome.FAILURE
 
     def test_create_manual_score_message_not_found(self, client: TestClient) -> None:
         """Test that a missing message returns 404 without running the scorer."""
@@ -1393,7 +1566,13 @@ def test_create_manual_score_message_not_found(self, client: TestClient) -> None
 
             response = client.post(
                 "/api/scores/manual",
-                json={"message_id": str(message_id), "value": 0.5, "rationale": ""},
+                json={
+                    "attack_result_id": str(uuid.uuid4()),
+                    "message_id": str(message_id),
+                    "score_type": "float_scale",
+                    "value": 0.5,
+                    "rationale": "",
+                },
             )
 
         assert response.status_code == status.HTTP_404_NOT_FOUND
@@ -1404,11 +1583,126 @@ def test_create_manual_score_rejects_value_outside_range(self, client: TestClien
         """Test request validation for the manual score range."""
         response = client.post(
             "/api/scores/manual",
-            json={"message_id": str(uuid.uuid4()), "value": value, "rationale": ""},
+            json={
+                "attack_result_id": str(uuid.uuid4()),
+                "message_id": str(uuid.uuid4()),
+                "score_type": "float_scale",
+                "value": value,
+                "rationale": "",
+            },
         )
 
         assert response.status_code == status.HTTP_422_UNPROCESSABLE_CONTENT
 
+    @pytest.mark.parametrize(
+        "request_body",
+        [
+            {
+                "attack_result_id": str(uuid.uuid4()),
+                "message_id": str(uuid.uuid4()),
+                "value": 0.5,
+            },
+            {
+                "attack_result_id": str(uuid.uuid4()),
+                "message_id": str(uuid.uuid4()),
+                "score_type": "float_scale",
+            },
+        ],
+    )
+    def test_create_manual_score_requires_type_and_value(
+        self,
+        client: TestClient,
+        request_body: dict[str, str | float],
+    ) -> None:
+        """Test that score type and value are required."""
+        response = client.post("/api/scores/manual", json=request_body)
+
+        assert response.status_code == status.HTTP_422_UNPROCESSABLE_CONTENT
+
+    @pytest.mark.parametrize(
+        ("score_type", "value"),
+        [
+            ("true_false", 0.5),
+            ("float_scale", True),
+        ],
+    )
+    def test_create_manual_score_rejects_mismatched_value_type(
+        self,
+        client: TestClient,
+        score_type: str,
+        value: bool | float,
+    ) -> None:
+        """Test that the score value matches its declared score family."""
+        response = client.post(
+            "/api/scores/manual",
+            json={
+                "attack_result_id": str(uuid.uuid4()),
+                "message_id": str(uuid.uuid4()),
+                "score_type": score_type,
+                "value": value,
+                "rationale": "",
+            },
+        )
+
+        assert response.status_code == status.HTTP_422_UNPROCESSABLE_CONTENT
+
+    def test_create_manual_score_requires_attack_objective(self, client: TestClient) -> None:
+        """Test that manual scoring is rejected when the attack has no objective."""
+        attack_result_id = uuid.uuid4()
+        message_id = uuid.uuid4()
+
+        with (
+            patch("pyrit.backend.routes.scores.CentralMemory") as mock_memory_class,
+            patch("pyrit.backend.routes.scores.ManualScorer") as mock_manual_scorer_class,
+        ):
+            memory = mock_memory_class.get_memory_instance.return_value
+            memory.get_message_pieces.return_value = [MagicMock(id=message_id, conversation_id="conversation-id")]
+            memory.get_attack_results.return_value = [MagicMock(objective="")]
+
+            response = client.post(
+                "/api/scores/manual",
+                json={
+                    "attack_result_id": str(attack_result_id),
+                    "message_id": str(message_id),
+                    "score_type": "float_scale",
+                    "value": 0.5,
+                    "rationale": "",
+                },
+            )
+
+        assert response.status_code == status.HTTP_422_UNPROCESSABLE_CONTENT
+        assert response.json()["detail"] == "An attack objective is required before adding a manual score"
+        mock_manual_scorer_class.assert_not_called()
+
+    def test_create_manual_score_rejects_message_without_conversation(self, client: TestClient) -> None:
+        """Test that an unassociated message cannot be scored as part of an attack."""
+        attack_result_id = uuid.uuid4()
+        message_id = uuid.uuid4()
+
+        with (
+            patch("pyrit.backend.routes.scores.CentralMemory") as mock_memory_class,
+            patch("pyrit.backend.routes.scores.ManualScorer") as mock_manual_scorer_class,
+        ):
+            memory = mock_memory_class.get_memory_instance.return_value
+            memory.get_message_pieces.return_value = [MagicMock(id=message_id, conversation_id=None)]
+            memory.get_attack_results.return_value = [MagicMock(objective="Evaluate the response")]
+
+            response = client.post(
+                "/api/scores/manual",
+                json={
+                    "attack_result_id": str(attack_result_id),
+                    "message_id": str(message_id),
+                    "score_type": "float_scale",
+                    "value": 0.5,
+                    "success_threshold": 0.5,
+                    "rationale": "",
+                },
+            )
+
+        assert response.status_code == status.HTTP_422_UNPROCESSABLE_CONTENT
+        assert response.json()["detail"] == "The message does not belong to the specified attack"
+        mock_manual_scorer_class.assert_not_called()
+
 
 # ============================================================================
 # Health Routes Tests
diff --git a/tests/unit/backend/test_attack_service.py b/tests/unit/backend/test_attack_service.py
index 949ae8e863..2dcb231832 100644
--- a/tests/unit/backend/test_attack_service.py
+++ b/tests/unit/backend/test_attack_service.py
@@ -31,6 +31,7 @@
     AttackService,
     get_attack_service,
 )
+from pyrit.common.utils import to_sha256
 from pyrit.memory import AttackResultKeysetCursor
 from pyrit.models import (
     AtomicAttackIdentifier,
@@ -1184,6 +1185,21 @@ async def test_update_attack_updates_outcome_error(self, attack_service, mock_me
         call_kwargs = mock_memory.update_attack_result_by_id.call_args[1]
         assert call_kwargs["update_fields"]["outcome"] == "error"
 
+    async def test_update_attack_updates_objective_and_hash(self, attack_service, mock_memory) -> None:
+        """Test that updating the objective keeps its lookup hash synchronized."""
+        ar = make_attack_result(conversation_id="test-id", objective="")
+        mock_memory.get_attack_results.return_value = [ar]
+        mock_memory.get_conversation_messages.return_value = []
+
+        await attack_service.update_attack_async(
+            attack_result_id="test-id",
+            request=UpdateAttackRequest(objective="Extract the system prompt"),
+        )
+
+        update_fields = mock_memory.update_attack_result_by_id.call_args.kwargs["update_fields"]
+        assert update_fields["objective"] == "Extract the system prompt"
+        assert update_fields["objective_sha256"] == to_sha256("Extract the system prompt")
+
     async def test_update_attack_bumps_timestamp(self, attack_service, mock_memory) -> None:
         """Test that update_attack bumps the timestamp recency column and does not write metadata."""
         old_time = datetime(2024, 1, 1, tzinfo=timezone.utc)
diff --git a/tests/unit/score/test_manual_scorer.py b/tests/unit/score/test_manual_scorer.py
index 6d96af77f0..2e8788c333 100644
--- a/tests/unit/score/test_manual_scorer.py
+++ b/tests/unit/score/test_manual_scorer.py
@@ -7,7 +7,7 @@
 
 from pyrit.memory import MemoryInterface
 from pyrit.models import ContentScorable, MessagePiece, MessageScorable
-from pyrit.score import ManualScorer
+from pyrit.score import ManualScorer, ManualTrueFalseScorer
 
 
 @pytest.mark.usefixtures("patch_central_database")
@@ -27,6 +27,7 @@ async def test_manual_scorer_persists_value_and_rationale(sqlite_instance: Memor
     assert len(scores) == 1
     assert scores[0].get_value() == 0.75
     assert scores[0].score_rationale == "Mostly satisfied"
+    assert scores[0].score_metadata == {"success_threshold": 0.5}
     assert scores[0].message_piece_id == message_id
     assert sqlite_instance.get_prompt_scores(prompt_ids=[message_id])[0].id == scores[0].id
 
@@ -42,3 +43,28 @@ async def test_manual_scorer_rejects_non_message_scorable() -> None:
 
     with pytest.raises(RuntimeError, match="ManualScorer requires a MessageScorable"):
         await scorer.score_async(scorable=ContentScorable(value="content"))
+
+
+@pytest.mark.usefixtures("patch_central_database")
+@pytest.mark.parametrize("value", [True, False])
+async def test_manual_true_false_scorer_persists_value(
+    sqlite_instance: MemoryInterface,
+    value: bool,
+) -> None:
+    message = MessagePiece(
+        role="assistant",
+        original_value="response",
+        conversation_id=str(uuid.uuid4()),
+    ).to_message()
+    sqlite_instance.add_message_to_memory(request=message)
+    message_id = message.get_piece().id
+
+    scores = await ManualTrueFalseScorer(value=value, rationale="Human verdict").score_async(
+        scorable=MessageScorable(message_piece_ids=(message_id,)),
+    )
+
+    assert len(scores) == 1
+    assert scores[0].get_value() is value
+    assert scores[0].score_type == "true_false"
+    assert scores[0].score_rationale == "Human verdict"
+    assert sqlite_instance.get_prompt_scores(prompt_ids=[message_id])[0].id == scores[0].id

From c8570dc04ca45bff2018466028f40743a13da329 Mon Sep 17 00:00:00 2001
From: jbolor21 <86250273+jbolor21@users.noreply.github.com>
Date: Tue, 8 Sep 2026 09:13:39 -0700
Subject: [PATCH 3/4] fix UI for variable window sizes

---
 frontend/e2e/touch-targets.spec.ts            | 26 +++++++++++++++++++
 frontend/src/components/Chat/ChatWindow.tsx   |  2 +-
 .../src/components/Chat/MessageList.styles.ts |  9 +++++++
 frontend/src/components/Chat/MessageList.tsx  | 19 +++++++++++---
 .../components/Chat/ObjectiveHeader.styles.ts | 19 +++++++++++++-
 .../src/components/Chat/ObjectiveHeader.tsx   | 24 ++++++++---------
 6 files changed, 81 insertions(+), 18 deletions(-)

diff --git a/frontend/e2e/touch-targets.spec.ts b/frontend/e2e/touch-targets.spec.ts
index bea4b9c24a..8622206db5 100644
--- a/frontend/e2e/touch-targets.spec.ts
+++ b/frontend/e2e/touch-targets.spec.ts
@@ -570,11 +570,37 @@ test.describe("Mobile touch targets", () => {
           '[data-testid="copy-to-new-conv-btn-1"]',
           '[data-testid="branch-conv-btn-1"]',
           '[data-testid="branch-attack-btn-1"]',
+          '[aria-label="Add manual score"]',
         ].join(",")
       )
     );
     await expectNoDocumentOverflow(page);
 
+    const manualScoreButton = page.getByRole("button", {
+      name: "Add manual score",
+    });
+    await manualScoreButton.click();
+    await page.getByRole("radio", { name: "Float scale" }).click();
+    await page.setViewportSize({ width: 320, height: 568 });
+
+    const manualScorePopover = page.getByTestId("manual-score-popover");
+    await expect(manualScorePopover).toBeVisible();
+    const popoverBounds = await manualScorePopover.boundingBox();
+    if (!popoverBounds) {
+      throw new Error("Expected manual score popover bounds");
+    }
+    expect(popoverBounds.y).toBeGreaterThanOrEqual(0);
+    expect(popoverBounds.y + popoverBounds.height).toBeLessThanOrEqual(568);
+    await expectMinimumTouchTarget(
+      page.getByRole("button", { name: "Cancel" })
+    );
+    await expectMinimumTouchTarget(
+      page.getByRole("button", { name: "Save" })
+    );
+    await expectNoDocumentOverflow(page);
+    await page.keyboard.press("Escape");
+    await page.setViewportSize({ width: 320, height: MOBILE_VIEWPORT.height });
+
     await page.getByTestId("toggle-panel-btn").click();
     await expect(
       page.getByRole("dialog", { name: "Attack Conversations" })
diff --git a/frontend/src/components/Chat/ChatWindow.tsx b/frontend/src/components/Chat/ChatWindow.tsx
index 12d8609a0d..8c1500cea9 100644
--- a/frontend/src/components/Chat/ChatWindow.tsx
+++ b/frontend/src/components/Chat/ChatWindow.tsx
@@ -898,7 +898,7 @@ export default function ChatWindow({
           </div>
         </div>
         <ObjectiveHeader
-          key={`${attackResultId ?? 'new'}-${objective}-${pendingObjective}`}
+          key={`${attackResultId ?? 'new'}-${objective}-${pendingObjective}-${objectiveEditRequestId}`}
           objective={objective || pendingObjective}
           canAdd={
             Boolean(activeTarget)
diff --git a/frontend/src/components/Chat/MessageList.styles.ts b/frontend/src/components/Chat/MessageList.styles.ts
index 28d55c7905..07cf389410 100644
--- a/frontend/src/components/Chat/MessageList.styles.ts
+++ b/frontend/src/components/Chat/MessageList.styles.ts
@@ -113,12 +113,21 @@ export const useMessageListStyles = makeStyles({
     flexDirection: 'column',
     gap: tokens.spacingVerticalS,
     width: 'min(320px, calc(100vw - 32px))',
+    maxHeight: 'calc(100vh - 32px)',
+    overflowY: 'auto',
   },
   manualScoreActions: {
     display: 'flex',
     justifyContent: 'flex-end',
+    flexWrap: 'wrap',
     gap: tokens.spacingHorizontalS,
   },
+  manualScoreActionButton: {
+    ...mobileTouchTargetHeight,
+  },
+  manualScoreInput: {
+    ...mobileTouchTargetHeight,
+  },
   thresholdControls: {
     display: 'flex',
     flexDirection: 'column',
diff --git a/frontend/src/components/Chat/MessageList.tsx b/frontend/src/components/Chat/MessageList.tsx
index 0cafa3d0f2..c72ae3ee91 100644
--- a/frontend/src/components/Chat/MessageList.tsx
+++ b/frontend/src/components/Chat/MessageList.tsx
@@ -247,7 +247,7 @@ function ManualScorePopover({
           />
         </PopoverTrigger>
       </Tooltip>
-      <PopoverSurface className={styles.manualScorePopover}>
+      <PopoverSurface className={styles.manualScorePopover} data-testid="manual-score-popover">
         <Text weight="semibold">Manual score</Text>
         <Field label="Score type" required>
           <RadioGroup
@@ -279,6 +279,7 @@ function ManualScorePopover({
               validationMessage={value && !isValueValid ? 'Enter a number from 0 to 1.' : undefined}
             >
               <Input
+                className={styles.manualScoreInput}
                 type="number"
                 min={0}
                 max={1}
@@ -297,7 +298,7 @@ function ManualScorePopover({
               >
                 <div className={styles.thresholdControls}>
                   <Input
-                    className={styles.thresholdInput}
+                    className={mergeClasses(styles.manualScoreInput, styles.thresholdInput)}
                     type="number"
                     min={0}
                     max={1}
@@ -330,10 +331,20 @@ function ManualScorePopover({
         </Field>
         {error && <Text role="alert">{error}</Text>}
         <div className={styles.manualScoreActions}>
-          <Button appearance="secondary" onClick={() => setIsOpen(false)} disabled={isSaving}>
+          <Button
+            appearance="secondary"
+            className={styles.manualScoreActionButton}
+            onClick={() => setIsOpen(false)}
+            disabled={isSaving}
+          >
             Cancel
           </Button>
-          <Button appearance="primary" onClick={handleSave} disabled={!isFormValid || isSaving}>
+          <Button
+            appearance="primary"
+            className={styles.manualScoreActionButton}
+            onClick={handleSave}
+            disabled={!isFormValid || isSaving}
+          >
             {isSaving ? 'Saving...' : 'Save'}
           </Button>
         </div>
diff --git a/frontend/src/components/Chat/ObjectiveHeader.styles.ts b/frontend/src/components/Chat/ObjectiveHeader.styles.ts
index bc2fd155a9..5f365c501e 100644
--- a/frontend/src/components/Chat/ObjectiveHeader.styles.ts
+++ b/frontend/src/components/Chat/ObjectiveHeader.styles.ts
@@ -1,6 +1,6 @@
 import { makeStyles, tokens } from '@fluentui/react-components'
 
-import { mobileTouchTargetHeight } from '../../styles/touchTargets'
+import { NARROW_VIEWPORT_QUERY, mobileTouchTargetHeight } from '../../styles/touchTargets'
 
 export const useObjectiveHeaderStyles = makeStyles({
   root: {
@@ -13,6 +13,12 @@ export const useObjectiveHeaderStyles = makeStyles({
     backgroundColor: tokens.colorNeutralBackground2,
     borderBottom: `1px solid ${tokens.colorNeutralStroke1}`,
     borderLeft: `3px solid ${tokens.colorBrandStroke1}`,
+    [NARROW_VIEWPORT_QUERY]: {
+      alignItems: 'center',
+      flexWrap: 'wrap',
+      rowGap: tokens.spacingVerticalS,
+      padding: `${tokens.spacingVerticalS} ${tokens.spacingHorizontalM}`,
+    },
   },
   label: {
     flexShrink: 0,
@@ -37,6 +43,11 @@ export const useObjectiveHeaderStyles = makeStyles({
   input: {
     flexGrow: 1,
     minWidth: 0,
+    ...mobileTouchTargetHeight,
+    [NARROW_VIEWPORT_QUERY]: {
+      flexBasis: '100%',
+      order: 2,
+    },
   },
   addButton: {
     ...mobileTouchTargetHeight,
@@ -48,4 +59,10 @@ export const useObjectiveHeaderStyles = makeStyles({
     color: tokens.colorBrandForeground1,
     ...mobileTouchTargetHeight,
   },
+  editorAction: {
+    ...mobileTouchTargetHeight,
+    [NARROW_VIEWPORT_QUERY]: {
+      order: 3,
+    },
+  },
 })
diff --git a/frontend/src/components/Chat/ObjectiveHeader.tsx b/frontend/src/components/Chat/ObjectiveHeader.tsx
index f218e13c91..6bcbb1ac73 100644
--- a/frontend/src/components/Chat/ObjectiveHeader.tsx
+++ b/frontend/src/components/Chat/ObjectiveHeader.tsx
@@ -1,4 +1,4 @@
-import { useEffect, useLayoutEffect, useRef, useState } from 'react'
+import { useLayoutEffect, useRef, useState } from 'react'
 
 import {
   Badge,
@@ -22,23 +22,16 @@ interface ObjectiveHeaderProps {
 
 export default function ObjectiveHeader({ objective, canAdd = false, onAdd, editRequestId = 0 }: ObjectiveHeaderProps) {
   const styles = useObjectiveHeaderStyles()
+  const promptedForManualScore = editRequestId > 0 && !objective && Boolean(onAdd)
   const [expanded, setExpanded] = useState(false)
   const [overflowing, setOverflowing] = useState(false)
-  const [isEditing, setIsEditing] = useState(false)
+  const [isEditing, setIsEditing] = useState(promptedForManualScore)
   const [draft, setDraft] = useState('')
   const [isSaving, setIsSaving] = useState(false)
   const [error, setError] = useState('')
-  const [showManualScoreWarning, setShowManualScoreWarning] = useState(false)
+  const [showManualScoreWarning, setShowManualScoreWarning] = useState(promptedForManualScore)
   const contentRef = useRef<HTMLElement>(null)
 
-  useEffect(() => {
-    if (editRequestId > 0 && !objective && onAdd) {
-      setError('')
-      setShowManualScoreWarning(true)
-      setIsEditing(true)
-    }
-  }, [editRequestId, objective, onAdd])
-
   useLayoutEffect(() => {
     const content = contentRef.current
     if (!content) return
@@ -98,12 +91,19 @@ export default function ObjectiveHeader({ objective, canAdd = false, onAdd, edit
                 aria-label="Attack objective"
                 autoFocus
               />
-              <Button appearance="primary" size="small" onClick={handleSave} disabled={!draft.trim() || isSaving}>
+              <Button
+                appearance="primary"
+                size="small"
+                className={styles.editorAction}
+                onClick={handleSave}
+                disabled={!draft.trim() || isSaving}
+              >
                 {isSaving ? 'Saving...' : 'Save'}
               </Button>
               <Button
                 appearance="subtle"
                 size="small"
+                className={styles.editorAction}
                 onClick={() => {
                   setIsEditing(false)
                   setShowManualScoreWarning(false)

From 9df33b5786ea2abec7ffb9416e91e676647281cb Mon Sep 17 00:00:00 2001
From: jbolor21 <86250273+jbolor21@users.noreply.github.com>
Date: Wed, 9 Sep 2026 11:52:43 -0700
Subject: [PATCH 4/4] ui fixes

---
 frontend/e2e/touch-targets.spec.ts            | 27 +++++++++++++++++++
 .../components/Chat/ObjectiveHeader.styles.ts | 12 ++++++++-
 2 files changed, 38 insertions(+), 1 deletion(-)

diff --git a/frontend/e2e/touch-targets.spec.ts b/frontend/e2e/touch-targets.spec.ts
index 8622206db5..b261051594 100644
--- a/frontend/e2e/touch-targets.spec.ts
+++ b/frontend/e2e/touch-targets.spec.ts
@@ -392,6 +392,33 @@ test.beforeEach(async ({ page }) => {
 test.describe("Mobile touch targets", () => {
   test.use({ viewport: MOBILE_VIEWPORT, hasTouch: true });
 
+  test("keeps the empty-chat objective editor usable on a narrow screen", async ({
+    page,
+  }) => {
+    await page.setViewportSize({ width: 320, height: 568 });
+    await page.goto("/");
+    await page.getByRole("button", { name: "Targets", exact: true }).click();
+    await expect(page.getByText("gpt-4o-mobile")).toBeVisible();
+    await page.getByRole("button", { name: "Set Active" }).first().click();
+    await page.getByRole("button", { name: "Chat", exact: true }).click();
+
+    await page.getByRole("button", { name: "Add objective" }).click();
+    const objectiveInput = page.getByRole("textbox", {
+      name: "Attack objective",
+    });
+    await expectMinimumTouchTarget(objectiveInput);
+    await objectiveInput.fill(
+      "Evaluate whether the response satisfies this mobile attack objective"
+    );
+    await expectMinimumTouchTarget(
+      page.getByRole("button", { name: "Save" })
+    );
+    await expectMinimumTouchTarget(
+      page.getByRole("button", { name: "Cancel" })
+    );
+    await expectNoDocumentOverflow(page);
+  });
+
   test("keeps Home, Targets, and History controls at least 44px", async ({
     page,
   }) => {
diff --git a/frontend/src/components/Chat/ObjectiveHeader.styles.ts b/frontend/src/components/Chat/ObjectiveHeader.styles.ts
index 5f365c501e..b138d5b9ac 100644
--- a/frontend/src/components/Chat/ObjectiveHeader.styles.ts
+++ b/frontend/src/components/Chat/ObjectiveHeader.styles.ts
@@ -1,6 +1,11 @@
 import { makeStyles, tokens } from '@fluentui/react-components'
 
-import { NARROW_VIEWPORT_QUERY, mobileTouchTargetHeight } from '../../styles/touchTargets'
+import {
+  MINIMUM_TOUCH_TARGET_SIZE,
+  NARROW_VIEWPORT_QUERY,
+  TOUCH_INPUT_QUERY,
+  mobileTouchTargetHeight,
+} from '../../styles/touchTargets'
 
 export const useObjectiveHeaderStyles = makeStyles({
   root: {
@@ -44,6 +49,11 @@ export const useObjectiveHeaderStyles = makeStyles({
     flexGrow: 1,
     minWidth: 0,
     ...mobileTouchTargetHeight,
+    '& input': {
+      [TOUCH_INPUT_QUERY]: {
+        minHeight: MINIMUM_TOUCH_TARGET_SIZE,
+      },
+    },
     [NARROW_VIEWPORT_QUERY]: {
       flexBasis: '100%',
       order: 2,