Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

34.1 KB
Raw Blame
import { deviceDisplayName } from '@/lib/deviceName';
import { SessionTaskMenu } from './sidebar/SessionTaskMenu';
import { TaskMigrationStatus } from './TaskMigrationStatus';
/**
 * SessionContentHeader — 会话视图注入 ContentHeader 的中部内容
 * ---------------------------------------------------------------------------
 * Codex 风格布局后,右侧内容区顶栏(ContentHeader Shell)中部由路由视图注入。
 * 本组件即 cc-agent 会话视图注入的内容:
 *   - Pin 指示 + 会话标题(截断显示,双击进入行内重命名 —— 与 SessionItem 同交互)
 *   - ··· 菜单:与 SessionItem 右键菜单同一套条目、变体与分组顺序(标准 /
 *     Draft / Archived 三分支),含「移动到项目」子菜单与「导出会话…」入口
 *
 * 动作实现说明:
 *   - rename / pin / move 与 CCAgentSidebarUpper 的对应 handler 同款乐观更新 +
 *     失败回滚。pin 不调用 sidebar 的 filter.promotePin、move 不做目标项目
 *     节点的自动展开(两者都是 CCAgentSidebarUpper 实例内 state,header 拿
 *     不到)—— 排序 / 展开走各自的兜底行为,差异可接受。
 *   - archive / delete / unarchive 的执行序列走 useSessionLifecycleActions
 *     (与 CCAgentSidebarUpper 共用同一实现),本组件只保留前置检查与确认
 *     弹窗。操作的恒为"当前打开的会话",activeSessionId 传 session.id。
 *
 * 拖拽区:本组件渲染在 drag region 内,默认继承窗口拖拽;只有真正需要点击 /
 * 输入的控件挖 no-drag 洞,避免标题和 git 信息整块变成不可拖区域。
 */

import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
import { ArrowLeft, Ellipsis, Pin } from 'lucide-react';
import { useTranslation } from 'react-i18next';
import { useNavigate } from 'react-router-dom';
import { Button } from '@/components/ui/button';

import { cn } from '@/lib/utils';
import { toast } from '@/lib/toast';
import type { Session } from '@/lib/ccAgent.types';
import * as sessionService from '@/lib/sessionService';
import { buildSessionDeepLink } from '@/lib/deepLink';
import { createLogger } from '@/lib/logger';
import {
  prefetchDirtyWorktreeForRemoval,
  resolveWorktreeRemovalPreflight,
} from '@/lib/worktreeRemovalWarning';
import { useCCSessions } from '@/hooks/useCCSessions';
import { useProjectPickerOptions } from '@/hooks/useProjectPickerOptions';
import { useSessionRunningStatus } from '@/hooks/useSessionRunningStatus';
import { useConfirmDialog } from '@/components/ui/confirm-dialog-provider';
import { DropdownMenu, DropdownMenuItem, DropdownMenuTrigger } from '@/components/ui/dropdown-menu';
import { WINDOW_NO_DRAG_STYLE, useManualWindowDrag } from '@/components/layout/windowDrag';
import { recentWorkdirsStore } from '@/lib/recentWorkdirsStore';
import { useRegisterContentHeader } from '../feature-context';
import { useSessionLifecycleActions } from './hooks/useSessionLifecycleActions';
import {
  getSessionDisplayTitle,
  isEmptyDraftSession,
  toStoredSessionTitle,
} from './lib/sessionDisplayTitle';
import {
  getVisibleSidebarSessionIds,
  pickSessionIdAfterRemoval,
} from './lib/sessionRemovalNavigation';
import { isOrcaLeadSession, resolveSessionRoute } from '@/lib/orcaSessionIdentity';
import { revalidateWorkersProjection } from './hooks/workerProjectionStore';
import { GitContextBadge } from './GitContextBadge';
import { OrcaRemoteLeadBadge } from './OrcaRemoteLeadBadge';
import { BotTaskOwnerChip } from '@/features/bots/BotTaskOwnerChip';
import { SessionRenameInput } from './SessionRenameInput';
import { useSessionBoundSchedules } from '@/features/scheduler/lib/scheduleSessionBinding';
import {
  archiveConfirmDescription,
  loadActiveBoundScheduleNames,
} from '@/features/scheduler/lib/archiveScheduleWarning';
import { ScheduleBindingBadge } from './sidebar/ScheduleBindingBadge';
import { RemoteProjectIcon } from './sidebar/RemoteProjectIcon';
import { VendorIcon, agentKindToVendor } from '@/components/sidebar/VendorIcon';
import { MENU_ITEM_CLASS } from './sidebar/menuStyles';
import { SessionProjectMoveSubmenu } from './sidebar/SessionProjectMoveSubmenu';
import { sessionMoveFailureFeedback } from '../../../shared/worktreeMoveGuardError';
import type { SessionMoveTarget } from './sidebar/sessionMoveTarget';
import { SessionShareExportDialog } from './sidebar/SessionShareExportDialog';
import { useRemoteProjectSessions } from '@/features/device-link/remoteProjectsStore';
import { isRemoteSessionWriteBlocked } from './lib/remoteSessionWriteGuard';
import { Tip } from '@/components/ui/tooltip';
import { Spinner } from '@/components/ui/spinner';
import { TaskTagDots, TaskTagMenuSection, TaskTagEditor } from '@/features/task-tags/TaskTags';
import { isSharedTaskPeer } from '@cindy/device-link';
import { useDeviceLinkDeviceList } from '@/features/device-link/useDeviceLinkDeviceList';
import { useProviderShareAgentDevices } from '@/features/provider-share/useProviderShareAgentDevices';

const log = createLogger('SessionContentHeader');

/**
 * 任务在本机、Agent 在同账号另一台电脑上运行:标明那台电脑,离线时如实提示(不自动改在本机跑)。
 * 图标与侧栏同款:Agent 图标 + 右上信号波纹。
 */
function AgentDeviceIndicator({
  deviceId,
  agentKind,
}: {
  deviceId: string;
  agentKind: Session['agentKind'];
}) {
  const { t } = useTranslation();
  const devices = useDeviceLinkDeviceList();
  // 分享来的供应商(`share:<id>`)不在同账号设备列表里,名字取自已收到的分享。
  const { nameFor: providerShareDeviceName } = useProviderShareAgentDevices();
  const device = devices?.find((item) => item.deviceId === deviceId);
  const name = deviceDisplayName(deviceId, device?.name || providerShareDeviceName(deviceId));
  const offline = device ? !device.online : false;
  const vendor = agentKindToVendor(agentKind);
  return (
    <Tip
      text={t(
        offline ? 'ccAgent.sessionHeader.agentDeviceOffline' : 'ccAgent.sessionHeader.agentDevice',
        { device: name },
      )}
    >
      <span
        role="img"
        aria-label={t('ccAgent.sessionHeader.agentDevice', { device: name })}
        className="inline-flex"
        style={WINDOW_NO_DRAG_STYLE}
      >
        {/* 波纹向右上溢出约 3px,右边距比其它标题前缀图标多留一些。 */}
        <VendorIcon
          vendor={vendor}
          size={vendor === 'cc' ? 14 : 13}
          remote
          colorClassName="text-[var(--cmd-palette-item-meta)]"
          className={cn('mr-2', offline && 'opacity-75')}
        />
      </span>
    </Tip>
  );
}

/**
 * 注册器组件:由路由直挂的 CCAgentSessionView 条件渲染(仅当该实例"拥有"
 * 当前路由时),把 SessionContentHeader 注进 ContentHeader 槽位。
 *
 * 为什么用条件挂载组件而不是在 CCAgentSessionView 里直接调 hook:
 * CCAgentSessionView 会被多处内嵌复用(workdir-browse 的 chat rail、Orca
 * worker 面板都会再挂一个实例)。如果 hook 无条件跑,内嵌实例会用 null /
 * 自己的 session 把路由主实例注册的内容覆盖掉。条件渲染本组件 = 条件执行
 * 注册,卸载时槽位自动清空。
 */
export function SessionContentHeaderRegistration({
  session,
  remoteSessionUnavailable = false,
  remoteSyncing = false,
  readOnly = false,
}: {
  session: Session;
  remoteSessionUnavailable?: boolean;
  remoteSyncing?: boolean;
  readOnly?: boolean;
}) {
  useRegisterContentHeader(
    useMemo(
      () => (
        <SessionContentHeader
          session={session}
          remoteSessionUnavailable={remoteSessionUnavailable}
          remoteSyncing={remoteSyncing}
          readOnly={readOnly}
        />
      ),
      [readOnly, session, remoteSessionUnavailable, remoteSyncing],
    ),
  );
  return null;
}

interface SessionContentHeaderProps {
  session: Session;
  remoteSessionUnavailable?: boolean;
  remoteSyncing?: boolean;
  readOnly?: boolean;
}

export function SessionContentHeader({
  session: sessionProp,
  remoteSessionUnavailable = false,
  remoteSyncing = false,
  readOnly = false,
}: SessionContentHeaderProps) {
  const { t } = useTranslation();
  const navigate = useNavigate();
  const { sessions, patchLocal } = useCCSessions();
  const remoteProjectSessions = useRemoteProjectSessions();
  const routeSessionById = useMemo(
    () => new Map([...sessions, ...remoteProjectSessions].map((s) => [s.id, s])),
    [sessions, remoteProjectSessions],
  );
  // 显示数据优先取 sessionsStore 的最新快照:本组件的 rename / pin 走
  // patchLocal 乐观更新,store 立即反映;而 prop 来自 CCAgentSessionView 的
  // `serverSession ?? sessionFromList`,其中 serverSession 不订阅 renderer
  // 发起的 update(main 的 sessions:update 不广播 sessions:patched),改名后
  // 会停留在旧值(Codex review P2)。prop 兜底覆盖 archived 等不在
  // active 桶里的会话。
  const session = routeSessionById.get(sessionProp.id) ?? sessionProp;
  const sharedGuest = isSharedTaskPeer(session.deviceLinkDeviceId ?? '');
  const { runningSessionIds } = useSessionRunningStatus(session.id);
  // worktree 归属取 store 镜像(与 main 的 worktreeStore 同源):回收后仍留历史路径、
  // 或存量半移动行的会话,不能靠 cwd 猜归属。
  const { confirm: confirmDialog } = useConfirmDialog();
  const { runSessionAction, unarchiveSession } = useSessionLifecycleActions();

  const isPinned = session.pinnedAt != null;
  const isArchived = session.status === 'archived';
  // Draft 判定与 SessionItem 同口径:标题仍是默认哨兵且无消息。
  const isEmpty = isEmptyDraftSession(session);
  const remoteWritesBlocked =
    readOnly || sharedGuest || remoteSessionUnavailable || isRemoteSessionWriteBlocked(session);
  // 「移动到项目」/「导出会话…」可见性与 SessionItem 同条件。
  const canMoveToProject =
    !isEmpty && !session.remoteHostId && !session.deviceLinkDeviceId && !isArchived;
  // Orca lead 可导出(整个协同随包);Worker 会话流不走此 header 菜单,双保险仍排除。
  const canExportShare =
    !isEmpty &&
    !session.remoteHostId &&
    session.orcaRole !== 'worker' &&
    !session.deviceLinkDeviceId;
  const projectOptions = useProjectPickerOptions();
  // heartbeat schedule 绑定标识,与 SessionItem 同源数据;删除/过期后自动消失。
  const boundSchedules = useSessionBoundSchedules(session.id, session.deviceLinkDeviceId);
  const displayTitle =
    getSessionDisplayTitle(session, t('ccAgent.common.unnamedSession'), t)?.trim() ||
    t('ccAgent.sessionHeader.untitled');
  const remoteIconKind = session.deviceLinkDeviceId
    ? 'device-link'
    : session.remoteHostId
      ? 'ssh'
      : null;
  const remoteIconConnectionStatus = session.deviceLinkDeviceId
    ? (session.deviceLinkConnectionStatus ?? 'connected')
    : null;

  /* ---- 行内重命名(与 SessionItem 同交互:双击进入,Enter 提交 / Esc 取消 / Blur 提交,
          输入框本体 + Magic AI 改名按钮统一在 SessionRenameInput) ---- */
  const [isEditing, setIsEditing] = useState(false);
  const [menuOpen, setMenuOpen] = useState(false);
  const menuTriggerRef = useRef<HTMLButtonElement>(null);
  const [tagEditorOpen, setTagEditorOpen] = useState(false);
  useEffect(() => {
    setMenuOpen(false);
    setTagEditorOpen(false);
  }, [session.id, session.deviceLinkDeviceId]);
  const tagMenu = (
    <TaskTagMenuSection
      session={session}
      onMore={() => {
        setMenuOpen(false);
        setTagEditorOpen(true);
      }}
    />
  );
  const [editValue, setEditValue] = useState(displayTitle);
  // Enter 提交后 input 卸载又触发 onBlur 的二次提交,用 ref 拦掉。
  const committedRef = useRef(false);

  const showRemoteWriteBlockedToast = useCallback(() => {
    toast.warning(t('ccAgent.remoteSession.actionsUnavailable'));
  }, [t]);

  const startEdit = useCallback(() => {
    if (remoteWritesBlocked) {
      showRemoteWriteBlockedToast();
      return;
    }
    // 预填用 displayTitle,不是原始 session.title —— 后者在未起名的会话上是英文
    // 哨兵,会把 "New Maker" 填进重命名输入框。commitTitle 的 `unchanged` 判据同步
    // 把 displayTitle 也算作「没改」,否则原样回车会把兜底文案写进库冲掉哨兵。
    setEditValue(displayTitle);
    committedRef.current = false;
    setIsEditing(true);
  }, [displayTitle, remoteWritesBlocked, showRemoteWriteBlockedToast]);

  // 标题文字是 no-drag(否则 onDoubleClick 收不到,见 span 处注释),
  // 拖窗习惯由手动拖拽补回:按住标题移动超过死区即拖动窗口。
  const titleManualDrag = useManualWindowDrag();

  // raw 由 SessionRenameInput 传入:输入框当前文本(Magic 生成的标题也先填入输入框,用户 Enter 确认后才走到这里)。
  const commitTitle = useCallback(
    async (raw: string) => {
      if (committedRef.current) return;
      committedRef.current = true;
      const trimmed = raw.trim();
      setIsEditing(false);
      // 「没改」= 与原始标题相同,**或**与预填的显示标题相同。后者不可省:未起名的
      // 会话预填的是本地化兜底文案(「未命名任务」),它不等于库里的英文哨兵 —— 只比
      // session.title 的话,用户双击后原样回车就会把兜底文案写进库、把哨兵冲掉,
      // 自动起名从此永久跳过这个会话(标题永远停在「未命名任务」)。
      const unchanged = !trimmed || trimmed === session.title || trimmed === displayTitle;
      if (remoteWritesBlocked) {
        if (!unchanged) showRemoteWriteBlockedToast();
        return;
      }
      if (unchanged) return;
      // 预填是**显示标题**(legacy automation 会话已剥掉 `[Schedule] ` 前缀),落库前还原,
      // 否则 isAutomationGeneratedSession 认不出它、会话从 automation 分组消失
      // (PR #1031 review P1)。
      const stored = toStoredSessionTitle(session, trimmed);
      const oldTitle = session.title;
      patchLocal(session.id, { title: stored });
      try {
        // 远程会话:patch-meta 经隧道写被控端 → 广播 sessions:patched → applyPatch 更新远程分片
        // (纯镜像,无需重拉);本机会话 patchLocal 已乐观反映。
        await sessionService.patchMeta(session.id, { title: stored });
      } catch (err) {
        log.error('[session rename]', err);
        toast.error(t('ccAgent.sidebar.renameFailed'));
        patchLocal(session.id, { title: oldTitle });
      }
    },
    [
      displayTitle,
      remoteWritesBlocked,
      session.id,
      session.title,
      patchLocal,
      showRemoteWriteBlockedToast,
      t,
    ],
  );

  /* ---- Pin / Unpin ---- */
  const handleTogglePin = useCallback(async () => {
    if (remoteWritesBlocked) {
      showRemoteWriteBlockedToast();
      return;
    }
    const oldPinnedAt = session.pinnedAt;
    const newPinnedAt = isPinned ? null : new Date().toISOString();
    patchLocal(session.id, { pinnedAt: newPinnedAt });
    try {
      // 远程会话:patch-meta → 广播 sessions:patched → applyPatch 更新远程分片(纯镜像)。
      await sessionService.patchMeta(session.id, { pinnedAt: newPinnedAt });
    } catch (err) {
      log.error('[session pin]', err);
      toast.error(t('ccAgent.sidebar.pinFailed'));
      patchLocal(session.id, { pinnedAt: oldPinnedAt });
    }
  }, [
    isPinned,
    patchLocal,
    remoteWritesBlocked,
    session.id,
    session.pinnedAt,
    showRemoteWriteBlockedToast,
    t,
  ]);

  /* ---- 复制任务链接(cindy://session/<id> 深链,与 SessionItem 同语义;
          远程会话把归属设备冻进 ?device=) ---- */
  const handleCopyDeepLink = useCallback(async () => {
    try {
      await navigator.clipboard.writeText(
        buildSessionDeepLink(session.id, { deviceId: session.deviceLinkDeviceId }),
      );
      toast.success(t('ccAgent.sidebar.deepLink.copied'));
    } catch (err) {
      log.warn('clipboard write failed', err);
      toast.warning(t('ccAgent.sidebar.deepLink.copyFailed'));
    }
  }, [session.deviceLinkDeviceId, session.id, t]);

  const handleOpenInNewWindow = useCallback(() => {
    if (remoteWritesBlocked) {
      showRemoteWriteBlockedToast();
      return;
    }
    void window.electronAPI.maker.openSessionInNewWindow(session.id, session.deviceLinkDeviceId);
  }, [remoteWritesBlocked, session.deviceLinkDeviceId, session.id, showRemoteWriteBlockedToast]);

  /* ---- 移动到项目 / 对话 ----
   * 与 CCAgentSidebarUpper.handleMoveSession 同款守卫(远程不支持 / 执行中 /
   * 被 IM 接管中拦截)与乐观更新 + 失败回滚;不含 sidebar 的目标项目节点自动
   * 展开(collapse 是 CCAgentSidebarUpper 实例内 state,header 拿不到)。 */
  const handleMoveSession = useCallback(
    async (target: SessionMoveTarget) => {
      if (session.remoteHostId || session.deviceLinkDeviceId) {
        toast.warning(t('ccAgent.sidebar.sessionMenu.moveToProjectRemoteUnsupported'));
        return;
      }
      if (runningSessionIds.has(session.id)) {
        toast.warning(t('ccAgent.sidebar.sessionMenu.moveToProjectRunningBlocked'));
        return;
      }
      // Orca lead:team 里任一 worker 在跑时同样不允许移动 workspace(与
      // CCAgentSidebarUpper.effectiveRunningSessionIds 的聚合口径一致)。
      // sidebar 用常驻订阅的 lead→worker map;header 在动作时同步查一次
      // worker 列表,避免依赖挂载初期尚未加载完成的订阅态(Codex review P2)。
      // 查询失败时不阻断,与 sidebar map 拉取失败(空集合)的行为一致。
      if (isOrcaLeadSession(session)) {
        const workers = await revalidateWorkersProjection(session.id)
          .then((result) => (result.status === 'applied' ? result.workers : []))
          .catch(() => []);
        if (workers.some((worker) => runningSessionIds.has(worker.sessionId))) {
          toast.warning(t('ccAgent.sidebar.sessionMenu.moveToProjectRunningBlocked'));
          return;
        }
      }
      try {
        const binding = await window.electronAPI.binding.resolveSession(session.id);
        if (binding.attached) {
          toast.warning(t('ccAgent.sidebar.sessionMenu.moveToProjectAttachedBlocked'));
          return;
        }
      } catch {
        // resolveSession 失败时不阻断移动;它只是 IM 接管保护的额外检查。
      }

      let targetWorkingDir = target.kind === 'project' ? target.workingDir : undefined;
      if (target.kind === 'browseProject') {
        try {
          const result = await window.electronAPI.showOpenDirectoryDialog();
          if (result.canceled || !result.path) return;
          targetWorkingDir = result.path;
        } catch (err) {
          log.warn('[session move to project] directory picker failed', err);
          toast.error(t('ccAgent.sidebar.sessionMenu.moveToProjectFailed'));
          return;
        }
      }

      // 与 CCAgentSidebarUpper 同款:worktree 会话不能改到它绑定 worktree 之外的目录
      // (半移动)。判定不在这里做:归属只有共享写路径一处权威,renderer 的缓存/复核都是
      // 异步镜像,任何「先查询再决定」都会有「查询通过后、写入前恰好回收」的窗口,把
      // 主进程本会放行的移动挡在请求之前;这里照常发请求,被守卫拒绝时在下面映射成
      // 同一条 toast。「移到对话」不改目录,不受影响。
      const oldPatch = {
        workingDir: session.workingDir,
        workspaceKind: session.workspaceKind,
      };
      if (target.kind !== 'dialogue' && !targetWorkingDir) return;
      const nextPatch =
        target.kind === 'dialogue'
          ? { workspaceKind: 'dialogue' as const }
          : { workingDir: targetWorkingDir, workspaceKind: 'project' as const };
      patchLocal(session.id, nextPatch);
      try {
        await sessionService.update(session.id, nextPatch);
        if (target.kind !== 'dialogue') {
          void recentWorkdirsStore.forceRefresh().catch(() => undefined);
        }
        toast.success(
          t(
            target.kind === 'dialogue'
              ? 'ccAgent.sidebar.sessionMenu.moveToDialogueDone'
              : 'ccAgent.sidebar.sessionMenu.moveToProjectDone',
          ),
        );
      } catch (err) {
        log.error('[session move]', err);
        patchLocal(session.id, oldPatch);
        // 归属守卫在主进程唯一权威地拒绝跨根移动(在关 runtime / 写库 / 转录迁移之前,
        // 不留部分写入);被它拒绝时给产品既定的「暂不支持移出 worktree」说明,其它失败
        // 照旧用通用报错文案。
        const feedback = sessionMoveFailureFeedback(target.kind, err);
        if (feedback.level === 'warning') toast.warning(t(feedback.key));
        else toast.error(t(feedback.key));
      }
    },
    [patchLocal, runningSessionIds, session, t],
  );

  /* ---- 导出会话(.cshare)---- 弹窗仅打开时挂载,与 SessionItem 同款。 */
  const [shareExportOpen, setShareExportOpen] = useState(false);
  /* ---- Archive / Delete / Unarchive ----
   * 执行序列共用 useSessionLifecycleActions(与 CCAgentSidebarUpper 同一实现);
   * 本组件只保留前置检查与确认弹窗。header 操作的恒为当前打开的会话,
   * activeSessionId 传 session.id —— archive 后跳 /cc-agent/new、delete 后
   * 优先跳到侧边栏相邻会话,没有相邻项才回新建页。 */
  const handleArchive = useCallback(async () => {
    if (remoteWritesBlocked) {
      showRemoteWriteBlockedToast();
      return;
    }
    // 执行中 / 被 IM 接管中不允许归档 —— 与 sidebar 的 handleActionClick 同规则
    if (runningSessionIds.has(session.id)) {
      toast.warning(t('ccAgent.sidebar.archiveBlocked.running'));
      return;
    }
    await runSessionAction(session.id, 'archive', {
      activeSessionId: session.id,
      prepareArchive: async (isCurrent) => {
        // 接管查询先发不 await,让它与菜单打开时那次 prefetch 在链路上重叠;
        // resolveSession 失败降级为「未接管」,不阻断归档(与 sidebar 同口径)。
        const attachedPromise = window.electronAPI.binding
          .resolveSession(session.id)
          .then((binding) => binding.attached)
          .catch(() => false);
        if (await attachedPromise) {
          toast.warning(t('ccAgent.sidebar.archiveBlocked.attached'));
          return false;
        }
        // 绑定了 active 自动化:后续运行会恢复原任务,需要确认。读本地缓存,排在 worktree 预检之前。
        const scheduleNames =
          (await loadActiveBoundScheduleNames([
            { id: session.id, deviceLinkDeviceId: session.deviceLinkDeviceId },
          ])).get(session.id) ?? [];
        // **worktree 预检必须是最后一个前置条件**(codex review):原来这里用 Promise.all
        // 一起等,dirty 先返回 clean、接管查询还在飞的那段时间就是 clean 结论的失效窗口。
        // 改成接管结算之后再 resolve —— clean 一律重查(见 worktreeRemovalWarning),
        // 拿到的是此刻的结论;菜单打开时的 prefetch 仍然热了 git cache。
        // 远程列表已经乐观换桶;预检与确认期间保留当前详情,取消时恢复行。
        const preflight = await resolveWorktreeRemovalPreflight(session.id, session.deviceLinkDeviceId);
        if (!isCurrent()) return false;
        // 归档不弹确认框 —— 可逆操作(菜单里就有「恢复」),与 sidebar 同口径。
        // 免确认的判据是「**确认**干净」:worktree 脏、或预检失败拿不到结论('unknown')
        // 都要确认 —— 归档会顺带回收 worktree,不能静默带走改动(greptile review)。
        // 'unknown' 只弹普通归档确认,不摆 dirty 警告文案(那会谎称有未提交改动)。
        if (preflight !== 'clean' || scheduleNames.length > 0) {
          const ok = await confirmDialog({
            title: t('ccAgent.sidebar.confirmArchive.title'),
            description: archiveConfirmDescription(t, {
              dirtyWorktree: preflight === 'dirty',
              scheduleNames,
            }),
            confirmText: t('ccAgent.sidebar.confirmArchive.confirm'),
            cancelText: t('ccAgent.sidebar.confirmArchive.cancel'),
          });
          if (!ok) {
            return false;
          }
        }
        return true;
      },
    });
  }, [
    confirmDialog,
    remoteWritesBlocked,
    runSessionAction,
    runningSessionIds,
    session.deviceLinkDeviceId,
    session.id,
    showRemoteWriteBlockedToast,
    t,
  ]);

  const handleUnarchive = useCallback(async () => {
    if (remoteWritesBlocked) {
      showRemoteWriteBlockedToast();
      return;
    }
    await unarchiveSession(session.id);
  }, [remoteWritesBlocked, session.id, showRemoteWriteBlockedToast, unarchiveSession]);

  const handleDelete = useCallback(async () => {
    if (remoteWritesBlocked) {
      showRemoteWriteBlockedToast();
      return;
    }
    // P1 预检:worktree 有未提交更改时确认文案追加警告。删除始终弹确认框,所以
    // 用不到三态 —— 预检失败时少一行警告文案,不会变成静默放行。
    const dirtyWorktree =
      (await resolveWorktreeRemovalPreflight(session.id, session.deviceLinkDeviceId)) === 'dirty';
    const ok = await confirmDialog({
      title: t('ccAgent.sidebar.confirmDelete.title'),
      description:
        t('ccAgent.sidebar.confirmDelete.description') +
        (dirtyWorktree ? ' ' + t('ccAgent.sidebar.confirmDelete.dirtyWorktreeWarning') : ''),
      confirmText: t('ccAgent.sidebar.confirmDelete.confirm'),
      cancelText: t('ccAgent.sidebar.confirmDelete.cancel'),
    });
    if (!ok) return;
    const visibleSessionIds = getVisibleSidebarSessionIds();
    const hasVisibleListContext = visibleSessionIds.includes(session.id);
    const nextSessionId = pickSessionIdAfterRemoval(
      visibleSessionIds,
      new Set([session.id]),
      session.id,
    );
    const deleteRedirectRoute = nextSessionId
      ? await resolveSessionRoute(nextSessionId, routeSessionById.get(nextSessionId))
      : hasVisibleListContext
        ? '/cc-agent/new'
        : null;
    await runSessionAction(session.id, 'delete', {
      activeSessionId: session.id,
      deleteRedirectRoute,
    });
  }, [
    confirmDialog,
    remoteWritesBlocked,
    routeSessionById,
    runSessionAction,
    session.id,
    showRemoteWriteBlockedToast,
    t,
  ]);

  return (
    <div className="flex min-w-0 items-center gap-0.5 pl-1">
      {session.source === 'side-chat' && session.parentSessionId && (
        <Tip text={t('chat.sideChat.returnMain')}>
          <Button variant="secondary" tone="quiet" size="sm" className="w-7 p-0" style={WINDOW_NO_DRAG_STYLE}
            aria-label={t('chat.sideChat.returnMain')}
            onClick={() => void resolveSessionRoute(session.parentSessionId!).then(route => navigate(route))
              .catch(() => toast.error(t('chat.sideChat.failed')))}>
            <ArrowLeft size={16} />
          </Button>
        </Tip>
      )}
      {isPinned && (
        <Pin
          size={13}
          className="mr-1 shrink-0 text-[var(--cmd-palette-item-meta)]"
          aria-label={t('ccAgent.sidebar.sessionMenu.pin')}
        />
      )}
      {boundSchedules.length > 0 && (
        <span style={WINDOW_NO_DRAG_STYLE}>
          <ScheduleBindingBadge
            schedules={boundSchedules}
            deviceLinkDeviceId={session.deviceLinkDeviceId}
            size={13}
            className="mr-1 size-4"
          />
        </span>
      )}
      {!isEditing && remoteIconKind && (
        <Tip
          text={
            session.deviceLinkDeviceId ? deviceDisplayName(session.deviceLinkDeviceId, session.deviceLinkDeviceName) : session.remoteHostId ?? ''
          }
        >
          <RemoteProjectIcon
            kind={remoteIconKind}
            connectionStatus={remoteIconConnectionStatus}
            className="mr-1 text-[var(--cmd-palette-item-meta)]"
          />
        </Tip>
      )}
      {!isEditing && !remoteIconKind && session.agentDeviceId && (
        <AgentDeviceIndicator deviceId={session.agentDeviceId} agentKind={session.agentKind} />
      )}

      {isEditing ? (
        <div style={WINDOW_NO_DRAG_STYLE}>
          <SessionRenameInput
            sessionId={session.id}
            value={editValue}
            onValueChange={setEditValue}
            onCommit={(raw) => void commitTitle(raw)}
            onCancel={() => {
              // 标记已提交再退出编辑:input 卸载会触发 onBlur → commitTitle,
              // 不拦住的话 Esc"取消"反而会把改了一半的标题保存掉(Codex review P2)。
              committedRef.current = true;
              setIsEditing(false);
            }}
            containerClassName="w-72 max-w-[40vw]"
            inputClassName="h-7 text-sm font-medium text-foreground"
          />
        </div>
      ) : (
        // 标题文字必须挖 no-drag 洞:留在 drag region 里的话全部鼠标事件都被
        // 原生拖拽吞掉(连 mousedown 都收不到),onDoubleClick 永远触发不了。
        // 拖窗习惯由 useManualWindowDrag 手动补回:按住标题移动照样拖窗,
        // 双击(死区内)不动窗、正常进入改名。
        <span
          {...titleManualDrag}
          onDoubleClick={sharedGuest ? undefined : startEdit}
          title={displayTitle}
          className="min-w-0 max-w-[40vw] cursor-default truncate text-sm font-medium text-foreground"
          style={WINDOW_NO_DRAG_STYLE}
        >
          {displayTitle}
        </span>
      )}

      {remoteSyncing && (
        <Tip text={t('ccAgent.remoteSession.syncing')}>
          <span
            role="status"
            aria-label={t('ccAgent.remoteSession.syncing')}
            aria-busy="true"
            className="mx-1 inline-flex shrink-0 text-[var(--text-tertiary)]"
            style={WINDOW_NO_DRAG_STYLE}
          >
            <Spinner size={14} />
          </span>
        </Tip>
      )}

      {!isEditing && !!session.tags?.length && (
        <span
          className="mx-1 shrink-0 [--task-tag-ring-bg:hsl(var(--content-area))]"
          style={WINDOW_NO_DRAG_STYLE}
        >
          <TaskTagDots tags={session.tags} />
        </span>
      )}

      {!isEditing && <OrcaRemoteLeadBadge session={session} />}

      {!isEditing && <BotTaskOwnerChip session={session} />}

      {!isEditing && !readOnly && (!sharedGuest || session.status === 'active') && (
        // 菜单打开就把归档/删除的 dirty 预检发出去:用户从展开菜单到点条目至少
        // 一次反应时间,足够这次 git status 跑完,点下去时命中缓存、零等待。
        <DropdownMenu
          open={menuOpen}
          onOpenChange={(open) => {
            setMenuOpen(open);
            if (open && !sharedGuest)
              prefetchDirtyWorktreeForRemoval(session.id, session.deviceLinkDeviceId);
          }}
        >
          <DropdownMenuTrigger asChild>
            <Tip text={t('ccAgent.sessionHeader.moreActions')} side="bottom">
              <button
                ref={menuTriggerRef}
                className={cn(
                  'flex h-7 w-7 shrink-0 items-center justify-center rounded-md',
                  'text-[var(--cmd-palette-item-meta)] transition-colors',
                  'hover:bg-titlebar-button-hover hover:text-foreground',
                  'focus-visible:outline-none data-[state=open]:bg-titlebar-button-hover',
                )}
                aria-label={t('ccAgent.sessionHeader.moreActions')}
                style={WINDOW_NO_DRAG_STYLE}
              >
                <Ellipsis size={15} />
              </button>
            </Tip>
          </DropdownMenuTrigger>
          <SessionTaskMenu
            key={`${session.deviceLinkDeviceId ?? ''}:${session.id}`}
            session={session}
            open={menuOpen}
            writeBlocked={remoteWritesBlocked}
            returnFocus={() => menuTriggerRef.current?.focus()}
            onRename={startEdit}
            onPin={() => void handleTogglePin()}
            onArchive={() => void handleArchive()}
            onUnarchive={() => void handleUnarchive()}
            onDelete={() => void handleDelete()}
            onOpenInNewWindow={handleOpenInNewWindow}
            tags={tagMenu}
            copy={
              <DropdownMenuItem
                onSelect={() => void handleCopyDeepLink()}
                className={MENU_ITEM_CLASS}
              >
                {t('ccAgent.sidebar.sessionMenu.copySessionLink')}
              </DropdownMenuItem>
            }
            exportShare={
              canExportShare && (
                <DropdownMenuItem
                  onSelect={() => setShareExportOpen(true)}
                  className={MENU_ITEM_CLASS}
                >
                  {t('ccAgent.sidebar.sessionMenu.exportShare')}
                </DropdownMenuItem>
              )
            }
            move={
              canMoveToProject && (
                <SessionProjectMoveSubmenu
                  projectOptions={projectOptions}
                  currentWorkingDir={
                    session.workspaceKind === 'project' ? session.workingDir : null
                  }
                  isDialogue={session.workspaceKind === 'dialogue'}
                  onSelectProject={(workingDir) =>
                    void handleMoveSession({ kind: 'project', workingDir })
                  }
                  onBrowseProject={() => void handleMoveSession({ kind: 'browseProject' })}
                  onMoveToDialogue={() => void handleMoveSession({ kind: 'dialogue' })}
                />
              )
            }
          />
        </DropdownMenu>
      )}

      {/* session-git-pr-context:当前分支 + 关联 PR 徽标(项目任务与对话一致;非 git 目录且无 PR 时自动隐藏) */}
      <GitContextBadge session={session} />
      <TaskMigrationStatus session={session} />

      {tagEditorOpen && <TaskTagEditor session={session} onClose={() => setTagEditorOpen(false)} />}

      {/* 导出 .cshare 弹窗:仅打开时挂载,与 SessionItem 同款。 */}
      {shareExportOpen && (
        <SessionShareExportDialog
          open={shareExportOpen}
          sessionId={session.id}
          onOpenChange={setShareExportOpen}
        />
      )}
    </div>
  );
}