4 - FEAT: Last-used Defaults

doc/gui/0_gui.md

@@ -23,12 +23,12 @@ For other setup options, see [Docker](../getting_started/install_docker.md) or t
 
 ## Home
 
-Home shows your default objective target and recent attacks grouped by operation.
+Home shows your last-used objective target and recent attacks grouped by operation.
 Open an attack to return to its conversation, or go to Registry to configure a
 target. The shared labels bar sets the operator, operation, and custom labels
 for new work; it does not change saved results.
 
-![Home page with default target and recent work](images/home.png)
+![Home page with target and recent work](images/home.png)
 
 ## Chat
 
@@ -37,6 +37,17 @@ workspace. Select a target and write the messages yourself. You can attach media
 and branch or edit conversations to try another approach. Add an objective and
 select a chat scorer if you want automated assessment of responses.
 
+New chats and scans start with the last objective target you used. New chats also
+reuse the last chat scorer, including **Off**, unless a Registry default is set.
+These choices are saved in the current browser profile after use. Opening saved
+activity or editing an unsent draft does not change them.
+Chat use is recorded only after a request turn is confirmed, not after preparation
+fails, and stays with the initiating account even if you navigate away. A chat
+with a temperature override remembers its registered source target, without
+changing that chat's execution binding. While a remembered scorer is loading,
+wait for its catalog. Explicit scorer selections, including **Off**, take
+precedence; an unavailable remembered scorer is not saved as **Off**.
+
 The **Chat** tab returns to your retained draft, or your last chat if there is no draft.
 Selecting **Chat** while a chat is open keeps that chat open.
 Use **New attack** to start a blank draft. The **History** tab
@@ -85,7 +96,10 @@ Registry prepares reusable components; it does not execute attacks. Create
 targets to connect to model endpoints, converters to transform content, and
 named techniques that configure existing attacks. Browse configured scorers
 and select a default chat scorer; scorer setup uses initializers, not an editor
-on this page. Target defaults apply to new chats and scans.
+on this page. An explicit scan choice takes precedence. Otherwise, the current
+adversarial-target order is a saved Registry default, the registered
+`adversarial_chat` target, then last use. Objective targets do not have a Registry
+default. Existing chats and runs keep their settings.
 
 Expand a target, scorer, technique, or converter name to inspect its identity
 JSON. Target identity inspection is independent of expanding composite target
@@ -96,6 +110,9 @@ red X to remove a converter from the live registry; confirmation is required.
 **Scenario presets** save a scenario configuration for reuse with a target
 chosen at launch. **Suites** maintain ordered collections of preset definitions.
 They are stored separately from live component instances.
+Suite launch dialogs apply arriving target defaults only to untouched selections.
+An explicit target choice, including clearing an optional adversarial target to
+use the server default, is retained when the registry refreshes.
 
 Targets, converters, and techniques added only to the live registry must be
 recreated after a backend restart or reinitialization. Use

frontend/e2e/_fixtures.ts

@@ -1,4 +1,4 @@
-import { test as base } from "@playwright/test";
+import { test as base, expect, type Page } from "@playwright/test";
 import { mockVersion } from "./_compatibility";
 
 export * from "@playwright/test";
@@ -19,3 +19,10 @@ export const test = base.extend<{ mockStartup: void }>({
     await use();
   }, { auto: true }],
 });
+
+export async function selectChatTarget(page: Page, registryName?: string): Promise<void> {
+  await page.goto("/attack/chat");
+  const picker = page.getByRole("combobox", { name: "Chat target", exact: true });
+  await expect(picker).toBeEnabled();
+  await picker.selectOption(registryName ?? { index: 1 });
+}

frontend/e2e/accessibility.spec.ts

@@ -1,4 +1,4 @@
-import { test, expect, type Locator, type Page } from "./_fixtures";
+import { test, expect, selectChatTarget, type Locator, type Page } from "./_fixtures";
 import { mockVersion } from "./_compatibility";
 import { makeTarget } from "./_targets";
 import { TOUR_STEPS } from "../src/components/Tour/tourSteps";
@@ -123,13 +123,7 @@ test.describe("Accessibility", () => {
       });
     });
 
-    // Save an objective default, then open a new chat with that target.
-    await page.getByRole("button", { name: "Registry", exact: true }).click();
-    await expect(page.getByText("Target Registry")).toBeVisible({ timeout: 10000 });
-    const objectiveDefault = page.getByRole("combobox", { name: "Default objective target", exact: true });
-    await expect(objectiveDefault).toBeVisible({ timeout: 5000 });
-    await objectiveDefault.selectOption({ index: 1 });
-    await page.getByRole("button", { name: "Attacks", exact: true }).click();
+    await selectChatTarget(page, "a11y-form-target");
 
     // Input should be accessible
     const input = page.getByRole("textbox", { name: "Type prompt here", exact: true });
@@ -266,13 +260,7 @@ test.describe("Accessibility", () => {
       });
     });
 
-    // Save an objective default, then open a new chat with that target.
-    await page.getByRole("button", { name: "Registry", exact: true }).click();
-    await expect(page.getByText("Target Registry")).toBeVisible({ timeout: 10000 });
-    const objectiveDefault = page.getByRole("combobox", { name: "Default objective target", exact: true });
-    await expect(objectiveDefault).toBeVisible({ timeout: 5000 });
-    await objectiveDefault.selectOption({ index: 1 });
-    await page.getByRole("button", { name: "Attacks", exact: true }).click();
+    await selectChatTarget(page, "a11y-focus-target");
 
     const input = page.getByRole("textbox", { name: "Type prompt here", exact: true });
     await expect(input).toBeEnabled({ timeout: 5000 });

frontend/e2e/chat-recovery.spec.ts

@@ -4,6 +4,7 @@ import { createServer, type IncomingMessage, type ServerResponse } from "node:ht
 import {
   test as base,
   expect,
+  selectChatTarget,
   type APIRequestContext,
   type Page,
   type Request,
@@ -236,11 +237,7 @@ test.describe("Chat processing recovery @seeded", () => {
   test.setTimeout(90_000);
 
   test.beforeEach(async ({ page, localTarget }) => {
-    await page.goto("/");
-    await page.getByRole("button", { name: "Registry", exact: true }).click();
-    await page.getByRole("combobox", { name: "Default objective target", exact: true })
-      .selectOption(localTarget.registryName);
-    await page.getByRole("button", { name: "Attacks", exact: true }).click();
+    await selectChatTarget(page, localTarget.registryName);
   });
 
   test("keeps the drawer closed when a delayed send refresh discovers another conversation", async ({

frontend/e2e/chat.spec.ts

@@ -1,6 +1,6 @@
 import { readFileSync } from "node:fs";
-import { test, expect, type Locator, type Page, type Request } from "./_fixtures";
-import type { BackendMessage, BackendMessagePiece } from "@/types";
+import { test, expect, selectChatTarget, type Locator, type Page, type Request } from "./_fixtures";
+import type { BackendMessage, BackendMessagePiece, TargetResponseStatus } from "@/types";
 import { fulfillMessageSend, makeAddMessageResponse } from "./_attacks";
 import { READY_RUNTIME } from "./_runtime";
 import { makeTarget } from "./_targets";
@@ -21,6 +21,19 @@ function getMessageByText(page: Page, text: string): Locator {
   return page.getByTestId("message-list").getByText(text, { exact: true });
 }
 
+async function readMockMessages(page: Page): Promise<{
+  messages: BackendMessage[];
+  target_response_status: TargetResponseStatus;
+}> {
+  return page.evaluate(async (conversationId: string) => {
+    const response = await fetch(`/api/attacks/e2e-attack-001/messages?conversation_id=${conversationId}`);
+    if (!response.ok) {
+      throw new Error(`Message read failed: ${response.status}`);
+    }
+    return response.json();
+  }, MOCK_CONVERSATION_ID);
+}
+
 /** Intercept targets & attacks APIs so the chat flow can run without real keys. */
 async function mockBackendAPIs(page: Page) {
   // Accumulate messages so multi-turn tests get full history back
@@ -64,7 +77,7 @@ async function mockBackendAPIs(page: Page) {
         // Ignore parse errors
       }
 
-      const turnNumber = Math.floor(accumulatedMessages.length / 2) + 1;
+      const turnNumber = accumulatedMessages.length;
       const userMsg: BackendMessage = {
         turn_number: turnNumber,
         role: "user",
@@ -82,7 +95,7 @@ async function mockBackendAPIs(page: Page) {
         ],
       };
       const assistantMsg: BackendMessage = {
-        turn_number: turnNumber,
+        turn_number: turnNumber + 1,
         role: "assistant",
         created_at: new Date().toISOString(),
         message_pieces: [
@@ -103,7 +116,11 @@ async function mockBackendAPIs(page: Page) {
 
       await fulfillMessageSend(route, makeAddMessageResponse(
         "e2e-attack-001", MOCK_CONVERSATION_ID, [...accumulatedMessages],
-        null, {
+        {
+          response_error: "none",
+          request_turn_number: turnNumber,
+          response_turn_number: turnNumber + 1,
+        }, {
           target: {
             target_type: "OpenAIChatTarget", identifier_hash: "mock-openai-chat-hash",
             endpoint: "https://mock.openai.com", model_name: "gpt-4o-mock",
@@ -140,20 +157,9 @@ async function mockBackendAPIs(page: Page) {
   });
 }
 
-/** Save the mock target as the objective default, then open a new chat. */
+/** Select the mock target in a new chat. */
 async function activateMockTarget(page: Page) {
-  // Click the Registry button in the sidebar
-  await page.getByRole("button", { name: "Registry", exact: true }).click();
-  await expect(page.getByText("Target Registry")).toBeVisible({ timeout: 10000 });
-
-  // Set the objective default for this browser profile.
-  const objectiveDefault = page.getByRole("combobox", { name: "Default objective target", exact: true });
-  await expect(objectiveDefault).toBeVisible({ timeout: 5000 });
-  await objectiveDefault.selectOption({ index: 1 });
-
-  // Return to Chat view
-  await page.getByRole("button", { name: "Attacks", exact: true }).click();
-  await expect(page.getByRole("button", { name: "New attack", exact: true })).toBeVisible({ timeout: 5000 });
+  await selectChatTarget(page);
 }
 
 // ---------------------------------------------------------------------------
@@ -776,6 +782,9 @@ test.describe("Multi-turn conversation flow", () => {
     await expect(
       page.getByText("Mock response for: First turn"),
     ).toBeVisible({ timeout: 10000 });
+    expect((await readMockMessages(page)).target_response_status).toEqual({
+      response_error: "none", request_turn_number: 0, response_turn_number: 1,
+    });
 
     // Turn 2
     await input.fill("Second turn");
@@ -784,6 +793,9 @@ test.describe("Multi-turn conversation flow", () => {
     await expect(
       page.getByText("Mock response for: Second turn"),
     ).toBeVisible({ timeout: 10000 });
+    expect((await readMockMessages(page)).target_response_status).toEqual({
+      response_error: "none", request_turn_number: 2, response_turn_number: 3,
+    });
 
     // Turn 3
     await input.fill("Third turn");
@@ -798,10 +810,31 @@ test.describe("Multi-turn conversation flow", () => {
     await expect(getMessageByText(page, "Second turn")).toBeVisible();
     await expect(getMessageByText(page, "Third turn")).toBeVisible();
     expect(createdAttacks).toBe(1);
+    const messages = await readMockMessages(page);
+    expect(messages.target_response_status).toEqual({
+      response_error: "none", request_turn_number: 4, response_turn_number: 5,
+    });
+    expect(messages.messages.map((message: BackendMessage) => ({
+      role: message.role,
+      turn_number: message.turn_number,
+    }))).toEqual([
+      { role: "user", turn_number: 0 },
+      { role: "assistant", turn_number: 1 },
+      { role: "user", turn_number: 2 },
+      { role: "assistant", turn_number: 3 },
+      { role: "user", turn_number: 4 },
+      { role: "assistant", turn_number: 5 },
+    ]);
   });
 
   test("should reset conversation on New Chat and send again", async ({ page }) => {
     const input = page.getByTestId("chat-input");
+    let createdAttacks = 0;
+    page.on("request", (request: Request) => {
+      if (request.method() === "POST" && new URL(request.url()).pathname === "/api/attacks") {
+        createdAttacks += 1;
+      }
+    });
 
     // Send a message
     await input.fill("Before reset");
@@ -810,10 +843,16 @@ test.describe("Multi-turn conversation flow", () => {
     await expect(
       page.getByText("Mock response for: Before reset"),
     ).toBeVisible({ timeout: 10000 });
+    expect((await readMockMessages(page)).target_response_status).toEqual({
+      response_error: "none", request_turn_number: 0, response_turn_number: 1,
+    });
 
     // New Attack
     await page.getByRole("button", { name: "New attack", exact: true }).click();
     await expect(getMessageByText(page, "Before reset")).not.toBeVisible();
+    await expect(input).toHaveValue("");
+    await expect(page.getByRole("combobox", { name: "Chat target", exact: true }))
+      .toHaveValue("mock-openai-chat");
 
     // Send new message in fresh conversation
     await input.fill("After reset");
@@ -822,6 +861,10 @@ test.describe("Multi-turn conversation flow", () => {
     await expect(
       page.getByText("Mock response for: After reset"),
     ).toBeVisible({ timeout: 10000 });
+    expect((await readMockMessages(page)).target_response_status).toEqual({
+      response_error: "none", request_turn_number: 0, response_turn_number: 1,
+    });
+    expect(createdAttacks).toBe(2);
   });
 });
 
@@ -892,16 +935,7 @@ test.describe("Target type scenarios", () => {
       }
     });
 
-    await page.goto("/");
-    await page.getByRole("button", { name: "Registry", exact: true }).click();
-    await expect(page.getByText("dall-e-3", { exact: true })).toBeVisible({ timeout: 10000 });
-
-    // Save the DALL-E target as the objective default.
-    await page.getByRole("combobox", { name: "Default objective target", exact: true })
-      .selectOption("dall-e-image-gen");
-
-    // Navigate to chat
-    await page.getByRole("button", { name: "Attacks", exact: true }).click();
+    await selectChatTarget(page, "dall-e-image-gen");
     // Scope queries to the badge so we don't also match the (hidden)
     // copy of the target text that Fluent's Tooltip renders into the DOM.
     const badge = page.getByTestId("target-badge");

frontend/e2e/config.spec.ts

@@ -1,4 +1,4 @@
-import { test, expect, type Locator, type Page } from "./_fixtures";
+import { test, expect, selectChatTarget, type Locator, type Page } from "./_fixtures";
 import { makeTarget, type FlatTarget } from "./_targets";
 import { READY_RUNTIME } from "./_runtime";
 
@@ -24,6 +24,7 @@ const SAMPLE_TARGETS = [
     target_type: "OpenAIChatTarget",
     endpoint: "https://api.openai.com",
     model_name: "gpt-4o",
+    capabilities: { supports_multi_turn: true },
   },
   {
     target_registry_name: "target-image-1",
@@ -272,7 +273,7 @@ test.describe("Target Registry Page", () => {
     await expect(page.getByText(/error/i)).toBeVisible({ timeout: 10000 });
   });
 
-  test("should set a default objective target", async ({ page }) => {
+  test("should retain the adversarial default without an objective default control", async ({ page }) => {
     await page.route(/\/api\/targets/, async (route) => {
       await route.fulfill(mockTargetsList(SAMPLE_TARGETS));
     });
@@ -281,12 +282,12 @@ test.describe("Target Registry Page", () => {
     await expect(page.getByText("gpt-4o", { exact: true })).toBeVisible({ timeout: 10000 });
 
     const defaults = page.getByRole("region", { name: "Target defaults" });
-    const objectiveDefault = defaults.getByRole("combobox", { name: "Default objective target", exact: true });
-    await expect(objectiveDefault).toBeVisible();
-    await objectiveDefault.selectOption("target-chat-1");
+    await expect(defaults.getByRole("combobox", { name: "Default objective target", exact: true })).toHaveCount(0);
+    const adversarialDefault = defaults.getByRole("combobox", { name: "Default adversarial target", exact: true });
+    await adversarialDefault.selectOption("target-chat-1");
 
-    await expect(page.getByTestId("target-row-target-chat-1").getByText("Objective", { exact: true })).toBeVisible();
-    await expect(objectiveDefault).toHaveValue("target-chat-1");
+    await expect(page.getByTestId("target-row-target-chat-1").getByText("Adversarial", { exact: true })).toBeVisible();
+    await expect(adversarialDefault).toHaveValue("target-chat-1");
   });
 
   test("should open create target dialog", async ({ page }) => {
@@ -671,20 +672,16 @@ test.describe("Responsive Target Registry", () => {
 });
 
 test.describe("Target Config ↔ Chat Navigation", () => {
-  test("should preselect the objective default in a new chat", async ({ page }) => {
+  test("should select a target in a new chat without a Registry objective default", async ({ page }) => {
     await page.route(/\/api\/targets/, async (route) => {
       await route.fulfill(mockTargetsList(SAMPLE_TARGETS));
     });
 
     await goToTargets(page);
     await expect(page.getByText("gpt-4o", { exact: true })).toBeVisible({ timeout: 10000 });
 
-    // Set the first target as the objective default.
-    await page.getByRole("combobox", { name: "Default objective target", exact: true }).selectOption({ index: 1 });
-
-    // Navigate back to chat
-    await page.getByRole("button", { name: "Attacks", exact: true }).click();
-    await expect(page.getByRole("button", { name: "New attack", exact: true })).toBeVisible();
+    await expect(page.getByRole("combobox", { name: "Default objective target", exact: true })).toHaveCount(0);
+    await selectChatTarget(page, "target-chat-1");
 
     // Chat should show the selected target type. Scope to the badge to
     // avoid matching the (hidden) tooltip copy of the same text.
@@ -706,20 +703,9 @@ test.describe("Target Config ↔ Chat Navigation", () => {
     await draft.fill("Draft without a target");
     await expect(page.getByRole("button", { name: "Send message" })).toBeDisabled();
 
-    // Go to targets, set a target
-    await page.getByRole("button", { name: "Registry", exact: true }).click();
-    await expect(page.getByText("gpt-4o", { exact: true })).toBeVisible({ timeout: 10000 });
-    await page.getByRole("combobox", { name: "Default objective target", exact: true }).selectOption({ index: 1 });
-
-    // Returning retains the original draft; a new attack adopts the new default.
-    await page.getByRole("button", { name: "Attacks", exact: true }).click();
-    await expect(draft).toHaveValue("Draft without a target");
-    await expect(page.getByRole("button", { name: "Send message", exact: true })).toBeDisabled();
-    await page.getByRole("button", { name: "New attack", exact: true }).click();
+    await page.getByRole("combobox", { name: "Chat target", exact: true }).selectOption("target-chat-1");
     const input = page.getByRole("textbox", { name: "Type prompt here", exact: true });
-    await expect(input).toHaveValue("");
-    await expect(page.getByRole("combobox", { name: "Chat target", exact: true })).toHaveValue("target-chat-1");
-    await input.fill("Hello");
+    await expect(input).toHaveValue("Draft without a target");
     await expect(page.getByRole("button", { name: "Send message", exact: true })).toBeEnabled();
   });
 });