import {
  type FormEvent,
  type UIEvent,
  useEffect,
  useLayoutEffect,
} from 'react';

import { AGENT_CHAT_SCROLL_BOTTOM_THRESHOLD } from '../../app/constants';
import { useEscapeToClose } from '../../app/dialogs';
import { resolveTauriInvoke } from '../../app/tauri';
import type {
  AgentChatPendingRuntimeRun,
  AgentConversationSessionListResult,
  AgentConversationSessionRecord,
  AgentGoalRecord,
  AgentRuntimeResult,
  AgentRuntimeSteerResult,
  GameCreatorAgentRuntimeUpdateEvent,
  GameCreatorChatAgentReply,
  GameCreatorLlmConfigStatus,
  GameCreatorRoleAgentChatStreamEvent,
  LauncherAgentChatAgent,
  LocalConversationResult,
  TauriInvoke,
} from '../../app/types';
import { type LauncherView } from '../../view/layout';
import {
  agentGoalStatusIsTerminal,
  agentRuntimeConversationStatus,
  agentRuntimeNeedsUserInput,
  agentRuntimeStartedRunId,
  agentRuntimeStartStatus,
  agentRuntimeStateFromResult,
  agentRuntimeSteerStatus,
  createAgentChatRunId,
  createLocalConversationDraftMessage,
  isAgentRuntimeTerminalState,
  isMissingAgentGoalCommandError,
  isMissingAgentRuntimeResumeCommandError,
  isMissingAgentSessionCommandError,
  matchingAgentRuntimeForSteer,
  mergeAgentGoalRecordFromRuntime,
  normalizeAgentRuntimeState,
} from '../agent-runtime';
import {
  formatAgentLlmConfigWarning,
  formatCodexAgentModeLabel,
  formatCodexRuntimeCapabilities,
  isCodexAgentMode,
  llmStatusForAgentCard,
} from '../project-summary/agentPresentation';
import {
  isAbsoluteProjectPath,
  projectPathHasControlCharacter,
} from '../project-summary/projectSummary';
import { createDeveloperAgentControls } from './developerAgentControls';
import { useDeveloperAgentState } from './useDeveloperAgentState';

export function useDeveloperAgentPanel(launcherView: LauncherView) {
  const state = useDeveloperAgentState();
  const {
    launcherAgentChatAgents,
    agentChatProjectPath,
    setAgentChatProjectPath,
    agentChatSelectedAgentId,
    setAgentChatSelectedAgentId,
    agentChatMessages,
    setAgentChatMessages,
    agentChatSessions,
    setAgentChatSessions,
    agentChatSelectedSessionId,
    setAgentChatSelectedSessionId,
    agentChatActiveSessionId,
    setAgentChatActiveSessionId,
    agentChatLegacySessionMode,
    setAgentChatLegacySessionMode,
    agentChatConversationPath,
    setAgentChatConversationPath,
    agentChatSessionStatus,
    setAgentChatSessionStatus,
    agentChatInput,
    setAgentChatInput,
    agentChatInteractionMode,
    setAgentChatInteractionMode,
    agentChatRunSubmitMode,
    setAgentChatRunSubmitMode,
    agentChatReplyPhase,
    setAgentChatReplyPhase,
    agentChatStatus,
    setAgentChatStatus,
    agentChatBusy,
    setAgentChatBusy,
    agentChatMessagesRef,
    agentChatShouldFollowLatestRef,
    agentChatBackgroundBusy,
    setAgentChatBackgroundBusy,
    agentChatPendingRuntimeRun,
    setAgentChatPendingRuntimeRunState,
    agentChatLlmConfigStatus,
    setAgentChatLlmConfigStatus,
    agentChatLlmStatus,
    setAgentChatLlmStatus,
    agentChatRuntime,
    setAgentChatRuntime,
    agentChatActiveRuntime,
    setAgentChatActiveRuntime,
    agentChatRuntimeError,
    setAgentChatRuntimeError,
    agentChatGoal,
    setAgentChatGoal,
    agentChatGoalError,
    setAgentChatGoalError,
    agentChatGoalDialog,
    setAgentChatGoalDialog,
    agentChatGoalDialogError,
    setAgentChatGoalDialogError,
    agentChatResumeConfirmation,
    setAgentChatResumeConfirmation,
    agentChatLoadVersionRef,
    agentChatRuntimeResumeProjectPathRef,
    agentChatProjectPathRef,
    agentChatSelectedAgentIdRef,
    agentChatSelectedSessionIdRef,
    agentChatActiveSessionIdRef,
    agentChatPendingRuntimeRunRef,
    agentChatRuntimeSyncingRunIdsRef,
    agentChatRuntimeSyncConversationRef,
  } = state;

  useEffect(() => {
    setAgentChatRunSubmitMode('steer');
  }, [
    agentChatSelectedAgentId,
    agentChatSelectedSessionId,
    setAgentChatRunSubmitMode,
  ]);

  function setAgentChatPendingRuntimeRun(
    pendingRun: AgentChatPendingRuntimeRun | null,
  ) {
    agentChatPendingRuntimeRunRef.current = pendingRun;
    setAgentChatPendingRuntimeRunState(pendingRun);
  }

  async function syncAgentChatConversationAfterRuntime(
    invoke: TauriInvoke,
    pendingRun: AgentChatPendingRuntimeRun,
  ) {
    let latestResult: LocalConversationResult | null = null;
    for (let attempt = 0; attempt < 4; attempt += 1) {
      if (
        agentChatProjectPathRef.current.trim() !== pendingRun.projectPath ||
        agentChatSelectedAgentIdRef.current !== pendingRun.agentId ||
        (pendingRun.sessionId !== null &&
          agentChatSelectedSessionIdRef.current !== pendingRun.sessionId)
      ) {
        return;
      }
      try {
        latestResult = await invoke<LocalConversationResult>(
          'read_local_conversation',
          {
            projectPath: pendingRun.projectPath,
            agentId: pendingRun.agentId,
            ...(pendingRun.sessionId
              ? { sessionId: pendingRun.sessionId }
              : {}),
          },
        );
      } catch (error) {
        if (attempt === 3) {
          setAgentChatStatus(
            `Agent 已结束，但同步对话失败：${
              error instanceof Error ? error.message : String(error)
            }`,
          );
          break;
        }
      }
      const newMessages =
        latestResult?.messages.slice(pendingRun.messageCount) ?? [];
      if (
        newMessages.some((message) => message.role === 'assistant') ||
        attempt === 3
      ) {
        break;
      }
      await new Promise<void>((resolve) => {
        window.setTimeout(resolve, 40);
      });
    }
    if (
      latestResult &&
      agentChatProjectPathRef.current.trim() === pendingRun.projectPath &&
      agentChatSelectedAgentIdRef.current === pendingRun.agentId &&
      (pendingRun.sessionId === null ||
        agentChatSelectedSessionIdRef.current === pendingRun.sessionId)
    ) {
      setAgentChatMessages(latestResult.messages);
      setAgentChatConversationPath(latestResult.path);
      updateAgentChatSessionMessageCount(
        pendingRun.sessionId,
        latestResult.messages.length,
      );
      setAgentChatStatus(
        `已同步 ${latestResult.messages.length} 条：${latestResult.path}`,
      );
    }
    if (pendingRun.sessionId) {
      try {
        const goal = await invoke<AgentGoalRecord | null>(
          'read_game_creator_agent_goal',
          {
            projectPath: pendingRun.projectPath,
            agentId: pendingRun.agentId,
            sessionId: pendingRun.sessionId,
          },
        );
        if (
          agentChatProjectPathRef.current.trim() === pendingRun.projectPath &&
          agentChatSelectedAgentIdRef.current === pendingRun.agentId &&
          agentChatSelectedSessionIdRef.current === pendingRun.sessionId
        ) {
          setAgentChatGoal(goal);
          setAgentChatGoalError('');
        }
      } catch (error) {
        if (
          !isMissingAgentGoalCommandError(error) &&
          agentChatProjectPathRef.current.trim() === pendingRun.projectPath &&
          agentChatSelectedAgentIdRef.current === pendingRun.agentId &&
          agentChatSelectedSessionIdRef.current === pendingRun.sessionId
        ) {
          setAgentChatGoalError(
            `Goal 状态读取失败：${
              error instanceof Error ? error.message : String(error)
            }`,
          );
        }
      }
    }
    if (agentChatPendingRuntimeRunRef.current?.runId === pendingRun.runId) {
      setAgentChatPendingRuntimeRun(null);
    }
  }
  agentChatRuntimeSyncConversationRef.current =
    syncAgentChatConversationAfterRuntime;

  useLayoutEffect(() => {
    const messageList = agentChatMessagesRef.current;
    if (messageList && agentChatShouldFollowLatestRef.current) {
      messageList.scrollTop = messageList.scrollHeight;
    }
  }, [
    agentChatMessages,
    agentChatPendingRuntimeRun,
    agentChatReplyPhase,
    agentChatStatus,
    agentChatMessagesRef,
    agentChatShouldFollowLatestRef,
  ]);

  function handleAgentChatMessagesScroll(event: UIEvent<HTMLDivElement>) {
    const messageList = event.currentTarget;
    const distanceFromBottom =
      messageList.scrollHeight -
      messageList.scrollTop -
      messageList.clientHeight;
    agentChatShouldFollowLatestRef.current =
      distanceFromBottom <= AGENT_CHAT_SCROLL_BOTTOM_THRESHOLD;
  }

  useEffect(() => {
    const listen = window.__TAURI__?.event?.listen;
    const invoke = resolveTauriInvoke();
    // WorkspaceLauncher stays mounted while users work in a project. The
    // legacy developer Agent Runtime listener must therefore exist only on
    // the explicit developer Agent chat surface, never behind direct Codex
    // project workbenches.
    if (launcherView !== 'agent-chat' || !listen || !invoke) {
      return;
    }
    let cleanup: (() => void) | null = null;
    let disposed = false;
    void listen<GameCreatorAgentRuntimeUpdateEvent>(
      'game-creator-agent-runtime-update',
      (event) => {
        const payload = event.payload;
        if (
          payload.projectPath !== agentChatProjectPathRef.current ||
          payload.agentId !== agentChatSelectedAgentIdRef.current
        ) {
          return;
        }
        const runtimeState = agentRuntimeStateFromResult(payload.runtime);
        if (
          agentChatActiveSessionIdRef.current === null ||
          payload.runtime.state.sessionId ===
            agentChatActiveSessionIdRef.current
        ) {
          setAgentChatActiveRuntime((current) =>
            agentRuntimeStateFromResult(payload.runtime, current),
          );
        }
        if (
          agentChatSelectedSessionIdRef.current !== null &&
          payload.runtime.state.sessionId !==
            agentChatSelectedSessionIdRef.current
        ) {
          return;
        }
        setAgentChatRuntime((current) =>
          agentRuntimeStateFromResult(payload.runtime, current),
        );
        setAgentChatGoal((current) =>
          mergeAgentGoalRecordFromRuntime(current, runtimeState),
        );
        setAgentChatRuntimeError('');
        const pendingRun = agentChatPendingRuntimeRunRef.current;
        if (
          !pendingRun ||
          pendingRun.projectPath !== payload.projectPath ||
          pendingRun.agentId !== payload.agentId ||
          pendingRun.runId !== payload.runId ||
          (pendingRun.sessionId !== null &&
            pendingRun.sessionId !== payload.runtime.state.sessionId)
        ) {
          return;
        }
        setAgentChatStatus(agentRuntimeConversationStatus(runtimeState));
        if (
          isAgentRuntimeTerminalState(runtimeState) &&
          !agentChatRuntimeSyncingRunIdsRef.current.has(pendingRun.runId)
        ) {
          const syncConversation = agentChatRuntimeSyncConversationRef.current;
          if (!syncConversation) {
            return;
          }
          agentChatRuntimeSyncingRunIdsRef.current.add(pendingRun.runId);
          void syncConversation(invoke, pendingRun).finally(() => {
            agentChatRuntimeSyncingRunIdsRef.current.delete(pendingRun.runId);
          });
        }
      },
    )
      .then((unlisten) => {
        if (disposed) {
          unlisten();
          return;
        }
        cleanup = unlisten;
      })
      .catch((error) => {
        if (disposed) {
          return;
        }
        setAgentChatRuntimeError(
          `Runtime 订阅不可用：${
            error instanceof Error ? error.message : String(error)
          }`,
        );
      });
    return () => {
      disposed = true;
      cleanup?.();
    };
  }, [
    agentChatActiveSessionIdRef,
    agentChatPendingRuntimeRunRef,
    agentChatProjectPathRef,
    agentChatRuntimeSyncConversationRef,
    agentChatRuntimeSyncingRunIdsRef,
    agentChatSelectedAgentIdRef,
    agentChatSelectedSessionIdRef,
    launcherView,
    setAgentChatActiveRuntime,
    setAgentChatGoal,
    setAgentChatRuntime,
    setAgentChatRuntimeError,
    setAgentChatStatus,
  ]);

  useEffect(() => {
    const invoke = resolveTauriInvoke();
    const pendingRun = agentChatPendingRuntimeRun;
    if (!invoke || !pendingRun) {
      return;
    }
    let disposed = false;
    let inFlight = false;
    const pollRuntime = async () => {
      if (disposed || inFlight) {
        return;
      }
      inFlight = true;
      try {
        const runtime = await invoke<AgentRuntimeResult>(
          'read_game_creator_agent_runtime',
          {
            projectPath: pendingRun.projectPath,
            agentId: pendingRun.agentId,
            ...(pendingRun.sessionId
              ? { sessionId: pendingRun.sessionId }
              : {}),
          },
        );
        if (
          disposed ||
          agentChatPendingRuntimeRunRef.current?.runId !== pendingRun.runId ||
          agentChatProjectPathRef.current.trim() !== pendingRun.projectPath ||
          agentChatSelectedAgentIdRef.current !== pendingRun.agentId
        ) {
          return;
        }
        const runtimeState = agentRuntimeStateFromResult(runtime);
        const tracksPendingRun =
          runtimeState.runId === pendingRun.runId ||
          (runtimeState.recentTasks ?? []).some(
            (task) => task.runId === pendingRun.runId,
          );
        if (!tracksPendingRun) {
          return;
        }
        if (
          pendingRun.sessionId !== null &&
          runtimeState.sessionId !== pendingRun.sessionId
        ) {
          return;
        }
        setAgentChatRuntime((current) =>
          normalizeAgentRuntimeState(runtimeState, current),
        );
        setAgentChatGoal((current) =>
          mergeAgentGoalRecordFromRuntime(current, runtimeState),
        );
        if (
          agentChatActiveSessionIdRef.current === null ||
          runtimeState.sessionId === agentChatActiveSessionIdRef.current
        ) {
          setAgentChatActiveRuntime((current) =>
            normalizeAgentRuntimeState(runtimeState, current),
          );
        }
        setAgentChatRuntimeError('');
        setAgentChatStatus(agentRuntimeConversationStatus(runtimeState));
        if (
          isAgentRuntimeTerminalState(runtimeState) &&
          !agentChatRuntimeSyncingRunIdsRef.current.has(pendingRun.runId)
        ) {
          const syncConversation = agentChatRuntimeSyncConversationRef.current;
          if (!syncConversation) {
            return;
          }
          agentChatRuntimeSyncingRunIdsRef.current.add(pendingRun.runId);
          void syncConversation(invoke, pendingRun).finally(() => {
            agentChatRuntimeSyncingRunIdsRef.current.delete(pendingRun.runId);
          });
        }
      } catch (error) {
        if (!disposed) {
          setAgentChatRuntimeError(
            `Runtime 状态刷新失败：${
              error instanceof Error ? error.message : String(error)
            }`,
          );
        }
      } finally {
        inFlight = false;
      }
    };
    void pollRuntime();
    const timer = window.setInterval(() => {
      void pollRuntime();
    }, 750);
    return () => {
      disposed = true;
      window.clearInterval(timer);
    };
  }, [
    agentChatActiveSessionIdRef,
    agentChatPendingRuntimeRun,
    agentChatPendingRuntimeRunRef,
    agentChatProjectPathRef,
    agentChatRuntimeSyncConversationRef,
    agentChatRuntimeSyncingRunIdsRef,
    agentChatSelectedAgentIdRef,
    setAgentChatActiveRuntime,
    setAgentChatGoal,
    setAgentChatRuntime,
    setAgentChatRuntimeError,
    setAgentChatStatus,
  ]);

  useEffect(() => {
    if (launcherView !== 'agent-chat') {
      return;
    }
    void loadAgentChatLlmStatus();
    // Reload only when the active launcher selection changes.
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [launcherView, agentChatSelectedAgentId]);

  function validateAgentChatProjectPath(projectPath = agentChatProjectPath) {
    const trimmedProjectPath = projectPath.trim();
    if (!trimmedProjectPath || !isAbsoluteProjectPath(trimmedProjectPath)) {
      setAgentChatStatus('请提供项目绝对路径');
      return null;
    }
    if (projectPathHasControlCharacter(trimmedProjectPath)) {
      setAgentChatStatus('项目目录不能包含控制字符');
      return null;
    }
    return trimmedProjectPath;
  }

  function selectedLauncherAgentChatAgent(
    agentId = agentChatSelectedAgentId,
  ): LauncherAgentChatAgent | null {
    return (
      launcherAgentChatAgents.find((agent) => agent.id === agentId) ??
      launcherAgentChatAgents[0] ??
      null
    );
  }

  function selectedLauncherAgentChatSession(
    sessionId = agentChatSelectedSessionId,
  ): AgentConversationSessionRecord | null {
    if (!sessionId) {
      return null;
    }
    return (
      agentChatSessions.find((session) => session.sessionId === sessionId) ??
      null
    );
  }

  function agentChatSessionInvokeArgs(sessionId: string | null) {
    return sessionId ? { sessionId } : {};
  }

  function resetAgentChatSessionView() {
    agentChatShouldFollowLatestRef.current = true;
    setAgentChatReplyPhase('idle');
    setAgentChatPendingRuntimeRun(null);
    setAgentChatRunSubmitMode('steer');
    setAgentChatSessions([]);
    setAgentChatSelectedSessionId(null);
    setAgentChatActiveSessionId(null);
    setAgentChatLegacySessionMode(false);
    setAgentChatActiveRuntime(null);
    setAgentChatRuntime(null);
    setAgentChatRuntimeError('');
    setAgentChatGoal(null);
    setAgentChatGoalError('');
    setAgentChatGoalDialog(null);
    setAgentChatGoalDialogError('');
    setAgentChatConversationPath('');
    setAgentChatSessionStatus('');
    setAgentChatMessages([]);
  }

  function updateAgentChatSessionMessageCount(
    sessionId: string | null,
    messageCount: number,
  ) {
    if (!sessionId) {
      return;
    }
    setAgentChatSessions((sessions) =>
      sessions.map((session) =>
        session.sessionId === sessionId
          ? { ...session, messageCount, updatedAt: Date.now() }
          : session,
      ),
    );
  }

  function getCurrentAgentChatLlmWarning(
    agent = selectedLauncherAgentChatAgent(),
  ) {
    if (!agent) {
      return null;
    }
    return formatAgentLlmConfigWarning(agentChatLlmConfigStatus, agent);
  }

  async function loadAgentChatLlmStatus() {
    const invoke = resolveTauriInvoke();
    if (!invoke) {
      setAgentChatLlmConfigStatus(null);
      setAgentChatLlmStatus('需要在 Tauri App 内检查 LLM 配置');
      return;
    }
    setAgentChatLlmStatus('正在检查 LLM 配置');
    try {
      const status = await invoke<GameCreatorLlmConfigStatus>(
        'check_game_creator_llm_config',
      );
      setAgentChatLlmConfigStatus(status);
      const agent = selectedLauncherAgentChatAgent();
      const agentStatus = agent ? llmStatusForAgentCard(status, agent) : null;
      if (!agentStatus) {
        setAgentChatLlmStatus('未找到当前 Agent 的 LLM 路由');
        return;
      }
      setAgentChatLlmStatus(
        isCodexAgentMode(agentStatus.agentMode)
          ? agentStatus.configured
            ? `当前 Agent 已检测到 ${formatCodexAgentModeLabel(
                agentStatus.agentMode,
              )}；${formatCodexRuntimeCapabilities(agentStatus)}；登录与网络将在首次调用时验证`
            : `当前 Agent ${formatCodexAgentModeLabel(
                agentStatus.agentMode,
              )} 未就绪；${formatCodexRuntimeCapabilities(agentStatus)}：${
                agentStatus.error ?? 'Codex CLI 不可用'
              }`
          : agentStatus.configured
            ? `当前 Agent LLM 已配置：${agentStatus.model ?? '未命名模型'}${
                agentStatus.reasoningEffort
                  ? `，推理 ${agentStatus.reasoningEffort}`
                  : ''
              }，联网检索 ${agentStatus.webSearchEnabled ? '开启' : '关闭'}，API Key ${
                agentStatus.apiKeyPresent ? '已读取' : '未读取'
              }`
            : `当前 Agent LLM 未就绪：${
                agentStatus.error ?? '缺少 API Key 或模型配置'
              }${
                agentStatus.reasoningEffort
                  ? `（推理 ${agentStatus.reasoningEffort}）`
                  : ''
              }，联网检索 ${agentStatus.webSearchEnabled ? '开启' : '关闭'}`,
      );
    } catch (error) {
      setAgentChatLlmConfigStatus(null);
      setAgentChatLlmStatus(
        `LLM 状态读取失败：${error instanceof Error ? error.message : String(error)}`,
      );
    }
  }

  function cancelAgentChatRuntimeResume() {
    setAgentChatResumeConfirmation(null);
    setAgentChatStatus('已取消恢复 Agent Runtime 任务');
  }

  async function confirmAgentChatRuntimeResume() {
    const pending = agentChatResumeConfirmation;
    const invoke = resolveTauriInvoke();
    if (!pending || !invoke) {
      return;
    }
    setAgentChatResumeConfirmation(null);
    setAgentChatStatus('正在恢复 Agent Runtime 任务');
    try {
      await invoke<AgentRuntimeResult[]>(
        'confirm_resume_game_creator_agent_runtime_tasks',
        { projectPath: pending.projectPath },
      );
      if (agentChatProjectPathRef.current.trim() !== pending.projectPath) {
        return;
      }
      agentChatRuntimeResumeProjectPathRef.current = pending.projectPath;
      await loadAgentChatConversation(
        agentChatSelectedAgentIdRef.current,
        pending.projectPath,
        agentChatSelectedSessionIdRef.current,
      );
      setAgentChatStatus('已确认恢复 Agent Runtime 任务');
    } catch (error) {
      if (agentChatProjectPathRef.current.trim() !== pending.projectPath) {
        return;
      }
      agentChatRuntimeResumeProjectPathRef.current = null;
      setAgentChatStatus(
        `Agent Runtime 恢复失败：${
          error instanceof Error ? error.message : String(error)
        }`,
      );
    }
  }

  async function resumeAgentChatRuntimeTasksIfNeeded(
    invoke: TauriInvoke,
    projectPathForChat: string,
  ) {
    if (agentChatRuntimeResumeProjectPathRef.current === projectPathForChat) {
      return '';
    }
    try {
      await invoke<AgentRuntimeResult[]>(
        'resume_game_creator_agent_runtime_tasks',
        { projectPath: projectPathForChat },
      );
      agentChatRuntimeResumeProjectPathRef.current = projectPathForChat;
      return '';
    } catch (error) {
      const message = error instanceof Error ? error.message : String(error);
      if (isMissingAgentRuntimeResumeCommandError(error)) {
        agentChatRuntimeResumeProjectPathRef.current = projectPathForChat;
        return '';
      }
      if (message.includes('项目权限策略要求用户确认：agent.resume')) {
        agentChatRuntimeResumeProjectPathRef.current = projectPathForChat;
        setAgentChatResumeConfirmation({
          projectPath: projectPathForChat,
          detail: `恢复 ${projectPathForChat} 中未完成的 Agent Runtime 任务`,
        });
        return '；等待确认恢复 Agent Runtime 任务';
      }
      if (message.includes('项目权限策略拒绝执行：agent.resume')) {
        agentChatRuntimeResumeProjectPathRef.current = projectPathForChat;
        return '；项目策略禁止恢复 Agent Runtime 任务';
      }
      agentChatRuntimeResumeProjectPathRef.current = null;
      return `；Agent Runtime 恢复检查失败：${message}`;
    }
  }

  useEscapeToClose(
    cancelAgentChatRuntimeResume,
    agentChatResumeConfirmation !== null,
  );

  function closeAgentChatGoalDialog() {
    if (agentChatBackgroundBusy) {
      return;
    }
    setAgentChatGoalDialog(null);
    setAgentChatGoalDialogError('');
  }

  useEscapeToClose(
    closeAgentChatGoalDialog,
    agentChatGoalDialog !== null && !agentChatBackgroundBusy,
  );

  async function handleOpenProjectSupervisorChatWindow() {
    if (agentChatBusy || agentChatBackgroundBusy) {
      return;
    }
    const projectPathForChat = validateAgentChatProjectPath();
    if (!projectPathForChat) {
      return;
    }
    const invoke = resolveTauriInvoke();
    if (!invoke) {
      setAgentChatStatus('需要在 Tauri App 内运行');
      return;
    }
    setAgentChatStatus('正在打开项目总控对话');
    try {
      await invoke('open_project_supervisor_chat_window', {
        projectPath: projectPathForChat,
      });
      setAgentChatStatus('已打开项目总控对话');
    } catch (error) {
      setAgentChatStatus(
        error instanceof Error ? error.message : String(error),
      );
    }
  }

  async function handleAgentChatPickProjectDirectory() {
    if (agentChatBusy || agentChatBackgroundBusy) {
      return;
    }
    const invoke = resolveTauriInvoke();
    if (!invoke) {
      setAgentChatStatus('需要在 Tauri App 内运行');
      return;
    }
    setAgentChatStatus('正在选择');
    try {
      const selectedPath = await invoke<string | null>(
        'pick_local_project_directory',
        agentChatProjectPath.trim()
          ? { initialPath: agentChatProjectPath.trim() }
          : undefined,
      );
      if (!selectedPath) {
        setAgentChatStatus('已取消');
        return;
      }
      setAgentChatStatus('已选择项目目录');
      resetAgentChatSessionView();
      agentChatRuntimeResumeProjectPathRef.current = null;
      setAgentChatResumeConfirmation(null);
      setAgentChatProjectPath(selectedPath);
      void loadAgentChatConversation(agentChatSelectedAgentId, selectedPath);
    } catch (error) {
      setAgentChatStatus(
        error instanceof Error ? error.message : String(error),
      );
    }
  }

  async function loadAgentChatConversation(
    agentId = agentChatSelectedAgentId,
    projectPath = agentChatProjectPath,
    requestedSessionId?: string | null,
    knownSessions?: AgentConversationSessionListResult | null,
  ) {
    const projectPathForChat = validateAgentChatProjectPath(projectPath);
    const agent = selectedLauncherAgentChatAgent(agentId);
    if (!projectPathForChat || !agent) {
      return;
    }
    agentChatShouldFollowLatestRef.current = true;
    const pendingRun = agentChatPendingRuntimeRunRef.current;
    if (
      pendingRun &&
      (pendingRun.projectPath !== projectPathForChat ||
        pendingRun.agentId !== agent.id ||
        (requestedSessionId !== undefined &&
          pendingRun.sessionId !== requestedSessionId))
    ) {
      setAgentChatPendingRuntimeRun(null);
    }
    const invoke = resolveTauriInvoke();
    if (!invoke) {
      setAgentChatStatus('需要在 Tauri App 内运行');
      return;
    }
    const loadVersion = agentChatLoadVersionRef.current + 1;
    agentChatLoadVersionRef.current = loadVersion;
    setAgentChatBusy(true);
    setAgentChatGoal(null);
    setAgentChatGoalError('');
    setAgentChatStatus('正在读取');
    try {
      const runtimeResumeStatus = await resumeAgentChatRuntimeTasksIfNeeded(
        invoke,
        projectPathForChat,
      );
      if (agentChatLoadVersionRef.current !== loadVersion) {
        return;
      }
      let sessionList = knownSessions;
      let sessionListError = '';
      if (sessionList === undefined) {
        try {
          const candidate = await invoke<AgentConversationSessionListResult>(
            'list_game_creator_agent_sessions',
            {
              projectPath: projectPathForChat,
              agentId: agent.id,
            },
          );
          if (candidate === undefined || candidate === null) {
            sessionList = null;
            sessionListError = '当前客户端后端不支持多会话命令';
          } else if (!Array.isArray(candidate.sessions)) {
            setAgentChatSessionStatus('Agent 会话列表返回格式无效');
            setAgentChatStatus('Agent 会话列表返回格式无效，已停止读取');
            return;
          } else {
            sessionList = candidate;
          }
        } catch (error) {
          if (!isMissingAgentSessionCommandError(error)) {
            const message =
              error instanceof Error ? error.message : String(error);
            setAgentChatSessionStatus(`Agent 会话列表读取失败：${message}`);
            setAgentChatStatus(`Agent 会话列表读取失败：${message}`);
            return;
          }
          sessionList = null;
          sessionListError = '当前客户端后端不支持多会话命令';
        }
      }
      if (agentChatLoadVersionRef.current !== loadVersion) {
        return;
      }

      let sessionId = requestedSessionId ?? null;
      let resolvedActiveSessionId = agentChatActiveSessionId;
      if (sessionList) {
        const requestedExists = sessionList.sessions.some(
          (session) => session.sessionId === sessionId,
        );
        if (!requestedExists) {
          sessionId =
            sessionList.activeSessionId ||
            sessionList.sessions.find((session) => session.archivedAt === null)
              ?.sessionId ||
            sessionList.sessions[0]?.sessionId ||
            null;
        }
        setAgentChatSessions(sessionList.sessions);
        setAgentChatSelectedSessionId(sessionId);
        resolvedActiveSessionId = sessionList.activeSessionId || null;
        setAgentChatActiveSessionId(resolvedActiveSessionId);
        setAgentChatLegacySessionMode(false);
        setAgentChatSessionStatus(
          sessionList.sessions.length > 0
            ? `共 ${sessionList.sessions.length} 个会话`
            : '暂无会话',
        );
      } else {
        sessionId = null;
        resolvedActiveSessionId = null;
        setAgentChatSessions([]);
        setAgentChatSelectedSessionId(null);
        setAgentChatActiveSessionId(null);
        setAgentChatLegacySessionMode(true);
        setAgentChatSessionStatus(
          sessionListError
            ? `会话列表不可用，已使用旧版单会话：${sessionListError}`
            : '已使用旧版单会话',
        );
      }

      const selectedSessionIsActive =
        sessionId === resolvedActiveSessionId ||
        (sessionId === null && resolvedActiveSessionId === null);
      setAgentChatRuntime(null);
      setAgentChatRuntimeError('');

      if (sessionId) {
        try {
          const goal = await invoke<AgentGoalRecord | null>(
            'read_game_creator_agent_goal',
            {
              projectPath: projectPathForChat,
              agentId: agent.id,
              sessionId,
            },
          );
          if (agentChatLoadVersionRef.current !== loadVersion) {
            return;
          }
          setAgentChatGoal(goal);
          setAgentChatGoalError('');
        } catch (error) {
          if (agentChatLoadVersionRef.current !== loadVersion) {
            return;
          }
          setAgentChatGoal(null);
          setAgentChatGoalError(
            isMissingAgentGoalCommandError(error)
              ? ''
              : `Goal 状态读取失败：${
                  error instanceof Error ? error.message : String(error)
                }`,
          );
        }
      }

      const result = await invoke<LocalConversationResult>(
        'read_local_conversation',
        {
          projectPath: projectPathForChat,
          agentId: agent.id,
          ...agentChatSessionInvokeArgs(sessionId),
        },
      );
      if (agentChatLoadVersionRef.current !== loadVersion) {
        return;
      }
      setAgentChatMessages(result.messages);
      updateAgentChatSessionMessageCount(sessionId, result.messages.length);
      setAgentChatConversationPath(result.path);
      try {
        const runtime = await invoke<AgentRuntimeResult>(
          'read_game_creator_agent_runtime',
          {
            projectPath: projectPathForChat,
            agentId: agent.id,
            ...agentChatSessionInvokeArgs(sessionId),
          },
        );
        if (agentChatLoadVersionRef.current === loadVersion) {
          const runtimeState = agentRuntimeStateFromResult(runtime);
          setAgentChatRuntime(runtimeState);
          if (selectedSessionIsActive) {
            setAgentChatActiveRuntime(runtimeState);
          }
          setAgentChatGoal((current) =>
            mergeAgentGoalRecordFromRuntime(current, runtimeState),
          );
          setAgentChatRuntimeError('');
        }
      } catch (error) {
        if (agentChatLoadVersionRef.current === loadVersion) {
          setAgentChatRuntime(null);
          if (selectedSessionIsActive) {
            setAgentChatActiveRuntime(null);
          }
          setAgentChatRuntimeError(
            error instanceof Error ? error.message : String(error),
          );
        }
      }
      setAgentChatStatus(
        `已读取 ${result.messages.length} 条：${result.path}${runtimeResumeStatus}`,
      );
    } catch (error) {
      if (agentChatLoadVersionRef.current !== loadVersion) {
        return;
      }
      setAgentChatMessages([]);
      setAgentChatConversationPath('');
      setAgentChatGoal(null);
      setAgentChatStatus(
        error instanceof Error ? error.message : String(error),
      );
    } finally {
      if (agentChatLoadVersionRef.current === loadVersion) {
        setAgentChatBusy(false);
      }
    }
  }

  async function handleAgentChatSelectSession(
    session: AgentConversationSessionRecord,
  ) {
    const projectPathForChat = validateAgentChatProjectPath();
    const agent = selectedLauncherAgentChatAgent();
    if (
      !projectPathForChat ||
      !agent ||
      agentChatBusy ||
      agentChatBackgroundBusy
    ) {
      return;
    }
    const invoke = resolveTauriInvoke();
    if (!invoke) {
      setAgentChatStatus('需要在 Tauri App 内运行');
      return;
    }
    if (session.archivedAt !== null) {
      await loadAgentChatConversation(
        agent.id,
        projectPathForChat,
        session.sessionId,
        {
          path: '',
          agentId: agent.id,
          activeSessionId:
            agentChatActiveSessionId ??
            agentChatSessions.find((candidate) => candidate.archivedAt === null)
              ?.sessionId ??
            session.sessionId,
          sessions: agentChatSessions,
        },
      );
      return;
    }
    if (
      session.sessionId === agentChatSelectedSessionId ||
      session.sessionId === agentChatActiveSessionId
    ) {
      await loadAgentChatConversation(
        agent.id,
        projectPathForChat,
        session.sessionId,
        {
          path: '',
          agentId: agent.id,
          activeSessionId: session.sessionId,
          sessions: agentChatSessions,
        },
      );
      return;
    }
    setAgentChatBusy(true);
    setAgentChatStatus('正在切换会话');
    try {
      const result = await invoke<AgentConversationSessionListResult>(
        'set_active_game_creator_agent_session',
        {
          projectPath: projectPathForChat,
          agentId: agent.id,
          sessionId: session.sessionId,
        },
      );
      await loadAgentChatConversation(
        agent.id,
        projectPathForChat,
        session.sessionId,
        result,
      );
    } catch (error) {
      setAgentChatStatus(
        error instanceof Error ? error.message : String(error),
      );
      setAgentChatBusy(false);
    }
  }

  async function handleAgentChatCreateSession() {
    const projectPathForChat = validateAgentChatProjectPath();
    const agent = selectedLauncherAgentChatAgent();
    if (
      !projectPathForChat ||
      !agent ||
      agentChatBusy ||
      agentChatBackgroundBusy
    ) {
      return;
    }
    const invoke = resolveTauriInvoke();
    if (!invoke) {
      setAgentChatStatus('需要在 Tauri App 内运行');
      return;
    }
    setAgentChatBusy(true);
    setAgentChatStatus('正在新建会话');
    try {
      const result = await invoke<AgentConversationSessionListResult>(
        'create_game_creator_agent_session',
        {
          projectPath: projectPathForChat,
          agentId: agent.id,
          title: '',
        },
      );
      await loadAgentChatConversation(
        agent.id,
        projectPathForChat,
        result.activeSessionId,
        result,
      );
    } catch (error) {
      setAgentChatStatus(
        error instanceof Error ? error.message : String(error),
      );
      setAgentChatBusy(false);
    }
  }

  async function handleAgentChatForkSession() {
    const projectPathForChat = validateAgentChatProjectPath();
    const agent = selectedLauncherAgentChatAgent();
    const sourceSession = selectedLauncherAgentChatSession();
    if (
      !projectPathForChat ||
      !agent ||
      !sourceSession ||
      agentChatBusy ||
      agentChatBackgroundBusy
    ) {
      return;
    }
    const invoke = resolveTauriInvoke();
    if (!invoke) {
      setAgentChatStatus('需要在 Tauri App 内运行');
      return;
    }
    setAgentChatBusy(true);
    setAgentChatStatus('正在分叉会话');
    try {
      const result = await invoke<AgentConversationSessionListResult>(
        'fork_game_creator_agent_session',
        {
          projectPath: projectPathForChat,
          agentId: agent.id,
          sourceSessionId: sourceSession.sessionId,
          title: '',
        },
      );
      await loadAgentChatConversation(
        agent.id,
        projectPathForChat,
        result.activeSessionId,
        result,
      );
      setAgentChatStatus(`已从“${sourceSession.title}”分叉新会话`);
    } catch (error) {
      setAgentChatStatus(
        error instanceof Error ? error.message : String(error),
      );
      setAgentChatBusy(false);
    }
  }

  async function handleAgentChatArchiveSession() {
    const projectPathForChat = validateAgentChatProjectPath();
    const agent = selectedLauncherAgentChatAgent();
    const session = selectedLauncherAgentChatSession();
    if (
      !projectPathForChat ||
      !agent ||
      !session ||
      session.legacy ||
      session.archivedAt !== null ||
      agentChatBusy ||
      agentChatBackgroundBusy
    ) {
      return;
    }
    const invoke = resolveTauriInvoke();
    if (!invoke) {
      setAgentChatStatus('需要在 Tauri App 内运行');
      return;
    }
    setAgentChatBusy(true);
    setAgentChatStatus('正在归档会话');
    try {
      const result = await invoke<AgentConversationSessionListResult>(
        'archive_game_creator_agent_session',
        {
          projectPath: projectPathForChat,
          agentId: agent.id,
          sessionId: session.sessionId,
        },
      );
      await loadAgentChatConversation(
        agent.id,
        projectPathForChat,
        result.activeSessionId,
        result,
      );
    } catch (error) {
      setAgentChatStatus(
        error instanceof Error ? error.message : String(error),
      );
      setAgentChatBusy(false);
    }
  }

  async function handleAgentChatSubmit(event: FormEvent<HTMLFormElement>) {
    event.preventDefault();
    const projectPathForChat = validateAgentChatProjectPath();
    const agent = selectedLauncherAgentChatAgent();
    const sessionIdForChat = agentChatSelectedSessionId;
    const selectedSession = selectedLauncherAgentChatSession(sessionIdForChat);
    const content = agentChatInput.trim();
    if (agentRuntimeNeedsUserInput(agentChatRuntime)) {
      setAgentChatStatus('请先回答 Agent 当前的澄清问题');
      return;
    }
    if (
      !projectPathForChat ||
      !agent ||
      !content ||
      agentChatBusy ||
      agentChatBackgroundBusy
    ) {
      return;
    }
    if (selectedSession && selectedSession.archivedAt !== null) {
      setAgentChatStatus('已归档会话只能查看，请先新建或切换到活动会话');
      return;
    }
    const llmWarning = getCurrentAgentChatLlmWarning(agent);
    if (llmWarning) {
      setAgentChatStatus(llmWarning);
      return;
    }
    const invoke = resolveTauriInvoke();
    if (!invoke) {
      setAgentChatStatus('需要在 Tauri App 内运行');
      return;
    }
    const saveVersion = agentChatLoadVersionRef.current + 1;
    agentChatLoadVersionRef.current = saveVersion;
    agentChatShouldFollowLatestRef.current = true;
    setAgentChatBusy(true);
    setAgentChatReplyPhase('saving-user');
    setAgentChatInput('');
    setAgentChatStatus('正在保存用户消息');
    let savedUserResult: LocalConversationResult | null = null;
    let stopStreamListen: (() => void) | null = null;
    let streamListenDisposed = false;
    let streamListenReady = false;
    let streamListenUnavailable = false;
    let streamFrameId: number | null = null;
    let pendingStreamDraftText = '';
    let pendingStreamFinishReason: string | null = null;
    const streamDraftUpdatedAt = Date.now();
    try {
      savedUserResult = await invoke<LocalConversationResult>(
        'append_local_conversation_message',
        {
          projectPath: projectPathForChat,
          agentId: agent.id,
          ...agentChatSessionInvokeArgs(sessionIdForChat),
          message: {
            role: 'user',
            content,
            agentId: null,
          },
        },
      );
      if (agentChatLoadVersionRef.current !== saveVersion) {
        return;
      }
      const savedUserMessages = savedUserResult.messages;
      setAgentChatMessages(savedUserMessages);
      updateAgentChatSessionMessageCount(
        sessionIdForChat,
        savedUserMessages.length,
      );
      setAgentChatReplyPhase('connecting');
      setAgentChatStatus('正在连接 Agent LLM');
      const streamRunId = createAgentChatRunId('launcher-agent-chat');
      const listen = window.__TAURI__?.event?.listen;
      if (listen) {
        try {
          stopStreamListen = await listen<GameCreatorRoleAgentChatStreamEvent>(
            'game-creator-role-agent-chat-stream',
            (event) => {
              const payload = event.payload;
              if (
                payload.projectPath !== projectPathForChat ||
                payload.agentId !== agent.id ||
                payload.runId !== streamRunId ||
                agentChatLoadVersionRef.current !== saveVersion
              ) {
                return;
              }
              if (payload.runtimeState && payload.status !== 'delta') {
                setAgentChatRuntime((current) =>
                  normalizeAgentRuntimeState(payload.runtimeState!, current),
                );
                setAgentChatActiveRuntime((current) =>
                  normalizeAgentRuntimeState(payload.runtimeState!, current),
                );
                setAgentChatRuntimeError('');
              }
              if (payload.status === 'started') {
                setAgentChatReplyPhase('waiting-first-content');
                setAgentChatStatus(
                  payload.runtimeSummary
                    ? `已连接 Agent LLM，${payload.runtimeSummary}`
                    : '已连接 Agent LLM，正在等待首个回复片段',
                );
                return;
              }
              if (payload.status === 'delta') {
                setAgentChatReplyPhase('streaming');
                const draftText = payload.accumulatedText || payload.deltaText;
                if (draftText) {
                  pendingStreamDraftText = draftText;
                }
                pendingStreamFinishReason = payload.finishReason ?? null;
                if (streamFrameId === null) {
                  streamFrameId = window.requestAnimationFrame(() => {
                    streamFrameId = null;
                    if (agentChatLoadVersionRef.current !== saveVersion) {
                      return;
                    }
                    if (pendingStreamDraftText) {
                      setAgentChatMessages([
                        ...savedUserMessages,
                        createLocalConversationDraftMessage(
                          pendingStreamDraftText,
                          streamDraftUpdatedAt,
                        ),
                      ]);
                    }
                    setAgentChatStatus(
                      pendingStreamFinishReason
                        ? `Agent 回复结束：${pendingStreamFinishReason}`
                        : '正在接收 Agent 回复',
                    );
                  });
                }
                return;
              }
              if (payload.status === 'completed') {
                if (streamFrameId !== null) {
                  window.cancelAnimationFrame(streamFrameId);
                  streamFrameId = null;
                }
                setAgentChatReplyPhase('saving-reply');
                setAgentChatStatus(
                  payload.runtimeSummary ?? 'Agent 回复完成，正在保存',
                );
                return;
              }
              if (payload.status === 'failed') {
                if (streamFrameId !== null) {
                  window.cancelAnimationFrame(streamFrameId);
                  streamFrameId = null;
                }
                setAgentChatReplyPhase('saving-reply');
                setAgentChatStatus(
                  payload.runtimeSummary ?? 'Agent 流式回复失败，正在记录错误',
                );
              }
            },
          );
          streamListenReady = true;
          if (streamListenDisposed) {
            stopStreamListen();
            stopStreamListen = null;
          }
        } catch {
          streamListenUnavailable = true;
          setAgentChatStatus('实时状态不可用，正在使用普通回复模式');
        }
      }
      setAgentChatStatus(
        streamListenReady
          ? '已连接 Agent LLM，正在等待首个回复片段'
          : streamListenUnavailable
            ? '实时状态不可用，正在使用普通回复模式'
            : '正在等待 Agent LLM 回复',
      );
      setAgentChatReplyPhase('waiting-first-content');
      let reply: GameCreatorChatAgentReply;
      if (streamListenReady) {
        try {
          reply = await invoke<GameCreatorChatAgentReply>(
            'chat_with_game_creator_role_agent_stream',
            {
              projectPath: projectPathForChat,
              agentId: agent.id,
              prompt: content,
              runId: streamRunId,
              ...agentChatSessionInvokeArgs(sessionIdForChat),
            },
          );
        } catch (error) {
          if (pendingStreamDraftText && pendingStreamFinishReason) {
            reply = { replyText: pendingStreamDraftText };
            setAgentChatStatus(
              `Agent 回复已结束（${pendingStreamFinishReason}），正在保存已接收内容`,
            );
          } else {
            throw error;
          }
        }
      } else {
        reply = await invoke<GameCreatorChatAgentReply>(
          'chat_with_game_creator_role_agent',
          {
            projectPath: projectPathForChat,
            agentId: agent.id,
            prompt: content,
            ...agentChatSessionInvokeArgs(sessionIdForChat),
          },
        );
      }
      if (agentChatLoadVersionRef.current !== saveVersion) {
        return;
      }
      try {
        const runtime = await invoke<AgentRuntimeResult>(
          'read_game_creator_agent_runtime',
          {
            projectPath: projectPathForChat,
            agentId: agent.id,
            ...agentChatSessionInvokeArgs(sessionIdForChat),
          },
        );
        if (agentChatLoadVersionRef.current === saveVersion) {
          const runtimeState = agentRuntimeStateFromResult(runtime);
          setAgentChatRuntime(runtimeState);
          setAgentChatActiveRuntime(runtimeState);
          setAgentChatGoal((current) =>
            mergeAgentGoalRecordFromRuntime(current, runtimeState),
          );
          setAgentChatRuntimeError('');
        }
      } catch (error) {
        if (agentChatLoadVersionRef.current === saveVersion) {
          setAgentChatRuntimeError(
            error instanceof Error ? error.message : String(error),
          );
        }
      }
      if (streamFrameId !== null) {
        window.cancelAnimationFrame(streamFrameId);
        streamFrameId = null;
      }
      setAgentChatReplyPhase('saving-reply');
      setAgentChatStatus('正在保存 Agent 回复');
      setAgentChatMessages([
        ...savedUserMessages,
        createLocalConversationDraftMessage(
          reply.replyText,
          streamDraftUpdatedAt,
        ),
      ]);
      const assistantResult = await invoke<LocalConversationResult>(
        'append_local_conversation_message',
        {
          projectPath: projectPathForChat,
          agentId: agent.id,
          ...agentChatSessionInvokeArgs(sessionIdForChat),
          message: {
            role: 'assistant',
            content: reply.replyText,
            agentId: null,
          },
        },
      );
      if (agentChatLoadVersionRef.current !== saveVersion) {
        return;
      }
      setAgentChatMessages(assistantResult.messages);
      updateAgentChatSessionMessageCount(
        sessionIdForChat,
        assistantResult.messages.length,
      );
      setAgentChatStatus(
        `已保存 ${assistantResult.messages.length} 条：${assistantResult.path}`,
      );
    } catch (error) {
      if (agentChatLoadVersionRef.current !== saveVersion) {
        return;
      }
      if (savedUserResult) {
        const message = `已保存用户消息；Agent 回复失败：${
          error instanceof Error ? error.message : String(error)
        }`;
        try {
          const errorResult = await invoke<LocalConversationResult>(
            'append_local_conversation_message',
            {
              projectPath: projectPathForChat,
              agentId: agent.id,
              ...agentChatSessionInvokeArgs(sessionIdForChat),
              message: {
                role: 'assistant',
                content: message,
                agentId: null,
              },
            },
          );
          if (agentChatLoadVersionRef.current !== saveVersion) {
            return;
          }
          setAgentChatMessages(errorResult.messages);
          updateAgentChatSessionMessageCount(
            sessionIdForChat,
            errorResult.messages.length,
          );
        } catch {
          setAgentChatMessages([
            ...savedUserResult.messages,
            {
              schemaVersion: 'game-creator-conversation.v1',
              role: 'assistant',
              content: message,
              agentId: null,
              updatedAt: Date.now(),
            },
          ]);
        }
        setAgentChatStatus(message);
      } else {
        setAgentChatInput(content);
        setAgentChatStatus(
          error instanceof Error ? error.message : String(error),
        );
      }
    } finally {
      streamListenDisposed = true;
      stopStreamListen?.();
      if (streamFrameId !== null) {
        window.cancelAnimationFrame(streamFrameId);
      }
      if (agentChatLoadVersionRef.current === saveVersion) {
        setAgentChatReplyPhase('idle');
        setAgentChatBusy(false);
      }
    }
  }

  async function handleAgentChatStartBackgroundTask() {
    const projectPathForChat = validateAgentChatProjectPath();
    const agent = selectedLauncherAgentChatAgent();
    const sessionIdForTask = agentChatSelectedSessionId;
    const selectedSession = selectedLauncherAgentChatSession(sessionIdForTask);
    const content = agentChatInput.trim();
    if (agentRuntimeNeedsUserInput(agentChatRuntime)) {
      setAgentChatStatus('请先回答 Agent 当前的澄清问题');
      return;
    }
    if (
      !projectPathForChat ||
      !agent ||
      !content ||
      agentChatBusy ||
      agentChatBackgroundBusy
    ) {
      return;
    }
    if (selectedSession && selectedSession.archivedAt !== null) {
      setAgentChatStatus('已归档会话不能启动任务，请先新建或切换会话');
      return;
    }
    const llmWarning = getCurrentAgentChatLlmWarning(agent);
    if (llmWarning) {
      setAgentChatStatus(llmWarning);
      return;
    }
    const invoke = resolveTauriInvoke();
    if (!invoke) {
      setAgentChatStatus('需要在 Tauri App 内运行');
      return;
    }
    const saveVersion = agentChatLoadVersionRef.current + 1;
    agentChatLoadVersionRef.current = saveVersion;
    agentChatShouldFollowLatestRef.current = true;
    const steerRuntime =
      agentChatRunSubmitMode === 'steer'
        ? matchingAgentRuntimeForSteer(
            [agentChatRuntime, agentChatActiveRuntime],
            agent.id,
            sessionIdForTask,
          )
        : null;
    const requestedRunId =
      steerRuntime?.runId ?? createAgentChatRunId('launcher-agent-task');
    let pendingRunId = requestedRunId;
    const previousPendingRun = agentChatPendingRuntimeRunRef.current;
    setAgentChatBackgroundBusy(true);
    if (steerRuntime) {
      setAgentChatStatus(`正在向当前 Run 追加指令：${steerRuntime.runId}`);
    } else {
      setAgentChatInput('');
      setAgentChatPendingRuntimeRun({
        projectPath: projectPathForChat,
        agentId: agent.id,
        sessionId: sessionIdForTask,
        runId: requestedRunId,
        messageCount: agentChatMessages.length,
      });
      setAgentChatStatus('正在启动 Agent 后台任务');
    }
    try {
      let runtime: AgentRuntimeResult;
      let successStatus: string;
      if (steerRuntime) {
        const steer = await invoke<AgentRuntimeSteerResult>(
          'steer_game_creator_agent_runtime_task',
          {
            projectPath: projectPathForChat,
            agentId: agent.id,
            sessionId: steerRuntime.sessionId,
            runId: steerRuntime.runId,
            steerId: createAgentChatRunId('launcher-agent-steer'),
            instruction: content,
          },
        );
        runtime = steer.runtime;
        successStatus = agentRuntimeSteerStatus(steer);
      } else {
        runtime = await invoke<AgentRuntimeResult>(
          'start_game_creator_agent_runtime_task',
          {
            projectPath: projectPathForChat,
            agentId: agent.id,
            task: content,
            runId: requestedRunId,
            ...agentChatSessionInvokeArgs(sessionIdForTask),
          },
        );
        successStatus = agentRuntimeStartStatus(runtime);
      }
      if (agentChatLoadVersionRef.current !== saveVersion) {
        return;
      }
      const runtimeState = agentRuntimeStateFromResult(runtime);
      pendingRunId = steerRuntime
        ? runtimeState.runId
        : agentRuntimeStartedRunId(runtime, requestedRunId);
      setAgentChatInput('');
      setAgentChatRunSubmitMode('steer');
      setAgentChatPendingRuntimeRun({
        projectPath: projectPathForChat,
        agentId: agent.id,
        sessionId: sessionIdForTask,
        runId: pendingRunId,
        messageCount: agentChatMessages.length,
      });
      setAgentChatRuntime(runtimeState);
      setAgentChatActiveRuntime(runtimeState);
      setAgentChatGoal((current) =>
        mergeAgentGoalRecordFromRuntime(current, runtimeState),
      );
      setAgentChatRuntimeError('');
      try {
        const conversation = await invoke<LocalConversationResult>(
          'read_local_conversation',
          {
            projectPath: projectPathForChat,
            agentId: agent.id,
            ...agentChatSessionInvokeArgs(sessionIdForTask),
          },
        );
        if (agentChatLoadVersionRef.current !== saveVersion) {
          return;
        }
        setAgentChatMessages(conversation.messages);
        if (agentChatPendingRuntimeRunRef.current?.runId === pendingRunId) {
          setAgentChatPendingRuntimeRun({
            ...agentChatPendingRuntimeRunRef.current,
            messageCount: conversation.messages.length,
          });
        }
        setAgentChatConversationPath(conversation.path);
        updateAgentChatSessionMessageCount(
          sessionIdForTask,
          conversation.messages.length,
        );
      } catch (error) {
        if (agentChatLoadVersionRef.current === saveVersion) {
          setAgentChatRuntimeError(
            `对话刷新失败：${
              error instanceof Error ? error.message : String(error)
            }`,
          );
        }
      }
      setAgentChatStatus(successStatus);
    } catch (error) {
      if (agentChatLoadVersionRef.current !== saveVersion) {
        return;
      }
      if (
        !steerRuntime &&
        agentChatPendingRuntimeRunRef.current?.runId === pendingRunId
      ) {
        setAgentChatPendingRuntimeRun(previousPendingRun);
      }
      setAgentChatInput(content);
      setAgentChatStatus(
        error instanceof Error ? error.message : String(error),
      );
    } finally {
      if (agentChatLoadVersionRef.current === saveVersion) {
        setAgentChatBackgroundBusy(false);
      }
    }
  }

  const {
    openAgentChatGoalDialog,
    handleAgentChatGoalDialogSubmit,
    handleAgentChatGoalControl,
    handleAgentChatCompactContext,
    handleAgentChatCancelRuntimeTask,
    handleAgentChatRetryRuntimeTask,
    handleAgentChatConfirmRuntimeTask,
    handleAgentChatRejectRuntimeTask,
    handleAgentChatSubmitUserInput,
  } = createDeveloperAgentControls({
    state,
    validateAgentChatProjectPath,
    selectedLauncherAgentChatAgent,
    selectedLauncherAgentChatSession,
    agentChatSessionInvokeArgs,
    updateAgentChatSessionMessageCount,
    getCurrentAgentChatLlmWarning,
    setAgentChatPendingRuntimeRun,
  });

  const currentAgentChatAgent = selectedLauncherAgentChatAgent();
  const currentAgentChatSession = selectedLauncherAgentChatSession();
  const currentAgentChatSessionArchived =
    currentAgentChatSession?.archivedAt !== null &&
    currentAgentChatSession?.archivedAt !== undefined;
  const currentAgentChatRuntimeMatchesGoal = Boolean(
    agentChatRuntime?.goalId &&
      (!agentChatGoal || agentChatRuntime.goalId === agentChatGoal.goalId),
  );
  const currentAgentChatGoalStatus =
    (currentAgentChatRuntimeMatchesGoal
      ? agentChatRuntime?.goalStatus
      : null) ??
    agentChatGoal?.status ??
    null;
  const currentAgentChatGoalDialogMode: 'create' | 'edit' =
    !agentChatGoal || agentGoalStatusIsTerminal(currentAgentChatGoalStatus)
      ? 'create'
      : 'edit';
  const currentAgentChatSessionMutationBlocked = Boolean(
    agentChatActiveRuntime &&
      ([
        'running',
        'pending',
        'waiting-for-confirmation',
        'waiting-for-user-input',
        'cancelling',
        'finalizing',
        'pausing',
        'paused',
      ].includes(agentChatActiveRuntime.status) ||
        ['needs-reconciliation', 'pausing', 'paused'].includes(
          agentChatActiveRuntime.phase,
        ) ||
        ['pause-requested', 'paused', 'clearing'].includes(
          agentChatActiveRuntime.goalStatus ?? '',
        ) ||
        (agentChatActiveRuntime.taskQueue?.pending ?? 0) > 0 ||
        (agentChatActiveRuntime.taskQueue?.running ?? 0) > 0 ||
        (agentChatActiveRuntime.taskQueue?.waitingForConfirmation ?? 0) > 0 ||
        (agentChatActiveRuntime.taskQueue?.waitingForUserInput ?? 0) > 0 ||
        (agentChatActiveRuntime.taskQueue?.paused ?? 0) > 0),
  );
  const currentAgentChatActiveSessions = agentChatSessions.filter(
    (session) => session.archivedAt === null,
  );
  const currentAgentChatArchivedSessions = agentChatSessions.filter(
    (session) => session.archivedAt !== null,
  );
  const currentAgentChatLlmWarning = getCurrentAgentChatLlmWarning(
    currentAgentChatAgent,
  );
  const currentAgentChatNeedsUserInput =
    agentRuntimeNeedsUserInput(agentChatRuntime);
  const currentAgentChatSteerRuntime = currentAgentChatAgent
    ? matchingAgentRuntimeForSteer(
        [agentChatRuntime, agentChatActiveRuntime],
        currentAgentChatAgent.id,
        agentChatSelectedSessionId,
      )
    : null;
  const currentAgentChatWaiting =
    agentChatReplyPhase !== 'idle' || agentChatPendingRuntimeRun !== null;
  const currentAgentChatWaitingStatus =
    agentChatPendingRuntimeRun &&
    agentChatRuntime?.runId === agentChatPendingRuntimeRun.runId
      ? agentRuntimeConversationStatus(agentChatRuntime)
      : agentChatStatus;
  const currentAgentChatWaitingDetail = agentChatPendingRuntimeRun
    ? '任务仍在运行，状态和最终回复会自动更新'
    : '请求仍在进行中，收到回复后会立即显示';

  return {
    launcherAgentChatAgents,
    agentChatProjectPath,
    setAgentChatProjectPath,
    agentChatSelectedAgentId,
    setAgentChatSelectedAgentId,
    agentChatMessages,
    agentChatSessions,
    agentChatSelectedSessionId,
    agentChatActiveSessionId,
    agentChatLegacySessionMode,
    agentChatConversationPath,
    agentChatSessionStatus,
    agentChatInput,
    setAgentChatInput,
    agentChatInteractionMode,
    setAgentChatInteractionMode,
    agentChatRunSubmitMode,
    setAgentChatRunSubmitMode,
    agentChatLlmStatus,
    agentChatStatus,
    setAgentChatStatus,
    agentChatBusy,
    agentChatMessagesRef,
    agentChatBackgroundBusy,
    agentChatRuntime,
    agentChatRuntimeError,
    agentChatGoal,
    agentChatGoalError,
    agentChatGoalDialog,
    setAgentChatGoalDialog,
    agentChatGoalDialogError,
    agentChatResumeConfirmation,
    setAgentChatResumeConfirmation,
    agentChatLoadVersionRef,
    agentChatRuntimeResumeProjectPathRef,
    handleAgentChatMessagesScroll,
    loadAgentChatLlmStatus,
    cancelAgentChatRuntimeResume,
    confirmAgentChatRuntimeResume,
    closeAgentChatGoalDialog,
    handleOpenProjectSupervisorChatWindow,
    handleAgentChatPickProjectDirectory,
    loadAgentChatConversation,
    resetAgentChatSessionView,
    handleAgentChatSelectSession,
    handleAgentChatCreateSession,
    handleAgentChatForkSession,
    handleAgentChatArchiveSession,
    handleAgentChatSubmit,
    handleAgentChatStartBackgroundTask,
    openAgentChatGoalDialog,
    handleAgentChatGoalDialogSubmit,
    handleAgentChatGoalControl,
    handleAgentChatCompactContext,
    handleAgentChatCancelRuntimeTask,
    handleAgentChatRetryRuntimeTask,
    handleAgentChatConfirmRuntimeTask,
    handleAgentChatRejectRuntimeTask,
    handleAgentChatSubmitUserInput,
    currentAgentChatAgent,
    currentAgentChatSession,
    currentAgentChatSessionArchived,
    currentAgentChatGoalStatus,
    currentAgentChatGoalDialogMode,
    currentAgentChatSessionMutationBlocked,
    currentAgentChatActiveSessions,
    currentAgentChatArchivedSessions,
    currentAgentChatLlmWarning,
    currentAgentChatNeedsUserInput,
    currentAgentChatSteerRuntime,
    currentAgentChatWaiting,
    currentAgentChatWaitingStatus,
    currentAgentChatWaitingDetail,
  };
}

export type DeveloperAgentPanelController = ReturnType<
  typeof useDeveloperAgentPanel
>;