import { beforeEach, describe, expect, it, vi } from 'vitest';
import {
  createImageWorkspaceOperationId,
  createImageWorkspaceProject,
  deleteImageWorkspaceProject,
  fetchImageWorkspace,
  fetchImageWorkspaceProject,
  ImageWorkspaceApiError,
  openImageWorkspaceEvents,
  renameImageWorkspaceProject,
  submitImageWorkspaceCommand,
} from '@/lib/image-workspace';
import { useImageWorkspaceStore } from '@/stores/image-workspace';
import {
  designBootstrapFixture,
  designFormFixture,
  designQuoteFixture,
  designSummaryFixture,
  designWorkspaceFixture,
} from '../fixtures/design-workspace-v2';

vi.mock('@/lib/image-workspace', async (importOriginal) => {
  const original = await importOriginal<typeof import('@/lib/image-workspace')>();
  return {
    ...original,
    createImageWorkspaceOperationId: vi.fn(),
    createImageWorkspaceProject: vi.fn(),
    deleteImageWorkspaceProject: vi.fn(),
    fetchImageWorkspace: vi.fn(),
    fetchImageWorkspaceProject: vi.fn(),
    openImageWorkspaceEvents: vi.fn(),
    renameImageWorkspaceProject: vi.fn(),
    submitImageWorkspaceCommand: vi.fn(),
  };
});

vi.mock('@/lib/host-api', async (importOriginal) => {
  const original = await importOriginal<typeof import('@/lib/host-api')>();
  return { ...original, setDesktopBackgroundLease: vi.fn() };
});

vi.mock('@/stores/auth', () => ({
  useAuthStore: {
    getState: () => ({ isAuthenticated: () => true }),
  },
}));

const operationIdMock = vi.mocked(createImageWorkspaceOperationId);
const createProjectMock = vi.mocked(createImageWorkspaceProject);
const deleteProjectMock = vi.mocked(deleteImageWorkspaceProject);
const fetchBootstrapMock = vi.mocked(fetchImageWorkspace);
const fetchProjectMock = vi.mocked(fetchImageWorkspaceProject);
const openEventsMock = vi.mocked(openImageWorkspaceEvents);
const renameProjectMock = vi.mocked(renameImageWorkspaceProject);
const submitCommandMock = vi.mocked(submitImageWorkspaceCommand);

class FakeEventSource {
  onopen: ((event: Event) => void) | null = null;
  onerror: ((event: Event) => void) | null = null;
  readonly listeners = new Map<string, Set<(event: Event) => void>>();
  close = vi.fn();

  addEventListener(type: string, listener: EventListenerOrEventListenerObject): void {
    const callback = typeof listener === 'function'
      ? listener
      : (event: Event) => listener.handleEvent(event);
    const listeners = this.listeners.get(type) ?? new Set<(event: Event) => void>();
    listeners.add(callback);
    this.listeners.set(type, listeners);
  }

  emit(type: string, payload: unknown): void {
    const event = new MessageEvent(type, { data: JSON.stringify(payload) });
    this.listeners.get(type)?.forEach((listener) => listener(event));
  }
}

function deferred<T>() {
  let resolve!: (value: T) => void;
  let reject!: (reason?: unknown) => void;
  const promise = new Promise<T>((resolvePromise, rejectPromise) => {
    resolve = resolvePromise;
    reject = rejectPromise;
  });
  return { promise, reject, resolve };
}

async function loadedStore(eventSource = new FakeEventSource()) {
  openEventsMock.mockResolvedValue(eventSource as unknown as EventSource);
  await useImageWorkspaceStore.getState().load();
  await vi.waitFor(() => expect(openEventsMock).toHaveBeenCalled());
  return eventSource;
}

describe('V2 Living Form store', () => {
  beforeEach(() => {
    vi.clearAllMocks();
    useImageWorkspaceStore.getState().reset();
    const workspace = designWorkspaceFixture();
    fetchBootstrapMock.mockResolvedValue(designBootstrapFixture());
    fetchProjectMock.mockResolvedValue(workspace);
    createProjectMock.mockResolvedValue(workspace);
    renameProjectMock.mockResolvedValue(workspace);
    deleteProjectMock.mockResolvedValue({ workspaceId: 'workspace-1', deleted: true });
    operationIdMock.mockReturnValue('operation-1');
    submitCommandMock.mockResolvedValue({
      clientOperationId: 'operation-1',
      runId: 'run-1',
      workspace,
    });
  });

  it('loads one canonical Workspace and opens its resumable event stream', async () => {
    await loadedStore();

    expect(useImageWorkspaceStore.getState()).toMatchObject({
      status: 'ready',
      activeWorkspaceId: 'workspace-1',
      workspace: { form: { specificationRevision: 3 } },
    });
    expect(openEventsMock).toHaveBeenCalledWith('workspace-1', 'session-1', undefined);
  });

  it('closes an obsolete event source when a replacement connection wins the race', async () => {
    const workspace = designWorkspaceFixture();
    useImageWorkspaceStore.setState({
      status: 'ready',
      activeWorkspaceId: workspace.workspace.workspaceId,
      workspace,
    });
    const firstOpen = deferred<EventSource>();
    const secondOpen = deferred<EventSource>();
    const firstSource = new FakeEventSource();
    const secondSource = new FakeEventSource();
    openEventsMock
      .mockReturnValueOnce(firstOpen.promise)
      .mockReturnValueOnce(secondOpen.promise);

    useImageWorkspaceStore.getState().connectEvents();
    useImageWorkspaceStore.getState().disconnectEvents();
    useImageWorkspaceStore.getState().connectEvents();

    firstOpen.resolve(firstSource as unknown as EventSource);
    await Promise.resolve();
    secondOpen.resolve(secondSource as unknown as EventSource);
    await vi.waitFor(() => expect(openEventsMock).toHaveBeenCalledTimes(2));

    expect(firstSource.close).toHaveBeenCalledOnce();
    expect(secondSource.close).not.toHaveBeenCalled();
  });

  it('ignores late activity from a closed connection after reconnecting to the same Workspace', async () => {
    const firstSource = await loadedStore();
    const oldOnOpen = firstSource.onopen;
    const oldOnError = firstSource.onerror;
    const secondSource = new FakeEventSource();
    useImageWorkspaceStore.setState({
      pendingOperations: {
        'operation-chat-1': {
          id: 'operation-chat-1',
          label: '发送创作想法',
          command: {
            kind: 'apply_input',
            workspaceId: 'workspace-1',
            sessionId: 'session-1',
            expectedDirectionRevision: 4,
            clientOperationId: 'operation-chat-1',
            input: { kind: 'chat', message: '继续完善画面' },
          },
          status: 'submitting',
          error: null,
          clearDraftPaths: [],
          clearChatDraft: true,
          baseRawTurnSequence: 1,
        },
      },
    });
    openEventsMock.mockResolvedValueOnce(secondSource as unknown as EventSource);

    useImageWorkspaceStore.getState().disconnectEvents();
    useImageWorkspaceStore.getState().connectEvents();
    await vi.waitFor(() => expect(openEventsMock).toHaveBeenCalledTimes(2));
    secondSource.onopen?.(new Event('open'));
    const fetchCount = fetchProjectMock.mock.calls.length;
    const event = {
      type: 'design.assistant.progress',
      workspaceId: 'workspace-1',
      directionId: 'direction-1',
      clientOperationId: 'operation-chat-1',
      stage: 'understanding',
      message: '正在听懂你刚补充的内容…',
    } as const;

    firstSource.emit('design.assistant.progress', { ...event, id: 'session-1:7-old' });
    oldOnOpen?.(new Event('open'));
    oldOnError?.(new Event('error'));
    expect(useImageWorkspaceStore.getState().assistantActivities).toEqual({});
    expect(useImageWorkspaceStore.getState().eventState).toBe('connected');
    expect(fetchProjectMock).toHaveBeenCalledTimes(fetchCount);

    secondSource.emit('design.assistant.progress', { ...event, id: 'session-1:7' });
    expect(useImageWorkspaceStore.getState().assistantActivities['operation-chat-1'])
      .toMatchObject({ status: 'active', steps: [{ stage: 'understanding' }] });
  });

  it('allows a new event connection after opening the previous one failed', async () => {
    const workspace = designWorkspaceFixture();
    const recoveredSource = new FakeEventSource();
    useImageWorkspaceStore.setState({
      status: 'ready',
      activeWorkspaceId: workspace.workspace.workspaceId,
      workspace,
    });
    openEventsMock
      .mockRejectedValueOnce(new Error('temporary event connection failure'))
      .mockResolvedValueOnce(recoveredSource as unknown as EventSource);

    useImageWorkspaceStore.getState().connectEvents();
    await vi.waitFor(() => expect(useImageWorkspaceStore.getState().eventState).toBe('degraded'));
    useImageWorkspaceStore.getState().connectEvents();
    await vi.waitFor(() => expect(openEventsMock).toHaveBeenCalledTimes(2));

    expect(recoveredSource.close).not.toHaveBeenCalled();
  });

  it('uses assistant chunk indexes to ignore replayed deltas', async () => {
    const source = await loadedStore();
    useImageWorkspaceStore.setState({
      pendingOperations: {
        'operation-chat-1': {
          id: 'operation-chat-1',
          label: '发送创作想法',
          command: {
            kind: 'apply_input',
            workspaceId: 'workspace-1',
            sessionId: 'session-1',
            expectedDirectionRevision: 4,
            clientOperationId: 'operation-chat-1',
            input: { kind: 'chat', message: '继续完善画面' },
          },
          status: 'submitting',
          error: null,
          clearDraftPaths: [],
          clearChatDraft: true,
          baseRawTurnSequence: 1,
        },
      },
    });
    const baseEvent = {
      type: 'design.assistant.delta',
      workspaceId: 'workspace-1',
      directionId: 'direction-1',
      clientOperationId: 'operation-chat-1',
      directionRevision: 4,
    } as const;
    source.emit('design.assistant.delta', {
      ...baseEvent,
      id: 'session-1:7',
      chunkIndex: 0,
      delta: '收到',
    });
    source.emit('design.assistant.delta', {
      ...baseEvent,
      id: 'session-1:7-replayed',
      chunkIndex: 0,
      delta: '收到',
    });
    source.emit('design.assistant.delta', {
      ...baseEvent,
      id: 'session-1:8',
      chunkIndex: 1,
      delta: '，正在整理',
    });
    source.emit('design.assistant.delta', {
      ...baseEvent,
      id: 'session-1:9',
      chunkIndex: 1,
      delta: '，正在整理',
    });

    expect(useImageWorkspaceStore.getState().assistantStreams).toEqual({
      'operation-chat-1': '收到，正在整理',
    });
    expect(useImageWorkspaceStore.getState().lastEventId).toBe('session-1:9');
  });

  it('keeps a field draft separate until the direct edit succeeds', async () => {
    await loadedStore();
    useImageWorkspaceStore.getState().setFieldDraft('output.aspect_ratio', '16:9');

    await useImageWorkspaceStore.getState().applyFieldOperations(
      [{ kind: 'set', path: 'output.aspect_ratio', value: '16:9' }],
      ['output.aspect_ratio'],
    );

    expect(submitCommandMock).toHaveBeenCalledWith({
      kind: 'apply_input',
      workspaceId: 'workspace-1',
      sessionId: 'session-1',
      expectedDirectionRevision: 4,
      clientOperationId: 'operation-1',
      input: {
        kind: 'direct_edit',
        operations: [{ kind: 'set', path: 'output.aspect_ratio', value: '16:9' }],
      },
    });
    expect(useImageWorkspaceStore.getState().fieldDrafts).not.toHaveProperty('output.aspect_ratio');
    expect(useImageWorkspaceStore.getState().pendingOperations).toEqual({});
  });

  it('publishes a pending chat operation before the server result settles', async () => {
    await loadedStore();
    const message = '画一只在月球踢球的熊猫';
    const submission = deferred<Awaited<ReturnType<typeof submitImageWorkspaceCommand>>>();
    submitCommandMock.mockReturnValueOnce(submission.promise);
    useImageWorkspaceStore.getState().setChatDraft(message);

    const sendPromise = useImageWorkspaceStore.getState().sendChat();

    expect(useImageWorkspaceStore.getState()).toMatchObject({
      chatDraft: message,
      pendingOperations: {
        'operation-1': {
          id: 'operation-1',
          status: 'submitting',
          clearChatDraft: true,
          command: {
            kind: 'apply_input',
            workspaceId: 'workspace-1',
            clientOperationId: 'operation-1',
            input: { kind: 'chat', message },
          },
        },
      },
    });

    const workspace = designWorkspaceFixture({
      turns: [{
        turnId: 'turn-2',
        rawTurnSequence: 2,
        userMessage: message,
        assistantMessage: '你希望画面更像漫画，还是更像电影？',
      }],
    });
    submission.resolve({ clientOperationId: 'operation-1', runId: 'run-2', workspace });
    await sendPromise;

    expect(useImageWorkspaceStore.getState()).toMatchObject({
      workspace,
      chatDraft: '',
      pendingOperations: {},
    });
  });

  it('keeps public AI activity with its chat operation and settles it into the canonical turn', async () => {
    const source = await loadedStore();
    const message = '画一只在月球踢球的熊猫';
    const submission = deferred<Awaited<ReturnType<typeof submitImageWorkspaceCommand>>>();
    submitCommandMock.mockReturnValueOnce(submission.promise);
    useImageWorkspaceStore.getState().setChatDraft(message);

    const sendPromise = useImageWorkspaceStore.getState().sendChat();
    const progress = {
      type: 'design.assistant.progress',
      workspaceId: 'workspace-1',
      directionId: 'direction-1',
      clientOperationId: 'operation-1',
    } as const;
    source.emit('design.assistant.progress', {
      ...progress,
      id: 'session-1:7',
      stage: 'understanding',
      message: '正在听懂你刚补充的内容…',
    });
    source.emit('design.assistant.progress', {
      ...progress,
      id: 'session-1:8',
      stage: 'reviewing_context',
      message: '正在把它和前面的设计想法放在一起看…',
    });

    expect(useImageWorkspaceStore.getState().assistantActivities['operation-1'])
      .toMatchObject({
        workspaceId: 'workspace-1',
        directionId: 'direction-1',
        status: 'active',
        turnId: null,
        steps: [
          { stage: 'understanding', message: '正在听懂你刚补充的内容…' },
          { stage: 'reviewing_context', message: '正在把它和前面的设计想法放在一起看…' },
        ],
      });

    source.emit('design.assistant.progress', {
      ...progress,
      id: 'session-1:9',
      stage: 'understanding',
      message: '迟到的旧阶段',
    });
    expect(useImageWorkspaceStore.getState().assistantActivities['operation-1']?.steps)
      .toHaveLength(2);

    source.emit('design.assistant.delta', {
      id: 'session-1:10',
      type: 'design.assistant.delta',
      workspaceId: 'workspace-1',
      directionId: 'direction-1',
      clientOperationId: 'operation-1',
      directionRevision: 5,
      chunkIndex: 0,
      delta: '这个画面很有趣。',
    });
    expect(useImageWorkspaceStore.getState().assistantActivities['operation-1']?.status)
      .toBe('completed');

    const workspace = designWorkspaceFixture({
      turns: [
        {
          turnId: 'turn-2',
          rawTurnSequence: 2,
          userMessage: message,
          assistantMessage: '这个画面很有趣。',
        },
        {
          turnId: 'turn-3',
          rawTurnSequence: 3,
          userMessage: '后来补充的另一条消息',
          assistantMessage: '这是后来的回复。',
        },
      ],
    });
    submission.resolve({ clientOperationId: 'operation-1', runId: 'run-2', workspace });
    await sendPromise;

    expect(useImageWorkspaceStore.getState().assistantActivities['operation-1'])
      .toMatchObject({ status: 'completed', turnId: 'turn-2' });
    expect(useImageWorkspaceStore.getState().pendingOperations).toEqual({});
  });

  it('settles an unknown chat from a replayed Gateway terminal event', async () => {
    const source = await loadedStore();
    const message = '画一只在月球踢球的熊猫';
    const canonical = designWorkspaceFixture({
      form: designFormFixture({ rawTurnSequence: 2, directionRevision: 5 }),
      turns: [{
        turnId: 'turn-2',
        rawTurnSequence: 2,
        userMessage: message,
        assistantMessage: '你希望它更像漫画还是电影？',
      }],
    });
    fetchProjectMock.mockResolvedValueOnce(canonical);
    useImageWorkspaceStore.setState({
      chatDraft: message,
      pendingOperations: {
        'operation-chat-unknown': {
          id: 'operation-chat-unknown',
          label: '发送创作想法',
          command: {
            kind: 'apply_input',
            workspaceId: 'workspace-1',
            sessionId: 'session-1',
            expectedDirectionRevision: 4,
            clientOperationId: 'operation-chat-unknown',
            input: { kind: 'chat', message },
          },
          status: 'unknown',
          error: '连接暂时中断',
          clearDraftPaths: [],
          clearChatDraft: true,
          baseRawTurnSequence: 1,
        },
      },
      assistantActivities: {
        'operation-chat-unknown': {
          workspaceId: 'workspace-1',
          directionId: 'direction-1',
          status: 'unknown',
          turnId: null,
          steps: [{ stage: 'reviewing_context', message: '正在整理上下文' }],
        },
      },
    });

    source.emit('command.completed', {
      id: 'session-1:20',
      type: 'command.completed',
      workspaceId: 'workspace-1',
      clientOperationId: 'operation-chat-unknown',
      outcome: 'succeeded',
      errorCode: null,
    });

    await vi.waitFor(() => {
      expect(useImageWorkspaceStore.getState().pendingOperations).toEqual({});
    });
    expect(useImageWorkspaceStore.getState()).toMatchObject({
      chatDraft: '',
      workspace: { form: { rawTurnSequence: 2 } },
      assistantActivities: {
        'operation-chat-unknown': { status: 'completed', turnId: 'turn-2' },
      },
    });
  });

  it('keeps a succeeded terminal event authoritative when command polling then disconnects', async () => {
    const source = await loadedStore();
    const message = '画一只在月球踢球的熊猫';
    const canonical = designWorkspaceFixture({
      form: designFormFixture({ rawTurnSequence: 2, directionRevision: 5 }),
      turns: [{
        turnId: 'turn-2',
        rawTurnSequence: 2,
        userMessage: message,
        assistantMessage: '你希望它更像漫画还是电影？',
      }],
    });
    fetchProjectMock.mockResolvedValue(canonical);
    const submission = deferred<Awaited<ReturnType<typeof submitImageWorkspaceCommand>>>();
    submitCommandMock.mockReturnValueOnce(submission.promise);
    useImageWorkspaceStore.getState().setChatDraft(message);

    const sendPromise = useImageWorkspaceStore.getState().sendChat();
    source.emit('command.completed', {
      id: 'session-1:20',
      type: 'command.completed',
      workspaceId: 'workspace-1',
      clientOperationId: 'operation-1',
      outcome: 'succeeded',
      errorCode: null,
    });
    submission.reject(new ImageWorkspaceApiError(
      502,
      'IMAGE_WORKSPACE_REQUEST_FAILED',
      '轮询连接中断',
      'unknown',
    ));

    await expect(sendPromise).resolves.toMatchObject({
      form: { rawTurnSequence: 2 },
    });
    expect(useImageWorkspaceStore.getState()).toMatchObject({
      chatDraft: '',
      error: null,
      pendingOperations: {},
      workspace: { form: { rawTurnSequence: 2 } },
    });
  });

  it('keeps a failed terminal event authoritative when command polling then disconnects', async () => {
    const source = await loadedStore();
    const submission = deferred<Awaited<ReturnType<typeof submitImageWorkspaceCommand>>>();
    submitCommandMock.mockReturnValueOnce(submission.promise);
    useImageWorkspaceStore.getState().setChatDraft('画一只机器人');

    const sendPromise = useImageWorkspaceStore.getState().sendChat();
    source.emit('command.failed', {
      id: 'session-1:20',
      type: 'command.failed',
      workspaceId: 'workspace-1',
      clientOperationId: 'operation-1',
      outcome: 'failed',
      errorCode: 'design_reasoner_invalid',
    });
    submission.reject(new ImageWorkspaceApiError(
      502,
      'IMAGE_WORKSPACE_REQUEST_FAILED',
      '轮询连接中断',
      'unknown',
    ));

    await expect(sendPromise).rejects.toMatchObject({
      code: 'design_reasoner_invalid',
      commandOutcome: 'definitive_failure',
    });
    expect(useImageWorkspaceStore.getState()).toMatchObject({
      chatDraft: '画一只机器人',
      error: 'AI 这次没有完成设计整理，内容还在输入框里，请再试一次',
      pendingOperations: {},
      assistantActivities: {},
      assistantStreams: {},
    });
  });

  it('does not let a late polling success overwrite a Gateway terminal failure', async () => {
    const source = await loadedStore();
    const submission = deferred<Awaited<ReturnType<typeof submitImageWorkspaceCommand>>>();
    submitCommandMock.mockReturnValueOnce(submission.promise);
    useImageWorkspaceStore.getState().setChatDraft('画一只机器人');

    const sendPromise = useImageWorkspaceStore.getState().sendChat();
    source.emit('command.failed', {
      id: 'session-1:20',
      type: 'command.failed',
      workspaceId: 'workspace-1',
      clientOperationId: 'operation-1',
      outcome: 'failed',
      errorCode: 'design_reasoner_invalid',
    });
    submission.resolve({
      clientOperationId: 'operation-1',
      runId: 'run-1',
      workspace: designWorkspaceFixture({
        form: designFormFixture({ rawTurnSequence: 2, directionRevision: 5 }),
      }),
    });

    await expect(sendPromise).rejects.toMatchObject({
      code: 'design_reasoner_invalid',
      commandOutcome: 'definitive_failure',
    });
    expect(useImageWorkspaceStore.getState()).toMatchObject({
      chatDraft: '画一只机器人',
      error: 'AI 这次没有完成设计整理，内容还在输入框里，请再试一次',
      pendingOperations: {},
    });
  });

  it('does not resurrect pending after direction success settles before polling disconnects', async () => {
    const source = await loadedStore();
    const message = '画一只在月球踢球的熊猫';
    const canonical = designWorkspaceFixture({
      form: designFormFixture({ rawTurnSequence: 2, directionRevision: 5 }),
      turns: [{
        turnId: 'turn-2',
        rawTurnSequence: 2,
        userMessage: message,
        assistantMessage: '你希望它更像漫画还是电影？',
      }],
    });
    fetchProjectMock.mockResolvedValue(canonical);
    const submission = deferred<Awaited<ReturnType<typeof submitImageWorkspaceCommand>>>();
    submitCommandMock.mockReturnValueOnce(submission.promise);
    useImageWorkspaceStore.getState().setChatDraft(message);
    const sendPromise = useImageWorkspaceStore.getState().sendChat();

    source.emit('design.direction.updated', {
      id: 'session-1:19',
      type: 'design.direction.updated',
      clientOperationId: 'operation-1',
      replayed: false,
      operation: {
        operationKind: 'chat',
        interactionId: 'interaction-2',
        baseDirectionRevision: 4,
        newDirectionRevision: 5,
        rawTurnSequence: 2,
        specificationRevision: 3,
        specificationRevisionId: 'specification-revision-3',
        workspaceViewRevision: 7,
        specificationRevisionCreated: false,
        meaningChanged: false,
        changeSet: { interaction_id: 'interaction-2', changes: [] },
        turnId: 'turn-2',
        assistantMessage: '你希望它更像漫画还是电影？',
        createdDecisionPromptIds: [],
        resolvedDecisionPromptId: null,
        supersededDecisionPromptIds: [],
        supersededQuoteCount: 0,
        quoteId: null,
        generationTaskId: null,
      },
      form: designFormFixture({ rawTurnSequence: 2, directionRevision: 5 }),
    });
    await vi.waitFor(() => {
      expect(useImageWorkspaceStore.getState().pendingOperations).toEqual({});
    });
    source.emit('command.completed', {
      id: 'session-1:20',
      type: 'command.completed',
      workspaceId: 'workspace-1',
      clientOperationId: 'operation-1',
      outcome: 'succeeded',
      errorCode: null,
    });
    submission.reject(new ImageWorkspaceApiError(
      502,
      'IMAGE_WORKSPACE_REQUEST_FAILED',
      '轮询连接中断',
      'unknown',
    ));

    await expect(sendPromise).resolves.toMatchObject({ form: { rawTurnSequence: 2 } });
    expect(useImageWorkspaceStore.getState()).toMatchObject({
      chatDraft: '',
      error: null,
      pendingOperations: {},
      workspace: { form: { rawTurnSequence: 2 } },
    });
  });

  it('keeps the Quote created immediately after a committed generation chat', async () => {
    const source = await loadedStore();
    const message = '开始生成';
    const quoteForm = designFormFixture({
      directionRevision: 6,
      rawTurnSequence: 2,
      workspaceViewRevision: 8,
      activeQuotes: [designQuoteFixture()],
    });
    const canonical = designWorkspaceFixture({
      form: quoteForm,
      turns: [
        ...designWorkspaceFixture().turns,
        {
          turnId: 'turn-2',
          rawTurnSequence: 2,
          userMessage: message,
          assistantMessage: '我先检查制作方案。准备好后需要你确认一次，确认后才会开始生成。',
        },
      ],
    });
    fetchProjectMock.mockResolvedValue(canonical);
    useImageWorkspaceStore.setState({
      chatDraft: message,
      pendingOperations: {
        'operation-1': {
          id: 'operation-1',
          label: '发送创作想法',
          command: {
            kind: 'apply_input',
            workspaceId: 'workspace-1',
            sessionId: 'session-1',
            expectedDirectionRevision: 4,
            clientOperationId: 'operation-1',
            input: { kind: 'chat', message },
          },
          status: 'submitting',
          error: null,
          clearDraftPaths: [],
          clearChatDraft: true,
          baseRawTurnSequence: 1,
        },
      },
      assistantActivities: {
        'operation-1': {
          workspaceId: 'workspace-1',
          directionId: 'direction-1',
          status: 'submitting',
          turnId: null,
          steps: [],
        },
      },
    });

    source.emit('design.direction.updated', {
      id: 'session-1:19',
      type: 'design.direction.updated',
      clientOperationId: 'operation-1',
      replayed: false,
      operation: {
        operationKind: 'chat',
        interactionId: 'interaction-2',
        baseDirectionRevision: 4,
        newDirectionRevision: 5,
        rawTurnSequence: 2,
        specificationRevision: 3,
        specificationRevisionId: 'specification-revision-3',
        workspaceViewRevision: 7,
        specificationRevisionCreated: false,
        meaningChanged: false,
        changeSet: { interaction_id: 'interaction-2', changes: [] },
        turnId: 'turn-2',
        assistantMessage: '我先检查制作方案。准备好后需要你确认一次，确认后才会开始生成。',
        createdDecisionPromptIds: [],
        resolvedDecisionPromptId: null,
        supersededDecisionPromptIds: [],
        supersededQuoteCount: 0,
        quoteId: null,
        generationTaskId: null,
      },
      form: designFormFixture({
        directionRevision: 5,
        rawTurnSequence: 2,
        workspaceViewRevision: 7,
      }),
    });
    source.emit('design.direction.updated', {
      id: 'session-1:20',
      type: 'design.direction.updated',
      clientOperationId: 'operation-1',
      replayed: false,
      operation: {
        operationKind: 'quote_request',
        interactionId: 'interaction-quote-1',
        baseDirectionRevision: 5,
        newDirectionRevision: 6,
        rawTurnSequence: 2,
        specificationRevision: 3,
        specificationRevisionId: 'specification-revision-3',
        workspaceViewRevision: 8,
        specificationRevisionCreated: false,
        meaningChanged: false,
        changeSet: { interaction_id: 'interaction-quote-1', changes: [] },
        turnId: null,
        assistantMessage: null,
        createdDecisionPromptIds: [],
        resolvedDecisionPromptId: null,
        supersededDecisionPromptIds: [],
        supersededQuoteCount: 0,
        quoteId: 'quote-1',
        generationTaskId: null,
      },
      form: quoteForm,
    });

    await vi.waitFor(() => {
      expect(useImageWorkspaceStore.getState()).toMatchObject({
        chatDraft: '',
        pendingOperations: {},
        workspace: { form: { directionRevision: 6 } },
      });
    });
    expect(useImageWorkspaceStore.getState().workspace?.form.activeQuotes)
      .toEqual([designQuoteFixture()]);
    expect(useImageWorkspaceStore.getState().assistantActivities).toMatchObject({
      'operation-1': { status: 'completed', turnId: 'turn-2' },
    });
  });

  it('keeps the optimistic chat until a terminal success is visible in the canonical Workspace', async () => {
    const source = await loadedStore();
    const message = '画一只在月球踢球的熊猫';
    useImageWorkspaceStore.setState({
      chatDraft: message,
      pendingOperations: {
        'operation-chat-unknown': {
          id: 'operation-chat-unknown',
          label: '发送创作想法',
          command: {
            kind: 'apply_input',
            workspaceId: 'workspace-1',
            sessionId: 'session-1',
            expectedDirectionRevision: 4,
            clientOperationId: 'operation-chat-unknown',
            input: { kind: 'chat', message },
          },
          status: 'unknown',
          error: '连接暂时中断',
          clearDraftPaths: [],
          clearChatDraft: true,
          baseRawTurnSequence: 1,
        },
      },
      assistantActivities: {
        'operation-chat-unknown': {
          workspaceId: 'workspace-1',
          directionId: 'direction-1',
          status: 'unknown',
          turnId: null,
          steps: [{ stage: 'composing', message: '已经整理好，正在准备回复…' }],
        },
      },
    });
    fetchProjectMock.mockResolvedValueOnce(designWorkspaceFixture());

    source.emit('command.completed', {
      id: 'session-1:20',
      type: 'command.completed',
      workspaceId: 'workspace-1',
      clientOperationId: 'operation-chat-unknown',
      outcome: 'succeeded',
      errorCode: null,
    });
    await vi.waitFor(() => {
      expect(fetchProjectMock).toHaveBeenCalledTimes(2);
    });
    expect(useImageWorkspaceStore.getState()).toMatchObject({
      chatDraft: message,
      pendingOperations: {
        'operation-chat-unknown': { status: 'unknown' },
      },
    });

    const canonical = designWorkspaceFixture({
      form: designFormFixture({ rawTurnSequence: 2, directionRevision: 5 }),
      turns: [{
        turnId: 'turn-2',
        rawTurnSequence: 2,
        userMessage: message,
        assistantMessage: '你希望它更像漫画还是电影？',
      }],
    });
    fetchProjectMock.mockResolvedValueOnce(canonical);
    source.emit('design.direction.updated', {
      id: 'session-1:21',
      type: 'design.direction.updated',
      clientOperationId: 'operation-chat-unknown',
      replayed: false,
      operation: {
        operationKind: 'chat',
        interactionId: 'interaction-2',
        baseDirectionRevision: 4,
        newDirectionRevision: 5,
        rawTurnSequence: 2,
        specificationRevision: 3,
        specificationRevisionId: 'specification-revision-3',
        workspaceViewRevision: 7,
        specificationRevisionCreated: false,
        meaningChanged: false,
        changeSet: { interaction_id: 'interaction-2', changes: [] },
        turnId: 'turn-2',
        assistantMessage: '你希望它更像漫画还是电影？',
        createdDecisionPromptIds: [],
        resolvedDecisionPromptId: null,
        supersededDecisionPromptIds: [],
        supersededQuoteCount: 0,
        quoteId: null,
        generationTaskId: null,
      },
      form: designFormFixture({ rawTurnSequence: 2, directionRevision: 5 }),
    });

    await vi.waitFor(() => {
      expect(useImageWorkspaceStore.getState().pendingOperations).toEqual({});
    });
    expect(useImageWorkspaceStore.getState()).toMatchObject({
      chatDraft: '',
      assistantActivities: {
        'operation-chat-unknown': { status: 'completed', turnId: 'turn-2' },
      },
    });
  });

  it('uses the Gateway operation turn ID when identical chats are both pending', async () => {
    const source = await loadedStore();
    const message = '再画一只机器人';
    const command = (operationId: string) => ({
      kind: 'apply_input' as const,
      workspaceId: 'workspace-1',
      sessionId: 'session-1',
      expectedDirectionRevision: 4,
      clientOperationId: operationId,
      input: { kind: 'chat' as const, message },
    });
    useImageWorkspaceStore.setState({
      pendingOperations: {
        'operation-chat-1': {
          id: 'operation-chat-1',
          label: '发送创作想法',
          command: command('operation-chat-1'),
          status: 'unknown',
          error: '结果尚未确认',
          clearDraftPaths: [],
          clearChatDraft: true,
          baseRawTurnSequence: 1,
        },
        'operation-chat-2': {
          id: 'operation-chat-2',
          label: '发送创作想法',
          command: command('operation-chat-2'),
          status: 'unknown',
          error: '结果尚未确认',
          clearDraftPaths: [],
          clearChatDraft: true,
          baseRawTurnSequence: 1,
        },
      },
      assistantActivities: {
        'operation-chat-1': {
          workspaceId: 'workspace-1',
          directionId: 'direction-1',
          status: 'unknown',
          turnId: null,
          steps: [{ stage: 'composing', message: '已经整理好，正在准备回复…' }],
        },
        'operation-chat-2': {
          workspaceId: 'workspace-1',
          directionId: 'direction-1',
          status: 'unknown',
          turnId: null,
          steps: [{ stage: 'composing', message: '已经整理好，正在准备回复…' }],
        },
      },
    });
    const canonical = designWorkspaceFixture({
      form: designFormFixture({ rawTurnSequence: 3, directionRevision: 6 }),
      turns: [
        {
          turnId: 'turn-2',
          rawTurnSequence: 2,
          userMessage: message,
          assistantMessage: '第一条相同消息的回复。',
        },
        {
          turnId: 'turn-3',
          rawTurnSequence: 3,
          userMessage: message,
          assistantMessage: '第二条相同消息的回复。',
        },
      ],
    });
    fetchProjectMock.mockResolvedValueOnce(canonical);

    source.emit('design.direction.updated', {
      id: 'session-1:22',
      type: 'design.direction.updated',
      clientOperationId: 'operation-chat-2',
      replayed: false,
      operation: {
        operationKind: 'chat',
        interactionId: 'interaction-3',
        baseDirectionRevision: 5,
        newDirectionRevision: 6,
        rawTurnSequence: 3,
        specificationRevision: 3,
        specificationRevisionId: 'specification-revision-3',
        workspaceViewRevision: 8,
        specificationRevisionCreated: false,
        meaningChanged: false,
        changeSet: { interaction_id: 'interaction-3', changes: [] },
        turnId: 'turn-3',
        assistantMessage: '第二条相同消息的回复。',
        createdDecisionPromptIds: [],
        resolvedDecisionPromptId: null,
        supersededDecisionPromptIds: [],
        supersededQuoteCount: 0,
        quoteId: null,
        generationTaskId: null,
      },
      form: designFormFixture({ rawTurnSequence: 3, directionRevision: 6 }),
    });

    await vi.waitFor(() => {
      expect(useImageWorkspaceStore.getState().pendingOperations['operation-chat-2'])
        .toBeUndefined();
    });
    expect(useImageWorkspaceStore.getState().pendingOperations['operation-chat-1'])
      .toBeDefined();
    expect(useImageWorkspaceStore.getState().assistantActivities).toMatchObject({
      'operation-chat-1': { turnId: null },
      'operation-chat-2': { status: 'completed', turnId: 'turn-3' },
    });
  });

  it('settles an unknown chat when Gateway later reports terminal failure', async () => {
    const source = await loadedStore();
    useImageWorkspaceStore.setState({
      pendingOperations: {
        'operation-chat-unknown': {
          id: 'operation-chat-unknown',
          label: '发送创作想法',
          command: {
            kind: 'apply_input',
            workspaceId: 'workspace-1',
            sessionId: 'session-1',
            expectedDirectionRevision: 4,
            clientOperationId: 'operation-chat-unknown',
            input: { kind: 'chat', message: '画一只机器人' },
          },
          status: 'unknown',
          error: '连接暂时中断',
          clearDraftPaths: [],
          clearChatDraft: true,
          baseRawTurnSequence: 1,
        },
      },
      assistantActivities: {
        'operation-chat-unknown': {
          workspaceId: 'workspace-1',
          directionId: 'direction-1',
          status: 'unknown',
          turnId: null,
          steps: [{ stage: 'reviewing_context', message: '正在整理上下文' }],
        },
      },
    });

    source.emit('command.failed', {
      id: 'session-1:20',
      type: 'command.failed',
      workspaceId: 'workspace-1',
      clientOperationId: 'operation-chat-unknown',
      outcome: 'failed',
      errorCode: 'design_reasoner_invalid',
    });

    expect(useImageWorkspaceStore.getState().pendingOperations).toEqual({});
    expect(useImageWorkspaceStore.getState().assistantActivities).toEqual({});
    expect(useImageWorkspaceStore.getState().error)
      .toBe('AI 这次没有完成设计整理，内容还在输入框里，请再试一次');
  });

  it('does not replace the active Workspace when an earlier Workspace command completes late', async () => {
    await loadedStore();
    const submission = deferred<Awaited<ReturnType<typeof submitImageWorkspaceCommand>>>();
    submitCommandMock.mockReturnValueOnce(submission.promise);
    useImageWorkspaceStore.getState().setChatDraft('旧项目里的消息');
    const sendPromise = useImageWorkspaceStore.getState().sendChat();
    const workspaceB = designWorkspaceFixture({
      workspace: designSummaryFixture({
        workspaceId: 'workspace-2',
        clientWorkspaceId: 'client-workspace-2',
        directionId: 'direction-2',
        sessionId: 'session-2',
        title: '当前项目',
      }),
      form: designFormFixture({ workspaceId: 'workspace-2', directionId: 'direction-2' }),
    });
    useImageWorkspaceStore.setState({
      activeWorkspaceId: 'workspace-2',
      workspace: workspaceB,
      assistantActivities: {},
      assistantStreams: {},
    });

    submission.resolve({
      clientOperationId: 'operation-1',
      runId: 'run-old',
      workspace: designWorkspaceFixture(),
    });
    await sendPromise;

    expect(useImageWorkspaceStore.getState()).toMatchObject({
      activeWorkspaceId: 'workspace-2',
      workspace: { workspace: { workspaceId: 'workspace-2', title: '当前项目' } },
      pendingOperations: {},
    });
  });

  it('does not apply an old A result after the user switches A to B and back to A', async () => {
    await loadedStore();
    const submission = deferred<Awaited<ReturnType<typeof submitImageWorkspaceCommand>>>();
    submitCommandMock.mockReturnValueOnce(submission.promise);
    useImageWorkspaceStore.getState().setChatDraft('旧的 A 项目消息');
    const sendPromise = useImageWorkspaceStore.getState().sendChat();

    const workspaceB = designWorkspaceFixture({
      workspace: designSummaryFixture({
        workspaceId: 'workspace-2',
        clientWorkspaceId: 'client-workspace-2',
        directionId: 'direction-2',
        sessionId: 'session-2',
        title: '项目 B',
      }),
      form: designFormFixture({ workspaceId: 'workspace-2', directionId: 'direction-2' }),
    });
    const currentWorkspaceA = designWorkspaceFixture({
      workspace: designSummaryFixture({ workspaceViewRevision: 12, title: '重新打开的项目 A' }),
      form: designFormFixture({ rawTurnSequence: 4, workspaceViewRevision: 12 }),
      turns: [{
        turnId: 'turn-4',
        rawTurnSequence: 4,
        userMessage: 'A 项目中较新的消息',
        assistantMessage: '这是较新的回复。',
      }],
    });
    fetchProjectMock
      .mockResolvedValueOnce(workspaceB)
      .mockResolvedValueOnce(currentWorkspaceA);
    await useImageWorkspaceStore.getState().selectProject('workspace-2');
    await useImageWorkspaceStore.getState().selectProject('workspace-1');

    submission.resolve({
      clientOperationId: 'operation-1',
      runId: 'run-old-a',
      workspace: designWorkspaceFixture({
        form: designFormFixture({ rawTurnSequence: 2, workspaceViewRevision: 7 }),
      }),
    });
    await sendPromise;

    expect(useImageWorkspaceStore.getState()).toMatchObject({
      activeWorkspaceId: 'workspace-1',
      pendingOperations: {},
      workspace: {
        workspace: { title: '重新打开的项目 A', workspaceViewRevision: 12 },
        form: { rawTurnSequence: 4, workspaceViewRevision: 12 },
      },
    });
  });

  it('does not show a late B loading error after the user returns to A', async () => {
    await loadedStore();
    const workspaceB = deferred<Awaited<ReturnType<typeof fetchImageWorkspaceProject>>>();
    const currentWorkspaceA = designWorkspaceFixture({
      workspace: designSummaryFixture({ workspaceViewRevision: 12, title: '重新打开的项目 A' }),
      form: designFormFixture({ rawTurnSequence: 4, workspaceViewRevision: 12 }),
    });
    fetchProjectMock
      .mockReturnValueOnce(workspaceB.promise)
      .mockResolvedValueOnce(currentWorkspaceA);

    const selectBPromise = useImageWorkspaceStore.getState().selectProject('workspace-2');
    await useImageWorkspaceStore.getState().selectProject('workspace-1');
    workspaceB.reject(new Error('项目 B 加载失败'));
    await selectBPromise;

    expect(useImageWorkspaceStore.getState()).toMatchObject({
      activeWorkspaceId: 'workspace-1',
      error: null,
      workspace: {
        workspace: { title: '重新打开的项目 A', workspaceViewRevision: 12 },
        form: { rawTurnSequence: 4, workspaceViewRevision: 12 },
      },
    });
  });

  it('ignores progress and reply deltas that do not belong to the active pending chat', async () => {
    const source = await loadedStore();

    source.emit('design.assistant.progress', {
      id: 'session-1:7',
      type: 'design.assistant.progress',
      workspaceId: 'workspace-1',
      directionId: 'direction-1',
      clientOperationId: 'unrelated-operation',
      stage: 'understanding',
      message: '不应显示',
    });
    source.emit('design.assistant.delta', {
      id: 'session-1:8',
      type: 'design.assistant.delta',
      workspaceId: 'workspace-1',
      directionId: 'direction-1',
      clientOperationId: 'unrelated-operation',
      directionRevision: 4,
      chunkIndex: 0,
      delta: '不应显示',
    });

    expect(useImageWorkspaceStore.getState().assistantActivities).toEqual({});
    expect(useImageWorkspaceStore.getState().assistantStreams).toEqual({});
    expect(useImageWorkspaceStore.getState().lastEventId).toBe('session-1:8');
  });

  it('settles a definitive reasoner failure without losing the chat draft', async () => {
    const source = await loadedStore();
    useImageWorkspaceStore.getState().setChatDraft('画一只会做饭的机器人');
    submitCommandMock.mockImplementationOnce(async () => {
      source.emit('design.assistant.progress', {
        id: 'session-1:6',
        type: 'design.assistant.progress',
        workspaceId: 'workspace-1',
        directionId: 'direction-1',
        clientOperationId: 'operation-1',
        stage: 'reviewing_context',
        message: '正在把它和前面的设计想法放在一起看…',
      });
      source.emit('design.assistant.delta', {
        id: 'session-1:7',
        type: 'design.assistant.delta',
        workspaceId: 'workspace-1',
        directionId: 'direction-1',
        clientOperationId: 'operation-1',
        directionRevision: 4,
        chunkIndex: 0,
        delta: '正在整理',
      });
      throw new ImageWorkspaceApiError(
        502,
        'design_reasoner_invalid',
        'AI 没有整理好这次想法，请再试一次',
        'definitive_failure',
      );
    });

    await expect(useImageWorkspaceStore.getState().sendChat()).rejects.toMatchObject({
      status: 502,
      code: 'design_reasoner_invalid',
    });

    expect(useImageWorkspaceStore.getState()).toMatchObject({
      chatDraft: '画一只会做饭的机器人',
      error: 'AI 没有整理好这次想法，请再试一次',
    });
    expect(useImageWorkspaceStore.getState().pendingOperations).toEqual({});
    expect(useImageWorkspaceStore.getState().assistantActivities).toEqual({});
    expect(useImageWorkspaceStore.getState().assistantStreams).toEqual({});
  });

  it('settles any Main-confirmed terminal run without an error-code allowlist', async () => {
    await loadedStore();
    submitCommandMock.mockRejectedValueOnce(new ImageWorkspaceApiError(
      422,
      'policy_blocked',
      '当前内容不符合创作安全规则',
      'definitive_failure',
    ));

    await expect(useImageWorkspaceStore.getState().requestQuote()).rejects.toMatchObject({
      code: 'policy_blocked',
      commandOutcome: 'definitive_failure',
    });

    expect(useImageWorkspaceStore.getState().pendingOperations).toEqual({});
    expect(useImageWorkspaceStore.getState().error).toBe('当前内容不符合创作安全规则');
  });

  it('keeps the accepted command identity when polling auth expires', async () => {
    const source = await loadedStore();
    useImageWorkspaceStore.getState().setChatDraft('画一只会做饭的机器人');
    submitCommandMock.mockImplementationOnce(async () => {
      source.emit('design.assistant.progress', {
        id: 'session-1:6',
        type: 'design.assistant.progress',
        workspaceId: 'workspace-1',
        directionId: 'direction-1',
        clientOperationId: 'operation-1',
        stage: 'reviewing_context',
        message: '正在把它和前面的设计想法放在一起看…',
      });
      source.emit('design.assistant.delta', {
        id: 'session-1:7',
        type: 'design.assistant.delta',
        workspaceId: 'workspace-1',
        directionId: 'direction-1',
        clientOperationId: 'operation-1',
        directionRevision: 4,
        chunkIndex: 0,
        delta: '正在整理',
      });
      throw new ImageWorkspaceApiError(
        401,
        'AUTH_EXPIRED',
        '登录状态已失效，请重新登录',
        'unknown',
      );
    });

    await expect(useImageWorkspaceStore.getState().sendChat()).rejects.toMatchObject({
      status: 401,
      code: 'AUTH_EXPIRED',
      commandOutcome: 'unknown',
    });

    expect(useImageWorkspaceStore.getState().chatDraft).toBe('画一只会做饭的机器人');
    expect(useImageWorkspaceStore.getState().pendingOperations['operation-1']).toMatchObject({
      id: 'operation-1',
      status: 'unknown',
    });
    expect(useImageWorkspaceStore.getState().assistantStreams).toEqual({
      'operation-1': '正在整理',
    });
    expect(useImageWorkspaceStore.getState().assistantActivities['operation-1'])
      .toMatchObject({ status: 'unknown', steps: [{ stage: 'reviewing_context' }] });
  });

  it('preserves an earlier unknown activity when another chat starts', async () => {
    await loadedStore();
    const submission = deferred<Awaited<ReturnType<typeof submitImageWorkspaceCommand>>>();
    operationIdMock.mockReturnValueOnce('operation-chat-2');
    submitCommandMock.mockReturnValueOnce(submission.promise);
    useImageWorkspaceStore.setState({
      chatDraft: '再补充一只小兔子',
      pendingOperations: {
        'operation-chat-1': {
          id: 'operation-chat-1',
          label: '发送创作想法',
          command: {
            kind: 'apply_input',
            workspaceId: 'workspace-1',
            sessionId: 'session-1',
            expectedDirectionRevision: 4,
            clientOperationId: 'operation-chat-1',
            input: { kind: 'chat', message: '先画一只小熊' },
          },
          status: 'unknown',
          error: '结果尚未确认',
          clearDraftPaths: [],
          clearChatDraft: true,
          baseRawTurnSequence: 1,
        },
      },
      assistantActivities: {
        'operation-chat-1': {
          workspaceId: 'workspace-1',
          directionId: 'direction-1',
          status: 'unknown',
          turnId: null,
          steps: [{ stage: 'reviewing_context', message: '正在整理上下文' }],
        },
      },
    });

    const sendPromise = useImageWorkspaceStore.getState().sendChat();

    expect(useImageWorkspaceStore.getState().assistantActivities).toMatchObject({
      'operation-chat-1': {
        status: 'unknown',
        steps: [{ stage: 'reviewing_context' }],
      },
    });
    expect(useImageWorkspaceStore.getState().pendingOperations).toMatchObject({
      'operation-chat-1': { status: 'unknown' },
      'operation-chat-2': { status: 'submitting' },
    });

    submission.resolve({
      clientOperationId: 'operation-chat-2',
      runId: 'run-2',
      workspace: designWorkspaceFixture(),
    });
    await sendPromise;
  });

  it('expires quote blockers only after the canonical Specification changes', async () => {
    await loadedStore();
    const blocker = {
      code: 'aspect_ratio_required',
      message: 'Choose an aspect ratio supported by the frozen route.',
      severity: 'blocker' as const,
      path: 'output.aspect_ratio',
    };
    useImageWorkspaceStore.setState({ quoteBlockers: [blocker] });

    await useImageWorkspaceStore.getState().refreshWorkspace();
    expect(useImageWorkspaceStore.getState().quoteBlockers).toEqual([blocker]);

    const revisedWorkspace = designWorkspaceFixture({
      form: designFormFixture({
        directionRevision: 5,
        specificationRevision: 4,
        specificationRevisionId: 'specification-revision-4',
      }),
    });
    submitCommandMock.mockResolvedValueOnce({
      clientOperationId: 'operation-1',
      runId: 'run-2',
      workspace: revisedWorkspace,
    });
    await useImageWorkspaceStore.getState().applyFieldOperations([
      { kind: 'set', path: 'output.aspect_ratio', value: '16:9' },
    ]);

    expect(useImageWorkspaceStore.getState().quoteBlockers).toEqual([]);
    expect(useImageWorkspaceStore.getState().workspace?.form.specificationRevision).toBe(4);
  });

  it('treats a terminal quote-blocked response as definitive instead of unknown', async () => {
    await loadedStore();
    submitCommandMock.mockRejectedValueOnce(new ImageWorkspaceApiError(
      422,
      'design_quote_blocked',
      'The frozen compiler needs more information.',
    ));

    await expect(useImageWorkspaceStore.getState().requestQuote()).rejects.toMatchObject({
      status: 422,
      code: 'design_quote_blocked',
    });

    expect(useImageWorkspaceStore.getState().pendingOperations).toEqual({});
    expect(useImageWorkspaceStore.getState().error).toBeNull();
  });

  it('settles an unknown quote from its blocked event, then allows a revised Quote', async () => {
    const source = await loadedStore();
    submitCommandMock.mockRejectedValueOnce(new Error('network disconnected'));
    await expect(useImageWorkspaceStore.getState().requestQuote()).rejects.toThrow(
      'network disconnected',
    );
    expect(useImageWorkspaceStore.getState().pendingOperations['operation-1']?.status).toBe('unknown');

    const blocker = {
      code: 'aspect_ratio_required',
      message: 'Choose an aspect ratio supported by the frozen route.',
      severity: 'blocker' as const,
      path: 'output.aspect_ratio',
    };
    source.emit('design.quote.blocked', {
      id: 'session-1:quote-blocked',
      type: 'design.quote.blocked',
      clientOperationId: 'operation-1',
      blockers: [blocker],
      warnings: [],
      form: designFormFixture(),
    });

    expect(useImageWorkspaceStore.getState()).toMatchObject({
      pendingOperations: {},
      quoteBlockers: [blocker],
      error: null,
    });

    const revisedWorkspace = designWorkspaceFixture({
      form: designFormFixture({
        directionRevision: 5,
        specificationRevision: 4,
        specificationRevisionId: 'specification-revision-4',
      }),
    });
    submitCommandMock.mockResolvedValueOnce({
      clientOperationId: 'operation-1',
      runId: 'run-edit',
      workspace: revisedWorkspace,
    });
    await useImageWorkspaceStore.getState().applyFieldOperations([
      { kind: 'set', path: 'output.aspect_ratio', value: '16:9' },
    ]);
    expect(useImageWorkspaceStore.getState().quoteBlockers).toEqual([]);

    submitCommandMock.mockResolvedValueOnce({
      clientOperationId: 'operation-1',
      runId: 'run-quote-revised',
      workspace: revisedWorkspace,
    });
    await useImageWorkspaceStore.getState().requestQuote();

    expect(submitCommandMock).toHaveBeenLastCalledWith(expect.objectContaining({
      kind: 'request_quote',
      expectedDirectionRevision: 5,
      specificationRevision: 4,
    }));
    expect(useImageWorkspaceStore.getState().pendingOperations).toEqual({});
  });

  it('refreshes on a definitive revision conflict and preserves the unsent draft', async () => {
    await loadedStore();
    useImageWorkspaceStore.getState().setFieldDraft('intent.purpose', '新的用途');
    submitCommandMock.mockRejectedValueOnce(new ImageWorkspaceApiError(
      409,
      'design_direction_revision_conflict',
      'conflict',
    ));

    await expect(useImageWorkspaceStore.getState().applyFieldOperations(
      [{ kind: 'set', path: 'intent.purpose', value: '新的用途' }],
      ['intent.purpose'],
    )).rejects.toMatchObject({ status: 409 });

    expect(fetchProjectMock).toHaveBeenCalledWith('workspace-1');
    expect(useImageWorkspaceStore.getState().fieldDrafts).toEqual({
      'intent.purpose': '新的用途',
    });
    expect(useImageWorkspaceStore.getState().pendingOperations).toEqual({});
  });

  it('retains an uncertain accepted write and retries the exact same command identity', async () => {
    await loadedStore();
    submitCommandMock.mockRejectedValueOnce(new Error('network disconnected'));

    await expect(useImageWorkspaceStore.getState().requestQuote()).rejects.toThrow(
      'network disconnected',
    );
    const pending = useImageWorkspaceStore.getState().pendingOperations['operation-1'];
    expect(pending).toMatchObject({
      id: 'operation-1',
      status: 'unknown',
      command: {
        kind: 'request_quote',
        expectedDirectionRevision: 4,
        specificationRevision: 3,
      },
    });

    submitCommandMock.mockResolvedValueOnce({
      clientOperationId: 'operation-1',
      runId: 'run-original',
      workspace: designWorkspaceFixture(),
    });
    await useImageWorkspaceStore.getState().retryOperation('operation-1');

    expect(submitCommandMock).toHaveBeenNthCalledWith(2, pending.command);
    expect(useImageWorkspaceStore.getState().pendingOperations).toEqual({});
  });

  it('reconciles assistant deltas and canonical Form events without mutating drafts', async () => {
    const source = await loadedStore();
    useImageWorkspaceStore.getState().setFieldDraft('intent.purpose', '本地草稿');
    useImageWorkspaceStore.setState({
      assistantStreams: { 'operation-chat-unknown': '这段回复还没确认' },
      pendingOperations: {
        'operation-chat-unknown': {
          id: 'operation-chat-unknown',
          label: '发送创作想法',
          command: {
            kind: 'apply_input',
            workspaceId: 'workspace-1',
            sessionId: 'session-1',
            expectedDirectionRevision: 4,
            clientOperationId: 'operation-chat-unknown',
            input: { kind: 'chat', message: '保留这条未知结果' },
          },
          status: 'unknown',
          error: '结果尚未确认',
          clearDraftPaths: [],
          clearChatDraft: true,
          baseRawTurnSequence: 1,
        },
      },
      quoteBlockers: [{
        code: 'missing_choice',
        message: '还需要选择作品形状',
        severity: 'blocker',
        path: 'output.aspect_ratio',
      }],
    });
    source.emit('design.assistant.delta', {
      id: 'session-1:7',
      type: 'design.assistant.delta',
      workspaceId: 'workspace-1',
      directionId: 'direction-1',
      clientOperationId: 'operation-chat-1',
      directionRevision: 4,
      chunkIndex: 0,
      delta: '正在整理',
    });
    source.emit('design.direction.updated', {
      id: 'session-1:8',
      type: 'design.direction.updated',
      clientOperationId: 'operation-chat-1',
      replayed: false,
      operation: {
        operationKind: 'chat',
        interactionId: 'interaction-2',
        baseDirectionRevision: 4,
        newDirectionRevision: 5,
        rawTurnSequence: 2,
        specificationRevision: 4,
        specificationRevisionId: 'specification-revision-4',
        workspaceViewRevision: 7,
        specificationRevisionCreated: true,
        meaningChanged: true,
        changeSet: { interaction_id: 'interaction-2', changes: [] },
        turnId: 'turn-2',
        assistantMessage: '已更新',
        createdDecisionPromptIds: [],
        resolvedDecisionPromptId: null,
        supersededDecisionPromptIds: [],
        supersededQuoteCount: 0,
        quoteId: null,
        generationTaskId: null,
      },
      form: designFormFixture({
        directionRevision: 5,
        specificationRevision: 4,
        specificationRevisionId: 'specification-revision-4',
        workspaceViewRevision: 7,
      }),
    });

    expect(useImageWorkspaceStore.getState().assistantStreams).toEqual({
      'operation-chat-unknown': '这段回复还没确认',
    });
    expect(useImageWorkspaceStore.getState()).toMatchObject({
      lastEventId: 'session-1:8',
      fieldDrafts: { 'intent.purpose': '本地草稿' },
      quoteBlockers: [],
      workspace: { form: { directionRevision: 5, specificationRevision: 4 } },
    });
  });

  it('creates, renames and deletes only Workspace identities', async () => {
    await useImageWorkspaceStore.getState().createProject('新项目');
    await useImageWorkspaceStore.getState().renameProject('workspace-1', '新名称');
    await useImageWorkspaceStore.getState().deleteProject('workspace-1');

    expect(createProjectMock).toHaveBeenCalledWith('新项目');
    expect(renameProjectMock).toHaveBeenCalledWith('workspace-1', '新名称');
    expect(deleteProjectMock).toHaveBeenCalledWith('workspace-1');
    expect(useImageWorkspaceStore.getState().activeWorkspaceId).toBeNull();
  });

  it('renames a background Workspace without changing the active Workspace', async () => {
    await loadedStore();
    const backgroundSummary = designSummaryFixture({
      workspaceId: 'workspace-2',
      clientWorkspaceId: 'client-workspace-2',
      title: '背景项目',
      directionId: 'direction-2',
      sessionId: 'session-2',
    });
    useImageWorkspaceStore.setState((state) => ({
      bootstrap: state.bootstrap
        ? { ...state.bootstrap, workspaces: [...state.bootstrap.workspaces, backgroundSummary] }
        : null,
    }));
    renameProjectMock.mockResolvedValueOnce(designWorkspaceFixture({
      workspace: { ...backgroundSummary, title: '背景项目新名称' },
    }));

    await useImageWorkspaceStore.getState().renameProject('workspace-2', '背景项目新名称');

    expect(useImageWorkspaceStore.getState()).toMatchObject({
      activeWorkspaceId: 'workspace-1',
      workspace: { workspace: { workspaceId: 'workspace-1' } },
    });
    expect(useImageWorkspaceStore.getState().bootstrap?.workspaces).toEqual(
      expect.arrayContaining([
        expect.objectContaining({ workspaceId: 'workspace-2', title: '背景项目新名称' }),
      ]),
    );
  });
});