// frontend/src/shell/SteerInput.test.tsx
import { act, render, screen, waitFor } from "@testing-library/react";
import userEvent from "@testing-library/user-event";
import { http, HttpResponse } from "msw";
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import { server } from "../test/msw";
import { canonicalWorkspaceFixture, workspaceRevisionFixture, workspaceSummaryFixture } from "../test/workspace-fixtures";
import { useSessionStore } from "../store/sessionStore";
import { workspacePreferences } from "../workspaces/preferences";
import { ComposerFooter, ContextGauge, SteerInput } from "./SteerInput";
import { setAuthState } from "../auth/authState";

const userA = {
  issuer: "local", subject: "user-a", roles: ["user"] as const,
  permissions: ["session.use"], isAdmin: false, csrfToken: "a".repeat(43), session: null,
};

beforeEach(() => {
  localStorage.clear();
  setAuthState(userA);
  server.use(
    http.post("/api/sessions/:id/steer", () =>
      new HttpResponse(null, { status: 204 }),
    ),
  );
});

test("new sessions send the ephemeral workspace, model, provider, and thinking", async () => {
  let body: unknown;
  workspacePreferences.save({
    workspaceId: "psd-clinical", provider: "zai", model: "glm-5.2", thinking: "high",
  });
  server.use(
    http.get("/api/workspaces", () => HttpResponse.json([{
      ...workspaceSummaryFixture("psd-clinical", {
        displayName: "PSD Clinical",
        revision: { id: "psd-clinical", commit: "a".repeat(40), blob: "b".repeat(40), snapshotPath: "/snapshot" },
      }),
    }])),
    http.get("/api/workspaces/psd-clinical", () => HttpResponse.json({
      workspace: canonicalWorkspaceFixture("psd-clinical"),
      revision: { id: "psd-clinical", commit: "a".repeat(40), blob: "b".repeat(40), snapshotPath: "/snapshot" },
    })),
    http.post("/api/sessions", async ({ request }) => {
      body = await request.json();
      return HttpResponse.json({ id: "s1" });
    }),
  );
  render(<SteerInput sessionId={null} />);

  await userEvent.type(screen.getByRole("textbox", { name: /new question/i }), "q");
  await userEvent.click(screen.getByRole("button", { name: /send/i }));

  await waitFor(() => expect(body).toEqual({
    question: "q", workspaceId: "psd-clinical", provider: "zai", model: "glm-5.2", thinking: "high",
  }));
});

test("renders a text input and submit button", () => {
  render(<SteerInput sessionId="s1" />);
  expect(screen.getByRole("textbox")).toBeInTheDocument();
  expect(screen.getByRole("button", { name: /invia|send|steer/i })).toBeInTheDocument();
});

test("submitting typed text POSTs to /steer and clears the input", async () => {
  let captured: unknown = null;
  server.use(
    http.post("/api/sessions/:id/steer", async ({ request, params }) => {
      captured = { id: params.id, body: await request.json() };
      return new HttpResponse(null, { status: 204 });
    }),
  );
  render(<SteerInput sessionId="s1" />);
  const input = screen.getByRole("textbox");
  await userEvent.type(input, "redirect to plan B");
  await userEvent.click(screen.getByRole("button", { name: /invia|send|steer/i }));
  await waitFor(() => {
    expect(captured).toEqual({ id: "s1", body: { text: "redirect to plan B" } });
  });
  expect(input).toHaveValue("");
});

test("a delayed steer from user A cannot mutate user B's store or composer", async () => {
  let release!: () => void;
  let started!: () => void;
  let settled!: () => void;
  const held = new Promise<void>((resolve) => { release = resolve; });
  const requestStarted = new Promise<void>((resolve) => { started = resolve; });
  const requestSettled = new Promise<void>((resolve) => { settled = resolve; });
  server.use(http.post("/api/sessions/:id/steer", async () => {
    started();
    try {
      await held;
      return new HttpResponse(null, { status: 204 });
    } finally {
      settled();
    }
  }));
  setAuthState(userA);
  const view = render(<SteerInput sessionId="s1" />);
  const input = screen.getByRole("textbox");
  await userEvent.type(input, "A-only steer");
  await userEvent.click(screen.getByRole("button", { name: /send/i }));
  await requestStarted;

  act(() => setAuthState({ ...userA, subject: "user-b", csrfToken: "b".repeat(43) }));
  act(() => useSessionStore.getState().setLastUserEntry({ kind: "input", text: "B-entry" }));
  release();
  await act(async () => { await requestSettled; });

  expect(useSessionStore.getState().lastUserEntry).toEqual({ kind: "input", text: "B-entry" });
  expect(input).toHaveValue("A-only steer");
  view.unmount();
});

test("a held steer for s1 cannot complete into the active s2 operation scope", async () => {
  let release!: () => void;
  let started!: () => void;
  let settled!: () => void;
  const held = new Promise<void>((resolve) => { release = resolve; });
  const requestStarted = new Promise<void>((resolve) => { started = resolve; });
  const requestSettled = new Promise<void>((resolve) => { settled = resolve; });
  server.use(http.post("/api/sessions/s1/steer", async () => {
    started();
    try {
      await held;
      return new HttpResponse(null, { status: 204 });
    } finally {
      settled();
    }
  }));

  const view = render(<SteerInput sessionId="s1" />);
  const input = screen.getByRole("textbox");
  await userEvent.type(input, "Keep s1 isolated");
  await userEvent.click(screen.getByRole("button", { name: /invia|send|steer/i }));
  await requestStarted;

  view.rerender(<SteerInput sessionId="s2" />);
  act(() => useSessionStore.getState().setLastUserEntry({ kind: "input", text: "s2 owned" }));
  release();
  await act(async () => { await requestSettled; });

  expect(useSessionStore.getState().lastUserEntry).toEqual({ kind: "input", text: "s2 owned" });
  expect(input).toHaveValue("Keep s1 isolated");
});

test("a settings preflight from user A prevents session POST after user B logs in", async () => {
  let releaseSettings!: () => void;
  let settingsStarted!: () => void;
  let settingsSettled!: () => void;
  let sessionPosts = 0;
  const settingsGate = new Promise<void>((resolve) => { releaseSettings = resolve; });
  const started = new Promise<void>((resolve) => { settingsStarted = resolve; });
  const settled = new Promise<void>((resolve) => { settingsSettled = resolve; });
  server.use(
    http.get("/api/settings", async () => {
      settingsStarted();
      try {
        await settingsGate;
        return HttpResponse.json({ workspace: "psd-clinical", provider: "zai", model: "glm-5.2", thinking: "low" });
      } finally {
        settingsSettled();
      }
    }),
    http.post("/api/sessions", () => {
      sessionPosts += 1;
      return HttpResponse.json({ id: "a-session" });
    }),
  );
  const userB = { ...userA, subject: "user-b", csrfToken: "b".repeat(43) };
  const view = render(<SteerInput sessionId={null} />);
  const input = screen.getByRole("textbox", { name: /new question/i });
  await userEvent.type(input, "A-only question");
  await userEvent.click(screen.getByRole("button", { name: /send/i }));
  await started;

  act(() => setAuthState(userB));
  act(() => useSessionStore.getState().setLastUserEntry({ kind: "input", text: "B-entry" }));
  releaseSettings();
  await act(async () => { await settled; });

  expect(sessionPosts).toBe(0);
  expect(useSessionStore.getState().lastUserEntry).toEqual({ kind: "input", text: "B-entry" });
  view.unmount();
});

test("a workspace-policy preflight from user A prevents session POST after user B logs in", async () => {
  workspacePreferences.save({
    workspaceId: "psd-clinical", provider: "zai", model: "glm-5.2", thinking: "low",
  });
  let releaseWorkspaces!: () => void;
  let workspacesStarted!: () => void;
  let workspacesSettled!: () => void;
  let sessionPosts = 0;
  const workspacesGate = new Promise<void>((resolve) => { releaseWorkspaces = resolve; });
  const started = new Promise<void>((resolve) => { workspacesStarted = resolve; });
  const settled = new Promise<void>((resolve) => { workspacesSettled = resolve; });
  server.use(
    http.get("/api/workspaces", () => HttpResponse.json([{
      ...workspaceSummaryFixture("psd-clinical", {
        displayName: "PSD Clinical",
        revision: workspaceRevisionFixture("psd-clinical"),
      }),
    }])),
    http.get("/api/workspaces/psd-clinical", async () => {
      workspacesStarted();
      try {
        await workspacesGate;
        return HttpResponse.json({
          workspace: canonicalWorkspaceFixture("psd-clinical"),
          revision: workspaceRevisionFixture("psd-clinical"),
        });
      } finally {
        workspacesSettled();
      }
    }),
    http.post("/api/sessions", () => {
      sessionPosts += 1;
      return HttpResponse.json({ id: "a-session" });
    }),
  );
  const userB = { ...userA, subject: "user-b", csrfToken: "b".repeat(43) };
  const view = render(<SteerInput sessionId={null} />);
  const input = screen.getByRole("textbox", { name: /new question/i });
  await userEvent.type(input, "A-policy-question");
  await userEvent.click(screen.getByRole("button", { name: /send/i }));
  await started;

  act(() => setAuthState(userB));
  act(() => useSessionStore.getState().setLastUserEntry({ kind: "input", text: "B-entry" }));
  releaseWorkspaces();
  await act(async () => { await settled; });

  expect(sessionPosts).toBe(0);
  expect(useSessionStore.getState().lastUserEntry).toEqual({ kind: "input", text: "B-entry" });
  view.unmount();
});

test("pressing Enter in the input submits the steer", async () => {
  let captured: unknown = null;
  server.use(
    http.post("/api/sessions/:id/steer", async ({ request }) => {
      captured = await request.json();
      return new HttpResponse(null, { status: 204 });
    }),
  );
  render(<SteerInput sessionId="s1" />);
  const input = screen.getByRole("textbox");
  await userEvent.type(input, "use approach X{Enter}");
  await waitFor(() => {
    expect(captured).toEqual({ text: "use approach X" });
  });
});

test("does not POST when input is empty", async () => {
  let called = false;
  server.use(
    http.post("/api/sessions/:id/steer", () => {
      called = true;
      return new HttpResponse(null, { status: 204 });
    }),
  );
  render(<SteerInput sessionId="s1" />);
  await userEvent.click(screen.getByRole("button", { name: /invia|send|steer/i }));
  // small wait to ensure the call didn't go through
  await new Promise((r) => setTimeout(r, 50));
  expect(called).toBe(false);
});


test("keeps the new-question composer white by default", () => {
  render(<SteerInput sessionId={null} />);
  const input = screen.getByRole("textbox", { name: /new question/i });
  expect(input).not.toHaveAttribute("data-awaiting-input");
  expect(input).not.toHaveClass("thot-awaiting-input");
});

test("marks the composer as awaiting input only when requested", () => {
  render(<SteerInput sessionId={null} awaitingInput />);
  const input = screen.getByRole("textbox", { name: /new question/i });
  expect(input).toHaveAttribute("data-awaiting-input", "true");
  expect(input).toHaveClass("thot-awaiting-input");
});

test("the context gauge uses green, yellow, and red at the requested thresholds", () => {
  const { rerender } = render(<ContextGauge pct={0.699} />);
  expect(screen.getByLabelText("Context usage 70%")).toHaveAttribute("data-level", "green");

  rerender(<ContextGauge pct={0.7} />);
  expect(screen.getByLabelText("Context usage 70%")).toHaveAttribute("data-level", "yellow");

  rerender(<ContextGauge pct={0.85} />);
  expect(screen.getByLabelText("Context usage 85%")).toHaveAttribute("data-level", "yellow");

  rerender(<ContextGauge pct={0.851} />);
  expect(screen.getByLabelText("Context usage 85%")).toHaveAttribute("data-level", "red");
});

test("footer shows cumulative k-token counters after workspace and context gauge after thinking", async () => {
  server.use(
    http.get("/api/settings", () => HttpResponse.json({
      workspace: "psd", provider: "zai", model: "glm-5.2", thinking: "medium",
    })),
    http.get("/api/workspaces", () => HttpResponse.json([{
      ...workspaceSummaryFixture("psd", {
        displayName: "PSD",
        revision: { id: "psd", commit: "a".repeat(40), blob: "b".repeat(40), snapshotPath: "/snapshot" },
      }),
    }])),
    http.get("/api/workspaces/psd", () => HttpResponse.json({
      workspace: canonicalWorkspaceFixture("psd"),
      revision: { id: "psd", commit: "a".repeat(40), blob: "b".repeat(40), snapshotPath: "/snapshot" },
    })),
    http.get("/api/models", () => HttpResponse.json({
      models: [{ provider: "zai", id: "glm-5.2", name: "GLM-5.2", reasoning: true }],
    })),
  );
  useSessionStore.getState().resetSession();
  useSessionStore.getState().applyEvent({
    type: "usage",
    usage: {
      input: 110_348,
      cacheRead: 633_344,
      output: 33_652,
      totalTokens: 55_935,
      contextWindow: 200_000,
    },
  });
  const client = new QueryClient({ defaultOptions: { queries: { retry: false } } });
  render(<QueryClientProvider client={client}><ComposerFooter /></QueryClientProvider>);

  const counters = screen.getByText("110k/633k/34k");
  const workspace = await screen.findByRole("combobox", { name: "Workspace" });
  const gauge = screen.getByLabelText("Context usage 28%");
  const thinking = await screen.findByRole("combobox", { name: "Thinking level" });
  expect(workspace.compareDocumentPosition(counters) & Node.DOCUMENT_POSITION_FOLLOWING).toBeTruthy();
  expect(thinking.compareDocumentPosition(gauge) & Node.DOCUMENT_POSITION_FOLLOWING).toBeTruthy();
});

test("footer limits model choices to the selected workspace policy", async () => {
  server.use(
    http.get("/api/settings", () => HttpResponse.json({
      workspace: "psd-clinical", provider: "zai", model: "glm-5.2", thinking: "medium",
    })),
    http.get("/api/workspaces", () => HttpResponse.json([{
      ...workspaceSummaryFixture("psd-clinical", {
        displayName: "PSD Clinical",
        revision: { id: "psd-clinical", commit: "a".repeat(40), blob: "b".repeat(40), snapshotPath: "/snapshot" },
      }),
    }])),
    http.get("/api/workspaces/psd-clinical", () => HttpResponse.json({
      workspace: canonicalWorkspaceFixture("psd-clinical"),
      revision: { id: "psd-clinical", commit: "a".repeat(40), blob: "b".repeat(40), snapshotPath: "/snapshot" },
    })),
    http.get("/api/models", () => HttpResponse.json({ models: [
      { provider: "zai", id: "glm-5.2", name: "GLM-5.2", reasoning: true },
      { provider: "deepseek", id: "deepseek-v4-pro", name: "DeepSeek V4 Pro", reasoning: true },
    ] })),
  );
  const client = new QueryClient({ defaultOptions: { queries: { retry: false } } });
  render(<QueryClientProvider client={client}><ComposerFooter /></QueryClientProvider>);

  const selector = await screen.findByRole("combobox", { name: "Model" });
  await waitFor(() => expect(selector).toHaveTextContent("GLM-5.2"));
  await waitFor(() => expect(selector).not.toHaveTextContent("DeepSeek V4 Pro"));
});

test("switching workspaces replaces an out-of-policy model before session creation", async () => {
  let body: unknown;
  workspacePreferences.save({
    workspaceId: "research", provider: "deepseek", model: "deepseek-v4-pro", thinking: "medium",
  });
  const revision = (id: string) => ({
    id, commit: "a".repeat(40), blob: "b".repeat(40), snapshotPath: "/snapshot",
  });
  server.use(
    http.get("/api/settings", () => HttpResponse.json({
      workspace: "research", provider: "deepseek", model: "deepseek-v4-pro", thinking: "medium",
    })),
    http.get("/api/workspaces", () => HttpResponse.json([
      workspaceSummaryFixture("research", { displayName: "Research", revision: revision("research") }),
      workspaceSummaryFixture("psd-clinical", { displayName: "PSD Clinical", revision: revision("psd-clinical") }),
    ])),
    http.get("/api/workspaces/research", () => HttpResponse.json({
      workspace: canonicalWorkspaceFixture("research", ["deepseek/deepseek-v4-pro"]),
      revision: revision("research"),
    })),
    http.get("/api/workspaces/psd-clinical", () => HttpResponse.json({
      workspace: canonicalWorkspaceFixture("psd-clinical", ["zai/glm-5.2"], "zai/glm-5.2"),
      revision: revision("psd-clinical"),
    })),
    http.get("/api/models", () => HttpResponse.json({ models: [
      { provider: "zai", id: "glm-5.2", name: "GLM-5.2", reasoning: true },
      { provider: "deepseek", id: "deepseek-v4-pro", name: "DeepSeek V4 Pro", reasoning: true },
    ] })),
    http.post("/api/sessions", async ({ request }) => {
      body = await request.json();
      return HttpResponse.json({ id: "s1" });
    }),
  );
  const client = new QueryClient({ defaultOptions: { queries: { retry: false } } });
  render(<QueryClientProvider client={client}><ComposerFooter /><SteerInput sessionId={null} /></QueryClientProvider>);

  const workspaceSelector = await screen.findByRole("combobox", { name: "Workspace" });
  await waitFor(() => expect(workspaceSelector).toHaveTextContent("psd-clinical"));
  await userEvent.selectOptions(workspaceSelector, "psd-clinical");
  await waitFor(() => expect(screen.getByRole("combobox", { name: "Model" })).toHaveValue("glm-5.2"));
  expect(screen.getByRole("combobox", { name: "Model" })).not.toHaveTextContent("DeepSeek V4 Pro");

  await userEvent.type(screen.getByRole("textbox", { name: /new question/i }), "q");
  await userEvent.click(screen.getByRole("button", { name: /send/i }));

  await waitFor(() => expect(body).toEqual({
    question: "q", workspaceId: "psd-clinical", provider: "zai", model: "glm-5.2", thinking: "medium",
  }));
});

test("immediate submit waits for a switched workspace policy before creating a session", async () => {
  let body: unknown;
  let releasePolicy!: () => void;
  let policyRequestStarted = false;
  const policyMayFinish = new Promise<void>((resolve) => { releasePolicy = resolve; });
  workspacePreferences.save({
    workspaceId: "research", provider: "deepseek", model: "deepseek-v4-pro", thinking: "medium",
  });
  const revision = (id: string) => ({
    id, commit: "a".repeat(40), blob: "b".repeat(40), snapshotPath: "/snapshot",
  });
  server.use(
    http.get("/api/settings", () => HttpResponse.json({ workspace: "research" })),
    http.get("/api/workspaces", () => HttpResponse.json([
      workspaceSummaryFixture("research", { displayName: "Research", revision: revision("research") }),
      workspaceSummaryFixture("psd-clinical", { displayName: "PSD Clinical", revision: revision("psd-clinical") }),
    ])),
    http.get("/api/workspaces/research", () => HttpResponse.json({
      workspace: canonicalWorkspaceFixture("research", ["deepseek/deepseek-v4-pro"]), revision: revision("research"),
    })),
    http.get("/api/workspaces/psd-clinical", async () => {
      policyRequestStarted = true;
      await policyMayFinish;
      return HttpResponse.json({
        workspace: canonicalWorkspaceFixture("psd-clinical", ["zai/glm-5.2"], "zai/glm-5.2"),
        revision: revision("psd-clinical"),
      });
    }),
    http.get("/api/models", () => HttpResponse.json({ models: [
      { provider: "zai", id: "glm-5.2", name: "GLM-5.2", reasoning: true },
      { provider: "deepseek", id: "deepseek-v4-pro", name: "DeepSeek V4 Pro", reasoning: true },
    ] })),
    http.post("/api/sessions", async ({ request }) => {
      body = await request.json();
      return HttpResponse.json({ id: "s1" });
    }),
  );
  const client = new QueryClient({ defaultOptions: { queries: { retry: false } } });
  render(<QueryClientProvider client={client}><ComposerFooter /><SteerInput sessionId={null} /></QueryClientProvider>);

  const workspaceSelector = await screen.findByRole("combobox", { name: "Workspace" });
  await waitFor(() => expect(workspaceSelector).toHaveTextContent("psd-clinical"));
  await userEvent.selectOptions(workspaceSelector, "psd-clinical");
  await waitFor(() => expect(policyRequestStarted).toBe(true));
  await userEvent.type(screen.getByRole("textbox", { name: /new question/i }), "q");
  await userEvent.click(screen.getByRole("button", { name: /send/i }));

  expect(body).toBeUndefined();
  expect(screen.getByRole("button", { name: /send/i })).toBeDisabled();
  releasePolicy();

  await waitFor(() => expect(body).toEqual({
    question: "q", workspaceId: "psd-clinical", provider: "zai", model: "glm-5.2", thinking: "medium",
  }));
});

test("initial restored workspace waits for its delayed policy before creating a session", async () => {
  let body: unknown;
  let releasePolicy!: () => void;
  let policyRequestStarted = false;
  const policyMayFinish = new Promise<void>((resolve) => { releasePolicy = resolve; });
  workspacePreferences.save({
    workspaceId: "psd-clinical", provider: "deepseek", model: "deepseek-v4-pro", thinking: "medium",
  });
  const revision = (id: string) => ({
    id, commit: "a".repeat(40), blob: "b".repeat(40), snapshotPath: "/snapshot",
  });
  server.use(
    http.get("/api/settings", () => HttpResponse.json({ workspace: "psd-clinical" })),
    http.get("/api/workspaces", () => HttpResponse.json([
      workspaceSummaryFixture("psd-clinical", { displayName: "PSD Clinical", revision: revision("psd-clinical") }),
    ])),
    http.get("/api/workspaces/psd-clinical", async () => {
      policyRequestStarted = true;
      await policyMayFinish;
      return HttpResponse.json({
        workspace: canonicalWorkspaceFixture("psd-clinical", ["zai/glm-5.2"], "zai/glm-5.2"),
        revision: revision("psd-clinical"),
      });
    }),
    http.get("/api/models", () => HttpResponse.json({ models: [
      { provider: "zai", id: "glm-5.2", name: "GLM-5.2", reasoning: true },
      { provider: "deepseek", id: "deepseek-v4-pro", name: "DeepSeek V4 Pro", reasoning: true },
    ] })),
    http.post("/api/sessions", async ({ request }) => {
      body = await request.json();
      return HttpResponse.json({ id: "s1" });
    }),
  );
  const client = new QueryClient({ defaultOptions: { queries: { retry: false } } });
  render(<QueryClientProvider client={client}><ComposerFooter /><SteerInput sessionId={null} /></QueryClientProvider>);

  await waitFor(() => expect(policyRequestStarted).toBe(true));
  await userEvent.type(screen.getByRole("textbox", { name: /new question/i }), "q");
  await userEvent.click(screen.getByRole("button", { name: /send/i }));

  expect(body).toBeUndefined();
  expect(screen.getByRole("button", { name: /send/i })).toBeDisabled();
  releasePolicy();

  await waitFor(() => expect(body).toEqual({
    question: "q", workspaceId: "psd-clinical", provider: "zai", model: "glm-5.2", thinking: "medium",
  }));
});

test("initial submit rejects a workspace summary that omits the canonical revision", async () => {
  let body: unknown;
  let failure: string | undefined;
  workspacePreferences.save({
    workspaceId: "broken-workspace", provider: "zai", model: "glm-5.2", thinking: "medium",
  });
  server.use(
    http.get("/api/settings", () => HttpResponse.json({ workspace: "broken-workspace" })),
    http.get("/api/workspaces", () => HttpResponse.json([{
      ...workspaceSummaryFixture("broken-workspace", {
        displayName: "Broken workspace",
        configurationState: "configuration_required",
      }),
    }])),
    http.get("/api/models", () => HttpResponse.json({ models: [
      { provider: "zai", id: "glm-5.2", name: "GLM-5.2", reasoning: true },
    ] })),
    http.post("/api/sessions", async ({ request }) => {
      body = await request.json();
      return HttpResponse.json({ id: "s1" });
    }),
  );
  const client = new QueryClient({ defaultOptions: { queries: { retry: false } } });
  render(<QueryClientProvider client={client}><ComposerFooter /><SteerInput sessionId={null} onSessionCreateFailed={(message) => { failure = message; }} /></QueryClientProvider>);

  await userEvent.type(screen.getByRole("textbox", { name: /new question/i }), "q");
  await userEvent.click(screen.getByRole("button", { name: /send/i }));

  await waitFor(() => expect(failure).toBe("Could not load workspace registry. Please retry."));
  expect(body).toBeUndefined();
});

test("failed workspace summaries block creation and report a safe error", async () => {
  let body: unknown;
  let failure: string | undefined;
  let summaryRequestFailed = false;
  workspacePreferences.save({
    workspaceId: "psd-clinical", provider: "zai", model: "glm-5.2", thinking: "medium",
  });
  server.use(
    http.get("/api/settings", () => HttpResponse.json({ workspace: "psd-clinical" })),
    http.get("/api/workspaces", () => {
      summaryRequestFailed = true;
      return new HttpResponse(null, { status: 503 });
    }),
    http.get("/api/models", () => HttpResponse.json({ models: [
      { provider: "zai", id: "glm-5.2", name: "GLM-5.2", reasoning: true },
    ] })),
    http.post("/api/sessions", async ({ request }) => {
      body = await request.json();
      return HttpResponse.json({ id: "s1" });
    }),
  );
  const client = new QueryClient({ defaultOptions: { queries: { retry: false } } });
  render(
    <QueryClientProvider client={client}>
      <ComposerFooter />
      <SteerInput sessionId={null} onSessionCreateFailed={(message) => { failure = message; }} />
    </QueryClientProvider>,
  );

  await waitFor(() => expect(summaryRequestFailed).toBe(true));
  await waitFor(() => expect(client.getQueryState(["workspaces"])?.status).toBe("error"));
  await userEvent.type(screen.getByRole("textbox", { name: /new question/i }), "q");
  await userEvent.click(screen.getByRole("button", { name: /send/i }));

  await waitFor(() => expect(failure).toBe("Could not load workspace registry. Please retry."));
  expect(body).toBeUndefined();
});

test("submit follows a rapid workspace switch instead of waiting for an abandoned policy", async () => {
  let body: unknown;
  let releaseC!: () => void;
  let bPolicyRequestStarted = false;
  let cPolicyRequestStarted = false;
  const cPolicyMayFinish = new Promise<void>((resolve) => { releaseC = resolve; });
  workspacePreferences.save({
    workspaceId: "research", provider: "deepseek", model: "deepseek-v4-pro", thinking: "medium",
  });
  const revision = (id: string) => ({
    id, commit: "a".repeat(40), blob: "b".repeat(40), snapshotPath: "/snapshot",
  });
  server.use(
    http.get("/api/settings", () => HttpResponse.json({ workspace: "research" })),
    http.get("/api/workspaces", () => HttpResponse.json([
      workspaceSummaryFixture("research", { displayName: "Research", revision: revision("research") }),
      workspaceSummaryFixture("workspace-b", { displayName: "Workspace B", revision: revision("workspace-b") }),
      workspaceSummaryFixture("workspace-c", { displayName: "Workspace C", revision: revision("workspace-c") }),
    ])),
    http.get("/api/workspaces/research", () => HttpResponse.json({
      workspace: canonicalWorkspaceFixture("research", ["deepseek/deepseek-v4-pro"]), revision: revision("research"),
    })),
    http.get("/api/workspaces/workspace-b", async () => {
      bPolicyRequestStarted = true;
      await new Promise(() => undefined);
      return HttpResponse.json({});
    }),
    http.get("/api/workspaces/workspace-c", async () => {
      cPolicyRequestStarted = true;
      await cPolicyMayFinish;
      return HttpResponse.json({
        workspace: canonicalWorkspaceFixture("workspace-c", ["zai/glm-5.2"], "zai/glm-5.2"),
        revision: revision("workspace-c"),
      });
    }),
    http.get("/api/models", () => HttpResponse.json({ models: [
      { provider: "zai", id: "glm-5.2", name: "GLM-5.2", reasoning: true },
      { provider: "deepseek", id: "deepseek-v4-pro", name: "DeepSeek V4 Pro", reasoning: true },
    ] })),
    http.post("/api/sessions", async ({ request }) => {
      body = await request.json();
      return HttpResponse.json({ id: "s1" });
    }),
  );
  const client = new QueryClient({ defaultOptions: { queries: { retry: false } } });
  render(<QueryClientProvider client={client}><ComposerFooter /><SteerInput sessionId={null} /></QueryClientProvider>);

  const workspaceSelector = await screen.findByRole("combobox", { name: "Workspace" });
  await waitFor(() => expect(screen.getByRole("option", { name: "workspace-b" })).toBeInTheDocument());
  await userEvent.selectOptions(workspaceSelector, "workspace-b");
  await waitFor(() => expect(bPolicyRequestStarted).toBe(true));
  await userEvent.type(screen.getByRole("textbox", { name: /new question/i }), "q");
  await userEvent.click(screen.getByRole("button", { name: /send/i }));
  await userEvent.selectOptions(workspaceSelector, "workspace-c");
  await waitFor(() => expect(cPolicyRequestStarted).toBe(true));

  expect(body).toBeUndefined();
  releaseC();

  await waitFor(() => expect(body).toEqual({
    question: "q", workspaceId: "workspace-c", provider: "zai", model: "glm-5.2", thinking: "medium",
  }));
});

test("pulses the stop dot only while the harness is working", () => {
  const { rerender } = render(<SteerInput sessionId="s1" working />);
  const dot = () =>
    screen.getByRole("button", { name: /stop and save session/i }).querySelector("span");
  expect(dot()).toHaveClass("thot-pulse");
  rerender(<SteerInput sessionId="s1" working={false} />);
  expect(dot()).not.toHaveClass("thot-pulse");
});