Skip to content

Your lightweight open-source personal agent.

116 KB
Raw Blame
import { pastedFilePath, PastedPathRange, type LocalAttachment } from "../../../../packages/client-events/attachments";
import {
  NewChatIcon,
  CompactIcon,
  StatusIcon,
  ModelsIcon,
  TriggerIcon,
  DreamLogIcon,
  PromptTemplateIcon,
  PairingIcon,
  ToolRunIcon,
  ActivityIcon,
  ArchiveIcon,
  SkillsIcon,
  MemoryIcon,
  HelpIcon,
  HistoryIcon,
  AttachIcon,
  RestartIcon,
  RestrictedAccessIcon,
  DreamIcon,
  StopIcon,
  EditIcon,
  GoalIcon,
  RestoreMemoryIcon,
} from "@/components/icons/product-icons";
import {
  useCallback,
  useEffect,
  useLayoutEffect,
  useMemo,
  useRef,
  useState,
  type CSSProperties,
  type KeyboardEvent as ReactKeyboardEvent,
  type Ref,
} from "react";

import { MarkdownText, preloadMarkdownText } from "@/components/MarkdownText";
import {
  CapabilityMentionToken,
  cliAppInitials,
  mcpPresetInitials,
  splitCapabilityMentionSegments,
} from "@/components/CliAppMentionText";
import {
  SkillReferenceToken,
  withSkillReferences,
  type InlineReferenceSegment,
} from "@/components/SkillReferenceText";
import {
  composerMentionText,
  isCapabilityMentionStart,
  type CapabilityMentionSegment,
} from "@/lib/composer-mention-text";
import { INLINE_REFERENCE_HIGHLIGHT_COLOR, INLINE_TOKEN_HIGHLIGHT_COLOR, InlineTokenHighlight } from "@/components/InlineTokenHighlight";
import { SlashCommandText } from "@/components/SlashCommandText";
import {
  ChevronDown,
  ChevronUp,
  CornerDownRight,
  Loader2,
  Quote,
  Trash2,
  X,
  type LucideIcon,
} from "lucide-react";
import { useTranslation } from "react-i18next";

import { Button } from "@/components/ui/button";
import { AttachmentCard, AttachmentTypeFace, attachmentCardActionClassName } from "@/components/AttachmentCard";
import { ComposerActionIcon, type ComposerActionState } from "@/components/thread/ComposerActionIcon";
import {
  floatingItemClassName,
  floatingItemFocusClassName,
  floatingSurfaceElevationClassName,
  floatingSurfaceVisualClassName,
} from "@/components/ui/floating-surface";
import {
  Tooltip,
  TooltipContent,
  TooltipProvider,
  TooltipTrigger,
} from "@/components/ui/tooltip";
import {
  WorkspaceAccessMenu,
  WorkspaceProjectPicker,
} from "@/components/thread/WorkspaceControls";
import {
  ModelPresetBadge,
  type ModelPresetOption,
} from "@/components/thread/ModelPresetBadge";
import type { ComposerUsageControl } from "@/components/thread/ComposerUsagePopover";
import {
  ACCEPT_ATTR,
  acceptedAttachmentKind,
  MAX_ATTACHMENTS_PER_MESSAGE,
  MAX_ATTACHMENT_BYTES,
  MAX_TOTAL_ATTACHMENT_BYTES,
  MAX_VIDEO_BYTES,
  MAX_VIDEOS_PER_MESSAGE,
  useAttachedImages,
  type AttachedImage,
  type AttachmentError,
  type RestoredReadyImage,
} from "@/hooks/useAttachedImages";
import { useClipboardAndDrop } from "@/hooks/useClipboardAndDrop";
import { useComposerMentionInput } from "@/hooks/useComposerMentionInput";
import { useLogoFallback } from "@/hooks/useLogoFallback";
import { useMediaQuery } from "@/hooks/useMediaQuery";
import type { SendAttachment, SendOptions } from "@/hooks/useNanobotStream";
import { useVoiceRecorder, type VoiceRecorderErrorKey } from "@/hooks/useVoiceRecorder";
import type {
  CliAppInfo,
  ChatSummary,
  GoalStateWsPayload,
  McpPresetInfo,
  OutboundCliAppMention,
  OutboundMcpPresetMention,
  SessionMention,
  SlashCommand,
  SkillSummary,
  WebUIIngressLimits,
  WorkspaceScopePayload,
  WorkspacesPayload,
  ProjectDirectory,
  WorkspaceDirectoriesPayload,
} from "@/lib/types";
import {
  logoFallbackUrls,
} from "@/lib/provider-brand";
import { sessionHandleColor } from "@/lib/session-handle";
import { requestSkillsRefresh } from "@/lib/skill-events";
import {
  isRegisteredSlashCommand,
  isSideChannelLifecycle,
  matchingSlashCommand,
  slashCommandLifecycle,
} from "@/lib/slash-command";
import {
  clearDraggedSession,
  hasDraggedSession,
  readDraggedSession,
} from "@/lib/session-drag";
import { formatQuotedUserMessage } from "@/lib/user-message-quote";
import { cn } from "@/lib/utils";
import type { ComposerDraft, ComposerDraftStore } from "@/lib/composer-draft";
import { useLocalPreferences } from "@/hooks/useLocalPreferences";
import {
  queuedImagesToSendImages,
  queuedUploadBytes,
  readyImagesToQueuedImages,
  useQueuedPrompt,
  type QueuedPromptContent,
} from "@/components/thread/useQueuedPrompt";

const VOICE_SHORTCUT_CODE = "KeyD";
const VOICE_SHORTCUT_ARIA = "Control+Shift+D";
const VOICE_ERROR_VISIBLE_MS = 3_500;
const VOICE_ERROR_FADE_MS = 500;
type VoiceShortcutPlatform = "apple" | "chromeos" | "linux" | "other" | "windows";

function formatBytes(n: number): string {
  if (n < 1024) return `${n} B`;
  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KiB`;
  return `${(n / (1024 * 1024)).toFixed(1)} MiB`;
}

function utf8Bytes(value: string): number {
  return new TextEncoder().encode(value).byteLength;
}

function isVoiceShortcutDown(event: KeyboardEvent): boolean {
  return (
    event.code === VOICE_SHORTCUT_CODE
    && event.ctrlKey
    && event.shiftKey
    && !event.altKey
    && !event.metaKey
  );
}

function isVoiceShortcutRelease(event: KeyboardEvent): boolean {
  return (
    event.code === VOICE_SHORTCUT_CODE
    || event.key === "Control"
    || event.key === "Shift"
  );
}

function getVoiceShortcutPlatform(): VoiceShortcutPlatform {
  if (typeof navigator === "undefined") return "other";
  const userAgentData = (navigator as Navigator & { userAgentData?: { platform?: string } })
    .userAgentData;
  const platform = [
    userAgentData?.platform,
    navigator.platform,
    navigator.userAgent,
  ].filter(Boolean).join(" ").toLowerCase();
  const isIpadPretendingToBeMac =
    navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1;
  if (isIpadPretendingToBeMac || /mac|iphone|ipad|ipod/.test(platform)) return "apple";
  if (/win/.test(platform)) return "windows";
  if (/cros/.test(platform)) return "chromeos";
  if (/linux|x11|android/.test(platform)) return "linux";
  return "other";
}

function getVoiceShortcutLabel(): string {
  switch (getVoiceShortcutPlatform()) {
    case "apple":
      return "⌃⇧D";
    case "chromeos":
    case "linux":
    case "windows":
    case "other":
      return "Ctrl ⇧ D";
  }
}

interface ThreadComposerProps {
  onSend: (
    content: string,
    images?: SendAttachment[],
    options?: SendOptions,
  ) => boolean | void | Promise<boolean | void>;
  disabled?: boolean;
  placeholder?: string;
  inputAriaLabel?: string;
  compactWhenIdle?: boolean;
  isStreaming?: boolean;
  activeTurnId?: string | null;
  completedTurnIds?: readonly string[];
  modelLabel?: string | null;
  modelDetail?: string | null;
  modelPreset?: string | null;
  modelPresets?: ModelPresetOption[];
  onModelPresetChange?: (name: string) => void;
  modelProvider?: string | null;
  modelProviderLabel?: string | null;
  modelNeedsSetup?: boolean;
  onModelBadgeClick?: () => void;
  onManageModels?: () => void;
  renderContextUsage?: ComposerUsageControl;
  variant?: "thread" | "hero";
  slashCommands?: SlashCommand[];
  onMentionSearch?: () => void;
  cliApps?: CliAppInfo[];
  mcpPresets?: McpPresetInfo[];
  sessions?: ChatSummary[];
  skills?: SkillSummary[];
  onStop?: () => void;
  surfaceRef?: Ref<HTMLDivElement>;
  onTranscribeAudio?: (dataUrl: string, options?: { durationMs?: number }) => Promise<string>;
  onInspectAttachment?: (path: string) => Promise<LocalAttachment>;
  /** Sustained objective for this chat (WebSocket ``goal_state``). */
  goalState?: GoalStateWsPayload;
  workspaceScope?: WorkspaceScopePayload | null;
  workspaceControlsHidden?: boolean;
  workspacePickerLayoutAnchor?: HTMLElement | null;
  workspaceDefaultScope?: WorkspaceScopePayload | null;
  workspaceControls?: WorkspacesPayload["controls"] | null;
  workspaceScopeDisabled?: boolean;
  workspaceProjectLocked?: boolean;
  workspaceError?: string | null;
  onFavoriteWorkspaceProject?: (path: string, pinned: boolean) => Promise<ProjectDirectory[]>;
  onResolveWorkspaceProject?: (path: string) => Promise<ProjectDirectory>;
  onLoadWorkspaceProjects?: () => Promise<WorkspacesPayload>;
  onBrowseWorkspaceDirectories?: (path: string, query: string, showHidden: boolean) => Promise<WorkspaceDirectoriesPayload>;
  onWorkspaceScopeChange?: (scope: WorkspaceScopePayload) => void;
  pendingQueueKey?: string | null;
  draftKey?: string;
  draftStore?: ComposerDraftStore;
  persistDraft?: boolean;
  transcriptionProvider?: string | null;
  ingressLimits?: WebUIIngressLimits | null;
  quotedContext?: string | null;
  focusRequest?: number;
  onQuotedContextChange?: (text: string | null) => void;
}

const COMMAND_ICONS: Record<string, LucideIcon> = {
  activity: ActivityIcon,
  archive: ArchiveIcon,
  "book-open": SkillsIcon,
  brain: MemoryIcon,
  "circle-help": HelpIcon,
  history: HistoryIcon,
  "rotate-cw": RestartIcon,
  shield: RestrictedAccessIcon,
  sparkles: DreamIcon,
  square: StopIcon,
  "square-pen": EditIcon,
  "undo-2": RestoreMemoryIcon,
  zap: TriggerIcon,
  "file-text": PromptTemplateIcon,
  wrench: ToolRunIcon,
};

const BUILTIN_COMMAND_ICONS: Record<string, LucideIcon> = {
  "/new": NewChatIcon, "/compact": CompactIcon, "/stop": StopIcon,
  "/restart": RestartIcon, "/status": StatusIcon, "/model": ModelsIcon,
  "/history": HistoryIcon, "/goal": GoalIcon, "/trigger": TriggerIcon,
  "/dream": DreamIcon, "/dream-log": DreamLogIcon, "/dream-restore": RestoreMemoryIcon,
  "/dream-prompt": PromptTemplateIcon, "/evaluator-prompt": PromptTemplateIcon,
  "/skill": SkillsIcon, "/help": HelpIcon, "/pairing": PairingIcon,
};

const SLASH_PALETTE_GAP_PX = 8;
const SLASH_PALETTE_MAX_HEIGHT_PX = 288;
const SLASH_PALETTE_MIN_HEIGHT_PX = 144;
const SLASH_PALETTE_CHROME_PX = 12;
const SLASH_RECENTS_STORAGE_KEY = "nanobot.webui.slashCommandRecents";
const SLASH_RECENTS_LIMIT = 5;
const SESSION_MENTIONS_LIMIT = 8;

function VoiceRecordingMeter({
  ariaLabel,
  className,
  elapsedLabel,
  isHero,
  levels,
}: {
  ariaLabel: string;
  className?: string;
  elapsedLabel: string;
  isHero: boolean;
  levels: number[];
}) {
  return (
    <div
      className={cn(
        "flex min-w-0 items-center gap-2 text-neutral-700 dark:text-white",
        isHero ? "h-8" : "h-9",
        className,
      )}
      aria-live="polite"
      aria-label={ariaLabel}
    >
      <span className="flex h-5 min-w-0 flex-1 items-center justify-between overflow-hidden" aria-hidden>
        {levels.map((height, index) => (
          <span
            key={index}
            className="w-[2px] rounded-full bg-current opacity-85 transition-[height] duration-75 ease-linear motion-reduce:transition-none"
            style={{ height }}
          />
        ))}
      </span>
      <span className="min-w-[2.1rem] text-right text-[12px] font-medium tabular-nums text-muted-foreground">
        {elapsedLabel}
      </span>
    </div>
  );
}

type SlashPalettePlacement = "above" | "below" | "beside";

interface SlashPaletteLayout {
  placement: SlashPalettePlacement;
  maxHeight: number;
}

interface CliAppMentionQuery {
  query: string;
  start: number;
  end: number;
}

type MentionCandidate = {
  name: string;
  displayName: string;
} & (
  | { kind: "session"; mention: SessionMention }
  | {
      kind: "cli" | "mcp";
      brandColor: string | null;
      logoUrl: string | null;
      initials: string;
    }
);

interface MentionInsertion {
  value: string;
  cursor: number;
  tokenStart: number;
  tokenEnd: number;
}

function mentionInsertion(
  value: string,
  name: string,
  start: number,
  end: number,
): MentionInsertion {
  const from = Math.min(Math.max(start, 0), value.length);
  const to = Math.min(Math.max(end, from), value.length);
  const prefix = value.slice(0, from);
  const suffix = value.slice(to);
  const leadingSpace = prefix && !isCapabilityMentionStart(value, from) ? " " : "";
  const trailingSpace = /^\s/.test(suffix) ? "" : " ";
  const tokenStart = prefix.length + leadingSpace.length;
  const tokenEnd = tokenStart + name.length + 1;
  return {
    value: `${prefix}${leadingSpace}@${name}${trailingSpace}${suffix}`,
    cursor: tokenEnd + trailingSpace.length,
    tokenStart,
    tokenEnd,
  };
}

function sessionMentionOptions(sessions: ChatSummary[]): SessionMention[] {
  return sessions.flatMap((session) => {
    if (!session.handle) return [];
    return [{
      id: session.handle.id,
      name: session.handle.name,
      session_key: session.key,
      title: session.title?.trim() || session.preview.trim(),
    }];
  });
}

interface SlashPaletteCommand {
  command: string;
  title: string;
  description: string;
  icon: string;
  kind?: "skill";
  argHint?: string;
  detail: string;
  badge?: string;
  recent: boolean;
}

function skillMatchRank(skill: SkillSummary, query: string): number | null {
  if (!query) return 0;
  const name = skill.name.toLowerCase();
  if (name === query) return 0;
  if (name.startsWith(query)) return 1;
  if (name.includes(query)) return 2;
  if (skill.description.toLowerCase().includes(query)) return 3;
  return null;
}

function slashCommandI18nKey(command: string): string {
  return command.replace(/^\//, "").replace(/-/g, "_");
}

function readSlashRecents(): string[] {
  if (typeof window === "undefined") return [];
  try {
    const raw = window.localStorage.getItem(SLASH_RECENTS_STORAGE_KEY);
    const parsed = raw ? JSON.parse(raw) : [];
    return Array.isArray(parsed)
      ? parsed.filter((item): item is string => typeof item === "string").slice(0, SLASH_RECENTS_LIMIT)
      : [];
  } catch {
    return [];
  }
}

function storeSlashRecents(commands: string[]): void {
  if (typeof window === "undefined") return;
  try {
    window.localStorage.setItem(
      SLASH_RECENTS_STORAGE_KEY,
      JSON.stringify(commands.slice(0, SLASH_RECENTS_LIMIT)),
    );
  } catch {
    // localStorage may be unavailable in private contexts; command insertion still works.
  }
}

function queuedPromptLabel(prompt: QueuedPromptContent): string {
  const text = prompt.text.trim();
  if (text) return text;
  return prompt.images?.map((img) => img.name).filter(Boolean).join(", ") || "File attachment";
}

function visualViewportBounds(): { top: number; bottom: number; height: number } {
  const viewport = window.visualViewport;
  if (!viewport) {
    return { top: 0, bottom: window.innerHeight, height: window.innerHeight };
  }
  const top = Math.max(0, viewport.offsetTop);
  const height = Math.max(0, viewport.height);
  return { top, bottom: top + height, height };
}

function getVisibleBounds(el: HTMLElement): { top: number; bottom: number } {
  // The app already follows the visual viewport on touch browsers. Measure
  // its frame in the same coordinates as the composer, not WebKit's pan offset.
  // During pinch zoom the app stops fitting, so use the zoomed viewport again.
  const fittedRoot = window.visualViewport?.scale === 1
    ? el.closest("#root.visual-viewport")
    : null;
  const viewport = fittedRoot?.getBoundingClientRect() ?? visualViewportBounds();
  let top = viewport.top;
  let bottom = viewport.bottom;
  let parent = el.parentElement;

  while (parent) {
    const style = window.getComputedStyle(parent);
    if (/(auto|scroll|hidden|clip)/.test(style.overflowY)) {
      const rect = parent.getBoundingClientRect();
      top = Math.max(top, rect.top);
      bottom = Math.min(bottom, rect.bottom);
    }
    parent = parent.parentElement;
  }

  return { top, bottom };
}

function goalStateStripPreview(
  goal: GoalStateWsPayload | undefined,
  t: (key: string) => string,
): string | null {
  if (!goal?.active) return null;
  const summary = goal.ui_summary?.trim();
  if (summary) return summary;
  const obj = goal.objective?.trim();
  if (obj) return obj.length > 72 ? `${obj.slice(0, 72)}…` : obj;
  return t("thread.composer.goalStateFallback");
}

const GOAL_PANEL_VIEWPORT_TOP_PAD = 20;
const GOAL_PANEL_GAP_ABOVE_STRIP_PX = 10;
const GOAL_PANEL_MIN_HEIGHT_PX = 112;
const GOAL_PANEL_MAX_VIEWPORT_RATIO = 0.62;

function measureGoalPanelMaxCssHeight(stripTopY: number): number {
  const viewport = visualViewportBounds();
  const spaceAboveStrip =
    stripTopY - viewport.top - GOAL_PANEL_VIEWPORT_TOP_PAD - GOAL_PANEL_GAP_ABOVE_STRIP_PX;
  return Math.min(
    Math.max(spaceAboveStrip, GOAL_PANEL_MIN_HEIGHT_PX),
    Math.floor(viewport.height * GOAL_PANEL_MAX_VIEWPORT_RATIO),
  );
}

function buildGoalMarkdownBody(summary: string, objective: string): string {
  const s = summary.trim();
  const o = objective.trim();
  if (s && o) return `${s}\n\n---\n\n${o}`;
  return o || s;
}

function cliAppMentionPayload(app: CliAppInfo): OutboundCliAppMention {
  return {
    name: app.name,
    display_name: app.display_name,
    category: app.category,
    entry_point: app.entry_point,
    logo_url: app.logo_url ?? null,
    brand_color: app.brand_color ?? null,
  };
}

function mcpPresetMentionPayload(preset: McpPresetInfo): OutboundMcpPresetMention {
  return {
    name: preset.name,
    display_name: preset.display_name,
    category: preset.category,
    transport: preset.transport,
    status: preset.status,
    configured: preset.configured,
    logo_url: preset.logo_url ?? null,
    brand_color: preset.brand_color ?? null,
  };
}

function GoalStateStrip({
  goalState,
}: {
  goalState?: GoalStateWsPayload;
}) {
  const { t } = useTranslation();
  const [goalPanelOpen, setGoalPanelOpen] = useState(false);
  const stripLabel = goalStateStripPreview(goalState, t);
  const active = !!stripLabel?.trim();
  const [, setTick] = useState(0);
  const stripWrapperRef = useRef<HTMLDivElement>(null);
  const panelRef = useRef<HTMLDivElement>(null);
  const expandToggleRef = useRef<HTMLButtonElement>(null);
  const stripSnapshotRef = useRef<{
    goalState?: GoalStateWsPayload;
    stripLabel: string | null;
  } | null>(null);
  const [panelMaxPx, setPanelMaxPx] = useState(280);

  if (active) {
    stripSnapshotRef.current = { goalState, stripLabel };
  }

  useEffect(() => {
    if (!active) setGoalPanelOpen(false);
  }, [active]);

  const display = active
    ? { goalState, stripLabel }
    : stripSnapshotRef.current;
  const displayGoalState = display?.goalState;
  const displayStripLabel = display?.stripLabel ?? null;

  const objectiveFull = displayGoalState?.objective?.trim() ?? "";
  const summaryFull = displayGoalState?.ui_summary?.trim() ?? "";
  const canExpandGoal = !!(active && displayGoalState?.active && (objectiveFull || summaryFull));

  const markdownBody =
    objectiveFull || summaryFull
      ? buildGoalMarkdownBody(summaryFull, objectiveFull)
      : "";

  useLayoutEffect(() => {
    if (!goalPanelOpen) return;

    function relayout(): void {
      const el = stripWrapperRef.current;
      if (!el) return;
      const top = el.getBoundingClientRect().top;
      setPanelMaxPx(measureGoalPanelMaxCssHeight(top));
    }

    relayout();

    void preloadMarkdownText();
    const ro =
      typeof ResizeObserver !== "undefined"
        ? new ResizeObserver(() => relayout())
        : null;
    if (stripWrapperRef.current && ro) {
      ro.observe(stripWrapperRef.current);
    }
    const viewport = window.visualViewport;
    viewport?.addEventListener("resize", relayout);
    viewport?.addEventListener("scroll", relayout);
    window.addEventListener("resize", relayout);
    window.addEventListener("scroll", relayout, true);
    return () => {
      ro?.disconnect();
      viewport?.removeEventListener("resize", relayout);
      viewport?.removeEventListener("scroll", relayout);
      window.removeEventListener("resize", relayout);
      window.removeEventListener("scroll", relayout, true);
    };
  }, [goalPanelOpen]);

  useEffect(() => {
    if (!goalPanelOpen) return;

    function onPointerDown(ev: MouseEvent): void {
      const target = ev.target as Node | null;
      if (!target) return;
      if (panelRef.current?.contains(target)) return;
      if (expandToggleRef.current?.contains(target)) return;
      setGoalPanelOpen(false);
    }

    function onKey(ev: KeyboardEvent): void {
      if (ev.key === "Escape") setGoalPanelOpen(false);
    }

    window.addEventListener("mousedown", onPointerDown);
    window.addEventListener("keydown", onKey);
    return () => {
      window.removeEventListener("mousedown", onPointerDown);
      window.removeEventListener("keydown", onKey);
    };
  }, [goalPanelOpen]);

  if (!display) return null;

  const ariaLabel = displayStripLabel
    ? t("thread.composer.goalStateStrip", { label: displayStripLabel })
    : t("thread.composer.goalStateFallback");

  return (
    <div
      ref={stripWrapperRef}
      className="composer-status-drawer relative z-30"
      data-composer-status-drawer=""
      data-state={active ? "open" : "closed"}
      aria-hidden={active ? undefined : true}
      onTransitionEnd={(event) => {
        if (active || event.target !== event.currentTarget) return;
        stripSnapshotRef.current = null;
        setTick((n) => n + 1);
      }}
    >
      {goalPanelOpen && canExpandGoal && markdownBody ? (
        <div
          ref={panelRef}
          id="nanobot-goal-panel-root"
          role="dialog"
          aria-modal="false"
          aria-label={t("thread.composer.goalStateSheetTitle")}
          tabIndex={-1}
          className={cn(
            "absolute bottom-[calc(100%+8px)] left-3 right-3 z-[50] flex max-w-none flex-col overflow-hidden",
            "rounded-2xl",
            floatingSurfaceElevationClassName,
          )}
          style={{ maxHeight: `${Math.round(panelMaxPx)}px` }}
        >
          <div
            id="nanobot-goal-panel-scroll"
            className="min-h-0 flex-1 overflow-y-auto scrollbar-thin p-3"
          >
            <MarkdownText className="max-w-none text-foreground/90">
              {markdownBody}
            </MarkdownText>
          </div>
        </div>
      ) : null}
      <div className="composer-status-drawer-clip">
        {display ? (
          <div
            className="composer-status-drawer-content flex min-h-[36px] items-center gap-2 px-3 py-2"
            role="status"
            aria-label={ariaLabel}
          >
            <GoalIcon className="h-4 w-4 shrink-0 text-primary/75" aria-hidden />
            <span className="flex min-w-0 flex-1 items-center gap-1.5 text-[12px] font-medium text-foreground/75">
              {displayStripLabel ? (
                <span className="truncate">
                  {t("thread.composer.goalStateStrip", { label: displayStripLabel })}
                </span>
              ) : null}
            </span>
            {canExpandGoal ? (
              <button
                ref={expandToggleRef}
                type="button"
                className={cn(
                  "inline-flex h-8 w-8 shrink-0 items-center justify-center rounded-full",
                  "text-muted-foreground transition-colors hover:text-foreground",
                  "focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
                )}
                aria-expanded={goalPanelOpen}
                aria-controls={goalPanelOpen ? "nanobot-goal-panel-root" : undefined}
                aria-label={t("thread.composer.goalStateExpandAria")}
                title={t("thread.composer.goalStateExpandAria")}
                onClick={() => setGoalPanelOpen((o) => !o)}
              >
                {goalPanelOpen ? (
                  <ChevronDown className="h-4 w-4" aria-hidden />
                ) : (
                  <ChevronUp className="h-4 w-4" aria-hidden />
                )}
              </button>
            ) : null}
          </div>
        ) : null}
      </div>
    </div>
  );
}

function autosizeTextarea(input: HTMLTextAreaElement) {
  const container = input.parentElement!;
  const previousMinHeight = container.style.minHeight;
  // Measuring the one-row textarea must not expand the sibling transcript and
  // clamp its native scroll offset, even temporarily before paint.
  container.style.minHeight = `${container.getBoundingClientRect().height}px`;
  try {
    input.style.height = "auto";
    input.style.height = `${Math.min(input.scrollHeight, 260)}px`;
  } finally {
    container.style.minHeight = previousMinHeight;
  }
}

export function ThreadComposer({
  onSend,
  disabled,
  placeholder,
  inputAriaLabel,
  compactWhenIdle = false,
  isStreaming = false,
  activeTurnId = null,
  completedTurnIds,
  modelLabel = null,
  modelDetail = null,
  modelPreset = null,
  modelPresets = [],
  onModelPresetChange,
  modelProvider = null,
  modelProviderLabel = null,
  modelNeedsSetup = false,
  onModelBadgeClick,
  onManageModels,
  renderContextUsage,
  variant = "thread",
  slashCommands = [],
  onMentionSearch,
  cliApps = [],
  mcpPresets = [],
  sessions = [],
  skills = [],
  onStop,
  surfaceRef,
  onTranscribeAudio,
  onInspectAttachment,
  goalState,
  workspaceScope = null,
  workspaceControlsHidden = false,
  workspacePickerLayoutAnchor,
  workspaceDefaultScope = null,
  workspaceControls = null,
  workspaceScopeDisabled = false,
  workspaceProjectLocked = false,
  workspaceError = null,
  onLoadWorkspaceProjects,
  onResolveWorkspaceProject,
  onFavoriteWorkspaceProject,
  onBrowseWorkspaceDirectories,
  onWorkspaceScopeChange,
  pendingQueueKey = null,
  draftKey,
  draftStore,
  persistDraft = false,
  transcriptionProvider = null,
  ingressLimits = null,
  quotedContext = null,
  focusRequest = 0,
  onQuotedContextChange,
}: ThreadComposerProps) {
  const { t } = useTranslation();
  const [initialDraft] = useState(() => draftKey ? draftStore?.get(draftKey, persistDraft) : undefined);
  const [value, setValue] = useState(initialDraft?.text ?? "");
  const [composerFocused, setComposerFocused] = useState(false);
  const [compactPlaceholder, setCompactPlaceholder] = useState(false);
  const blurFrame = useRef<number | null>(null);
  const [boundSessionMentions, setBoundSessionMentions] = useState<SessionMention[]>(
    initialDraft?.sessionMentions ?? [],
  );
  const [sessionDragPreview, setSessionDragPreview] = useState<{
    mention: SessionMention;
    start: number;
    end: number;
  } | null>(null);
  const [inlineError, setInlineError] = useState<string | null>(null);
  const [sendPending, setSendPending] = useState(false);
  const [pathInspection, setPathInspection] = useState<{
    generation: number; scope: string; range: PastedPathRange; attachment?: LocalAttachment;
  } | null>(null);
  const pathCheckGeneration = useRef(0);
  const pathCheckScope = useRef("");
  const scopeIdentity = `${workspaceScope?.project_path ?? ""}:${workspaceScope?.access_mode ?? ""}`;
  pathCheckScope.current = scopeIdentity;
  useEffect(() => () => { pathCheckGeneration.current += 1; }, []);
  const [modelSetupAttentionRequest, setModelSetupAttentionRequest] = useState(0);
  const textareaRef = useRef<HTMLTextAreaElement>(null);
  const focusTextarea = useCallback(() => {
    requestAnimationFrame(() => textareaRef.current?.focus());
  }, []);
  const maxAttachments = ingressLimits?.attachments.max_count
    ?? MAX_ATTACHMENTS_PER_MESSAGE;
  const maxFileBytes = ingressLimits?.attachments.max_file_bytes ?? MAX_ATTACHMENT_BYTES;
  const maxTextBytes = ingressLimits?.message.max_text_bytes ?? 64 * 1024;

  const formatRejection = useCallback(
    (reason: Exclude<AttachmentError, "too_large">): string => {
      const key = `thread.composer.imageRejected.${reason}`;
      const fallback = reason === "too_many_videos"
        ? "Max 1 video per message"
        : reason === "too_many_attachments"
        ? `Max ${maxAttachments} attachments per message`
        : reason === "empty_file"
          ? "Empty files cannot be attached"
          : reason === "total_too_large"
            ? "Attachments are too large together — remove some or use smaller files"
            : "Unsupported file type";
      return t(key, { max: maxAttachments, defaultValue: fallback });
    },
    [maxAttachments, t],
  );

  const formatUploadTooLarge = useCallback(
    (size: number, maximum: number) => t("thread.composer.imageRejected.too_large", {
      size: formatBytes(size), max: formatBytes(maximum),
    }),
    [t],
  );

  const textTooLargeMessage = useCallback(
    () => t("thread.composer.textTooLarge", {
      max: formatBytes(maxTextBytes),
      defaultValue: `Message text is too large (max ${formatBytes(maxTextBytes)})`,
    }),
    [maxTextBytes, t],
  );

  const queuedPromptError = useCallback((prompt: QueuedPromptContent): string | null => {
    if (utf8Bytes(formatQuotedUserMessage(prompt.text, prompt.quotedContext)) > maxTextBytes) {
      return textTooLargeMessage();
    }
    const attachments = prompt.images ?? [];
    const videos = attachments.filter((item) => item.kind === "video").length;
    if (videos > MAX_VIDEOS_PER_MESSAGE) return formatRejection("too_many_videos");
    if (attachments.length - videos > maxAttachments) return formatRejection("too_many_attachments");
    const oversized = attachments.find((item) => queuedUploadBytes(item) > (item.kind === "video" ? MAX_VIDEO_BYTES : maxFileBytes));
    if (oversized) {
      return formatUploadTooLarge(queuedUploadBytes(oversized), oversized.kind === "video" ? MAX_VIDEO_BYTES : maxFileBytes);
    }
    const total = attachments.reduce((sum, item) => sum + (item.kind === "video" ? 0 : queuedUploadBytes(item)), 0);
    if (total > (ingressLimits?.attachments.max_total_bytes ?? MAX_TOTAL_ATTACHMENT_BYTES)) {
      return formatRejection("total_too_large");
    }
    if ((prompt.sessionMentions?.length ?? 0) > SESSION_MENTIONS_LIMIT) {
      return t("thread.composer.queued.tooManyMentions", { max: SESSION_MENTIONS_LIMIT });
    }
    return null;
  }, [formatRejection, formatUploadTooLarge, ingressLimits, maxAttachments, maxFileBytes, maxTextBytes, t, textTooLargeMessage]);

  const {
    snapshot: queueSnapshot,
    collect: collectQueuedPrompt,
    enqueue: enqueueQueuedPrompt,
    clear: clearQueuedPrompt,
    pause: pauseQueue,
    send: sendQueuedPrompt,
  } = useQueuedPrompt(pendingQueueKey, { isStreaming, activeTurnId, completedTurnIds }, {
    disabled: !!disabled || sendPending,
    onSend,
    validate: queuedPromptError,
    onValidationError: setInlineError,
    onSendAttempt: focusTextarea,
  });
  const queuedPrompt = queueSnapshot.prompt;
  const interactionDisabled = !!disabled || sendPending || queueSnapshot.sending;
  useEffect(() => {
    if (queueSnapshot.error) setInlineError(queueSnapshot.error);
  }, [queueSnapshot.error]);
  const [voiceErrorFading, setVoiceErrorFading] = useState(false);
  const [slashMenuDismissed, setSlashMenuDismissed] = useState(false);
  const [selectedCommandIndex, setSelectedCommandIndex] = useState(0);
  const [cliAppMenuDismissed, setCliAppMenuDismissed] = useState(false);
  const [selectedCliAppIndex, setSelectedCliAppIndex] = useState(0);
  const [cursorPosition, setCursorPosition] = useState(0);
  const [recentSlashCommands, setRecentSlashCommands] = useState<string[]>(() => readSlashRecents());
  const hasTouchPrimaryPointer = useMediaQuery("(hover: none) and (pointer: coarse)");
  // Coarser than hasTouchPrimaryPointer on purpose: tablets with a physical
  // keyboard still get the newline-on-Enter behavior.
  const hasCoarsePointer = useMediaQuery("(pointer: coarse)");
  const mobileWorkspaceControls = useMediaQuery("(max-width: 639px)");
  const { readingTextSize, customReadingTextSize } = useLocalPreferences();
  const placeholderMeasureRef = useRef<HTMLSpanElement>(null);
  const mentionOverlayRef = useRef<HTMLDivElement>(null);
  const formRef = useRef<HTMLFormElement>(null);
  const [compactControls, setCompactControls] = useState(false);

  useLayoutEffect(() => {
    const form = formRef.current;
    if (!form) return;
    let previousWidth = 0;
    const update = () => {
      const width = form.getBoundingClientRect().width;
      if (width <= 0 || width === previousWidth) return;
      previousWidth = width;
      setCompactControls(width <= 512);
      const input = textareaRef.current;
      if (input) autosizeTextarea(input);
    };
    update();
    const observer = typeof ResizeObserver === "undefined" ? null : new ResizeObserver(update);
    observer?.observe(form);
    window.addEventListener("resize", update);
    return () => {
      observer?.disconnect();
      window.removeEventListener("resize", update);
    };
  }, []);
  const fileInputRef = useRef<HTMLInputElement>(null);
  const chipRefs = useRef(new Map<string, HTMLButtonElement>());
  const previousPendingQueueKeyRef = useRef(pendingQueueKey);
  const voiceShortcutDownRef = useRef(false);
  const voiceErrorFadeTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
  const isHero = variant === "hero";
  const voiceShortcutLabel = useMemo(getVoiceShortcutLabel, []);
  const projectPickerAvailable =
    !workspaceProjectLocked
    && !!workspaceDefaultScope
    && !!onWorkspaceScopeChange
    && !!onLoadWorkspaceProjects
    && !!onBrowseWorkspaceDirectories
    && !!onResolveWorkspaceProject
    && !!onFavoriteWorkspaceProject
    && workspaceControls?.can_change_project !== false;
  const showProjectPicker = projectPickerAvailable && !workspaceControlsHidden;

  const resolvedPlaceholder = placeholder ?? t("thread.composer.placeholder");
  const showCompactPlaceholder = placeholder === undefined && compactPlaceholder;
  const displayedPlaceholder = showCompactPlaceholder ? t("thread.composer.placeholderCompact") : resolvedPlaceholder;

  useLayoutEffect(() => {
    const input = textareaRef.current;
    const text = placeholderMeasureRef.current;
    if (!input || !text || placeholder !== undefined) return;
    const measure = () => {
      const style = getComputedStyle(input);
      const available = input.clientWidth - parseFloat(style.paddingLeft) - parseFloat(style.paddingRight);
      if (available > 0) setCompactPlaceholder(text.getBoundingClientRect().width > available);
    };
    measure();
    const observer = typeof ResizeObserver === "undefined" ? null : new ResizeObserver(measure);
    observer?.observe(input);
    observer?.observe(text);
    window.addEventListener("resize", measure);
    let active = true;
    void document.fonts?.ready.then(() => { if (active) measure(); });
    return () => {
      active = false;
      observer?.disconnect();
      window.removeEventListener("resize", measure);
    };
  }, [placeholder, resolvedPlaceholder, compactControls, readingTextSize, customReadingTextSize]);

  const { images, enqueue, addLocal, remove, clear, restoreReadyImages, encoding: encodingFiles, full } =
    useAttachedImages({ ingressLimits });
  const encoding = encodingFiles || pathInspection !== null;
  const restoredDraftAttachments = useRef(false);
  const [draftAttachmentsReady, setDraftAttachmentsReady] = useState(!initialDraft?.attachments.length);
  useLayoutEffect(() => {
    if (restoredDraftAttachments.current) return;
    restoredDraftAttachments.current = true;
    for (const attachment of initialDraft?.attachments ?? []) {
      if (attachment instanceof File) enqueue([attachment], { restoringDraft: true });
      else addLocal(attachment, { restoringDraft: true });
    }
    setDraftAttachmentsReady(true);
  }, [enqueue, addLocal, initialDraft]);

  const addFiles = useCallback(
    (files: File[]) => {
      if (interactionDisabled || files.length === 0) return;
      const { rejected } = enqueue(files);
      if (rejected.length > 0) {
        const { reason, file } = rejected[0];
        setInlineError(reason === "too_large"
          ? formatUploadTooLarge(file.size, acceptedAttachmentKind(file) === "video" ? MAX_VIDEO_BYTES : maxFileBytes)
          : formatRejection(reason));
      } else {
        setInlineError(null);
      }
    },
    [enqueue, formatRejection, formatUploadTooLarge, interactionDisabled, maxFileBytes],
  );

  const {
    isDragging,
    onPaste: onAttachmentPaste,
    onDragEnter,
    onDragOver,
    onDragLeave,
    onDrop,
  } = useClipboardAndDrop(addFiles);

  useEffect(() => {
    if (compactWhenIdle || interactionDisabled || hasTouchPrimaryPointer || (workspaceError && showProjectPicker)) {
      return;
    }
    const el = textareaRef.current;
    if (!el) return;
    const id = requestAnimationFrame(() => el.focus());
    return () => cancelAnimationFrame(id);
  }, [compactWhenIdle, hasTouchPrimaryPointer, interactionDisabled, showProjectPicker, workspaceError]);

  useEffect(() => () => {
    if (blurFrame.current !== null) cancelAnimationFrame(blurFrame.current);
  }, []);

  useEffect(() => {
    if (!focusRequest || interactionDisabled) return;
    const id = requestAnimationFrame(() => textareaRef.current?.focus());
    return () => cancelAnimationFrame(id);
  }, [focusRequest, interactionDisabled]);

  const normalizedQuotedContext = quotedContext?.trim() || null;

  const readyImages = useMemo(
    () => images.filter((img) =>
      img.status === "ready" && (typeof img.dataUrl === "string" || !!img.local),
    ),
    [images],
  );
  const hasErrors = images.some((img) => img.status === "error");

  const isUserShell = value.trimStart().startsWith("!");
  const requiresModelSetup = modelNeedsSetup && !isUserShell;
  const hasComposerContent = value.trim().length > 0 || readyImages.length > 0;
  const canSend =
    !interactionDisabled
    && !requiresModelSetup
    && !encoding
    && !hasErrors
    && hasComposerContent;
  const canOpenModelSettings = Boolean(
    requiresModelSetup && onModelBadgeClick && !interactionDisabled,
  );
  const canQueueGuidance =
    isStreaming
    && !isUserShell
    && !interactionDisabled
    && !modelNeedsSetup
    && !encoding
    && !hasErrors
    && hasComposerContent
    // Without command metadata, let the gateway classify slash input immediately.
    && (slashCommands.length > 0
      ? !isRegisteredSlashCommand(value, slashCommands)
      : !value.trimStart().startsWith("/"));

  const slashQuery = useMemo(() => {
    if (interactionDisabled || slashMenuDismissed || !value.startsWith("/")) return null;
    const commandToken = value.slice(1);
    if (/\s/.test(commandToken)) return null;
    return commandToken.toLowerCase();
  }, [interactionDisabled, slashMenuDismissed, value]);

  const skillQuery = useMemo(() => {
    if (interactionDisabled || isUserShell || slashMenuDismissed) return null;
    const caret = Math.min(Math.max(cursorPosition, 0), value.length);
    const beforeCaret = value.slice(0, caret);
    const match = /\$([A-Za-z0-9_-]*)$/i.exec(beforeCaret);
    if (!match) return null;
    return {
      end: caret,
      start: match.index,
      text: match[1].toLowerCase(),
    };
  }, [cursorPosition, interactionDisabled, isUserShell, slashMenuDismissed, value]);

  const skillMenuActive = skillQuery !== null;
  useEffect(() => {
    // Also refresh an empty menu: skills may have been installed by the agent.
    if (skillMenuActive) requestSkillsRefresh();
  }, [skillMenuActive]);

  const visibleSlashCommands = useMemo(() => {
    if (!(isStreaming && onStop)) return slashCommands;
    const stopCommand = slashCommands.find((command) => command.command === "/stop");
    if (!stopCommand) return slashCommands;
    return [
      stopCommand,
      ...slashCommands.filter((command) => command.command !== "/stop"),
    ];
  }, [isStreaming, onStop, slashCommands]);

  const filteredSlashCommands = useMemo<SlashPaletteCommand[]>(() => {
    if (skillQuery !== null) {
      const query = skillQuery.text;
      return skills
        .filter((skill) => skill.enabled !== false && skill.available)
        .flatMap((skill) => {
          const matchRank = skillMatchRank(skill, query);
          return matchRank === null
            ? []
            : [{
                command: `$${skill.name}`,
                matchRank,
                skill,
              }];
        })
        .sort((a, b) => {
          if (a.matchRank !== b.matchRank) return a.matchRank - b.matchRank;
          if (query !== "") return 0;
          const aRecent = recentSlashCommands.indexOf(a.command);
          const bRecent = recentSlashCommands.indexOf(b.command);
          if (aRecent === -1 && bRecent === -1) return 0;
          if (aRecent === -1) return 1;
          if (bRecent === -1) return -1;
          return aRecent - bRecent;
        })
        .slice(0, 8)
        .map(({ command, skill }) => {
          const description = skill.description || skill.name;
          return {
            command,
            title: skill.name,
            description,
            detail: description,
            icon: "brain",
            kind: "skill" as const,
            recent: recentSlashCommands.includes(command),
          };
        });
    }
    if (slashQuery === null) return [];
    const withDetails = visibleSlashCommands
      .filter((command) => {
        if (
          slashQuery === ""
          && (
            command.command === "/restart"
            || (command.command === "/stop" && !(isStreaming && onStop))
          )
        ) {
          return false;
        }
        const commandKey = slashCommandI18nKey(command.command);
        const title = t(`thread.composer.slash.commands.${commandKey}.title`, {
          defaultValue: command.title,
        });
        const description = t(`thread.composer.slash.commands.${commandKey}.description`, {
          defaultValue: command.description,
        });
        const haystack = [
          command.command,
          command.title,
          command.description,
          command.argHint ?? "",
          title,
          description,
        ].join(" ").toLowerCase();
        return haystack.includes(slashQuery);
      })
      .map((command) => {
        const commandKey = slashCommandI18nKey(command.command);
        const description = t(`thread.composer.slash.commands.${commandKey}.description`, {
          defaultValue: command.description,
        });
        let detail = description;
        let badge: string | undefined;
        if (command.command === "/model" && modelLabel) {
          detail = modelLabel;
          badge = t("thread.composer.slash.badges.current");
        } else if (command.command === "/goal") {
          detail = goalState?.active
            ? t("thread.composer.slash.details.goalActive")
            : t("thread.composer.slash.details.goalReady");
        } else if (command.command === "/stop" && isStreaming) {
          detail = t("thread.composer.slash.details.stopRunning");
        } else if (command.command === "/history") {
          detail = t("thread.composer.slash.details.history");
        }
        return {
          ...command,
          detail,
          badge,
          recent: recentSlashCommands.includes(command.command),
        };
      })
      .sort((a, b) => {
        if (isStreaming) {
          if (a.command === "/stop") return -1;
          if (b.command === "/stop") return 1;
        }
        if (slashQuery !== "") return 0;
        const aRecent = recentSlashCommands.indexOf(a.command);
        const bRecent = recentSlashCommands.indexOf(b.command);
        if (aRecent !== -1 || bRecent !== -1) {
          if (aRecent === -1) return 1;
          if (bRecent === -1) return -1;
          return aRecent - bRecent;
        }
        return 0;
      });

    return withDetails
      .slice(0, 8);
  }, [goalState?.active, isStreaming, modelLabel, recentSlashCommands, skills, skillQuery, slashQuery, t, visibleSlashCommands]);

  const showSlashMenu = filteredSlashCommands.length > 0;
  const cliAppMention = useMemo<CliAppMentionQuery | null>(() => {
    if (interactionDisabled || isUserShell || cliAppMenuDismissed) return null;
    const caret = Math.min(Math.max(cursorPosition, 0), value.length);
    const beforeCaret = value.slice(0, caret);
    const match = /@([\p{L}\p{N}_-]*)$/iu.exec(beforeCaret);
    if (!match || !isCapabilityMentionStart(value, match.index)) return null;
    const query = match[1].toLowerCase();
    return {
      query,
      start: match.index,
      end: caret,
    };
  }, [cliAppMenuDismissed, cursorPosition, interactionDisabled, isUserShell, value]);

  const mentionSearchActive = cliAppMention !== null;
  useEffect(() => {
    if (mentionSearchActive) onMentionSearch?.();
  }, [mentionSearchActive, onMentionSearch]);

  const availableSessionMentions = useMemo(
    () => sessionMentionOptions(sessions),
    [sessions],
  );
  const sessionMentionCatalog = useMemo(
    () => [...availableSessionMentions, ...boundSessionMentions],
    [availableSessionMentions, boundSessionMentions],
  );
  const mentionSegments = useMemo<CapabilityMentionSegment[]>(
    () => isUserShell ? [{ kind: "text", text: value }]
      : splitCapabilityMentionSegments(value, cliApps, mcpPresets, sessionMentionCatalog),
    [cliApps, isUserShell, mcpPresets, sessionMentionCatalog, value],
  );
  const editMentionInput = useCallback((next: string, cursor: number) => {
    setValue(next);
    setSlashMenuDismissed(false);
    setCliAppMenuDismissed(false);
    setCursorPosition(cursor);
  }, []);
  const mentionInput = useComposerMentionInput({
    segments: mentionSegments,
    inputRef: textareaRef,
    onEdit: editMentionInput,
    resetKey: pendingQueueKey,
  });
  const { rawSelection, replace: replaceMentionInput } = mentionInput;
  const onPaste = useCallback((event: React.ClipboardEvent<HTMLTextAreaElement>) => {
    onAttachmentPaste(event);
    if (event.defaultPrevented || interactionDisabled || isUserShell || !onInspectAttachment) return;
    const raw = event.clipboardData.getData("text/plain");
    const path = pastedFilePath(raw);
    if (!path) return;
    event.preventDefault();
    const { start, end } = rawSelection();
    const pasted = value.slice(0, start) + raw + value.slice(end);
    const generation = ++pathCheckGeneration.current;
    replaceMentionInput(pasted, start + raw.length);
    setPathInspection({ generation, scope: scopeIdentity, range: new PastedPathRange(pasted, start, start + raw.length) });
    void onInspectAttachment(path).then((attachment) => {
      if (generation !== pathCheckGeneration.current) return;
      setPathInspection((current) => current?.generation === generation ? { ...current, attachment } : current);
    }).catch((error: unknown) => {
      if (generation !== pathCheckGeneration.current || pathCheckScope.current !== scopeIdentity) return;
      setPathInspection(null);
      if (error instanceof Error && "status" in error && error.status === 404) return;
      setInlineError(error instanceof Error ? error.message : t("message.attachmentUnavailable"));
    });
  }, [interactionDisabled, isUserShell, onAttachmentPaste, onInspectAttachment, rawSelection, replaceMentionInput, scopeIdentity, t, value]);

  useLayoutEffect(() => {
    if (!pathInspection) return;
    if (isUserShell || pathInspection.scope !== scopeIdentity || !pathInspection.range.update(value)) {
      pathCheckGeneration.current += 1;
      setPathInspection(null);
      return;
    }
    // Let the native IME commit before removing the confirmed path from its text.
    if (!pathInspection.attachment || mentionInput.isComposing) return;
    const edited = pathInspection.range.replace("", rawSelection().start);
    if (edited) {
      const rejection = addLocal(pathInspection.attachment);
      if (rejection) setInlineError(formatRejection(rejection));
      else {
        replaceMentionInput(edited.value, edited.cursor, { preserveFocus: true });
        setInlineError(null);
      }
    }
    setPathInspection(null);
  }, [addLocal, formatRejection, isUserShell, mentionInput.isComposing, pathInspection, rawSelection, replaceMentionInput, scopeIdentity, value]);

  const draftText = composerMentionText(mentionInput.segments).raw;
  const sessionDragInsertion = sessionDragPreview
    ? mentionInsertion(
        value,
        sessionDragPreview.mention.name,
        sessionDragPreview.start,
        sessionDragPreview.end,
      )
    : null;
  const displayMentionSegments = sessionDragInsertion && sessionDragPreview
    ? splitCapabilityMentionSegments(
        sessionDragInsertion.value,
        cliApps,
        mcpPresets,
        sessionMentionCatalog,
      )
    : mentionInput.segments;
  const activeSessionMentions = useMemo(() => {
    const seen = new Set<string>();
    return mentionSegments.flatMap((segment) => {
      if (segment.kind !== "session" || seen.has(segment.mention.session_key)) return [];
      seen.add(segment.mention.session_key);
      return [segment.mention];
    });
  }, [mentionSegments]);
  useLayoutEffect(() => {
    // Pin resolved identities so a catalog refresh cannot retarget an existing reference.
    if (activeSessionMentions.length !== boundSessionMentions.length
      || activeSessionMentions.some((mention, index) => mention !== boundSessionMentions[index])) {
      setBoundSessionMentions(activeSessionMentions);
    }
  }, [activeSessionMentions, boundSessionMentions]);
  useLayoutEffect(() => {
    if (!draftKey || !draftStore || !draftAttachmentsReady) return;
    if (!draftText && images.length === 0 && !quotedContext) {
      draftStore.delete(draftKey);
      return;
    }
    draftStore.set(draftKey, {
      text: draftText,
      attachments: images.flatMap((image): ComposerDraft["attachments"] => (
        image.local ? [image.local] : image.file instanceof File ? [image.file] : []
      )),
      sessionMentions: activeSessionMentions,
      quotedContext,
    }, persistDraft);
  }, [activeSessionMentions, draftAttachmentsReady, draftKey, draftStore, images, persistDraft, quotedContext, draftText]);
  const insertableSessionMentions = useMemo(() => availableSessionMentions.filter((mention) => {
    const bound = activeSessionMentions.find(
      (active) => active.name.toLowerCase() === mention.name.toLowerCase(),
    );
    return (!bound || bound.session_key === mention.session_key)
      && (activeSessionMentions.length < SESSION_MENTIONS_LIMIT
        || activeSessionMentions.some((active) => active.session_key === mention.session_key));
  }), [activeSessionMentions, availableSessionMentions]);
  const filteredMentionCandidates = useMemo<MentionCandidate[]>(() => {
    if (!cliAppMention) return [];
    const sessionCandidates: MentionCandidate[] = insertableSessionMentions
      .filter((mention) => [
        mention.name,
        mention.title,
      ].join(" ").toLowerCase().includes(cliAppMention.query))
      .map((mention) => ({
        kind: "session",
        name: mention.name,
        displayName: mention.title || mention.name,
        mention,
      }));
    const sessionNames = new Set(
      sessionMentionCatalog.map((mention) => mention.name.toLowerCase()),
    );
    const cliCandidates: MentionCandidate[] = cliApps
      .filter((app) => app.installed)
      .filter((app) => !sessionNames.has(app.name.toLowerCase()))
      .filter((app) => {
        const haystack = [
          app.name,
          app.display_name,
          app.category,
          app.description,
          app.entry_point,
        ].join(" ").toLowerCase();
        return haystack.includes(cliAppMention.query);
      })
      .map((app) => ({
        kind: "cli",
        name: app.name,
        displayName: app.display_name,
        brandColor: app.brand_color ?? null,
        logoUrl: app.logo_url ?? null,
        initials: cliAppInitials(app),
      }));
    const mcpCandidates: MentionCandidate[] = mcpPresets
      .filter((preset) => preset.installed && preset.configured)
      .filter((preset) => !sessionNames.has(preset.name.toLowerCase()))
      .filter((preset) => {
        const haystack = [
          preset.name,
          preset.display_name,
          preset.category,
          preset.description,
          preset.transport,
        ].join(" ").toLowerCase();
        return haystack.includes(cliAppMention.query);
      })
      .map((preset) => ({
        kind: "mcp",
        name: preset.name,
        displayName: preset.display_name,
        brandColor: preset.brand_color ?? null,
        logoUrl: preset.logo_url ?? null,
        initials: mcpPresetInitials(preset),
      }));
    const groups = [
      { candidates: sessionCandidates, reserved: 4 },
      { candidates: cliCandidates, reserved: 2 },
      { candidates: mcpCandidates, reserved: 2 },
    ];
    let remaining = 8;
    const counts = groups.map(({ candidates, reserved }) => {
      const count = Math.min(candidates.length, reserved);
      remaining -= count;
      return count;
    });
    for (const index of [0, 1, 2]) {
      const extra = Math.min(remaining, groups[index].candidates.length - counts[index]);
      counts[index] += extra;
      remaining -= extra;
    }
    return groups.flatMap(({ candidates }, index) => candidates.slice(0, counts[index]));
  }, [cliAppMention, cliApps, insertableSessionMentions, mcpPresets, sessionMentionCatalog]);

  const showCliAppMenu = filteredMentionCandidates.length > 0;
  const showAnyPalette = showSlashMenu || showCliAppMenu;
  const inlineSegments = useMemo(
    () => isUserShell ? displayMentionSegments : withSkillReferences(displayMentionSegments),
    [displayMentionSegments, isUserShell],
  );
  const slashCommand = matchingSlashCommand(sessionDragInsertion?.value ?? draftText, slashCommands);
  const hasInlineDecorations = isUserShell || slashCommand !== null || inlineSegments.some((segment) => segment.kind !== "text");
  const activeCliMentionApps = useMemo(() => {
    const seen = new Set<string>();
    return mentionSegments.flatMap((segment) => {
      if (segment.kind !== "cli" || seen.has(segment.app.name)) return [];
      seen.add(segment.app.name);
      return [segment.app];
    });
  }, [mentionSegments]);
  const activeMcpPresetMentions = useMemo(() => {
    const seen = new Set<string>();
    return mentionSegments.flatMap((segment) => {
      if (segment.kind !== "mcp" || seen.has(segment.preset.name)) return [];
      seen.add(segment.preset.name);
      return [segment.preset];
    });
  }, [mentionSegments]);
  const [slashPaletteLayout, setSlashPaletteLayout] = useState<SlashPaletteLayout>({
    placement: "above",
    maxHeight: SLASH_PALETTE_MAX_HEIGHT_PX,
  });

  useEffect(() => {
    setSelectedCommandIndex(0);
  }, [slashQuery]);

  useEffect(() => {
    setSelectedCliAppIndex(0);
  }, [cliAppMention?.query]);

  useEffect(() => {
    if (selectedCommandIndex >= filteredSlashCommands.length) {
      setSelectedCommandIndex(0);
    }
  }, [filteredSlashCommands.length, selectedCommandIndex]);

  useEffect(() => {
    if (selectedCliAppIndex >= filteredMentionCandidates.length) {
      setSelectedCliAppIndex(0);
    }
  }, [filteredMentionCandidates.length, selectedCliAppIndex]);

  useEffect(() => {
    if (!showAnyPalette) return;

    const dismissOnPointerDown = (event: PointerEvent) => {
      const target = event.target;
      if (target instanceof Node && formRef.current?.contains(target)) return;
      setSlashMenuDismissed(true);
      setCliAppMenuDismissed(true);
    };

    document.addEventListener("pointerdown", dismissOnPointerDown, true);
    return () => {
      document.removeEventListener("pointerdown", dismissOnPointerDown, true);
    };
  }, [showAnyPalette]);

  useLayoutEffect(() => {
    if (!showAnyPalette) return;

    const updateLayout = () => {
      const form = formRef.current;
      if (!form) return;
      const rect = form.getBoundingClientRect();
      if (rect.width === 0 && rect.height === 0) return;

      const bounds = getVisibleBounds(form);
      const spaceAbove = Math.max(0, rect.top - bounds.top - SLASH_PALETTE_GAP_PX);
      const spaceBelow = Math.max(0, bounds.bottom - rect.bottom - SLASH_PALETTE_GAP_PX);
      // A landscape keyboard can leave less height than one input and option.
      // Use the available width instead of clipping an absolute menu in the
      // short viewport's scrollable composer footer.
      const beside = rect.width >= 640
        && !!form.closest("#root.short-visual-viewport");
      const placement: SlashPalettePlacement =
        beside ? "beside" : spaceAbove >= SLASH_PALETTE_MIN_HEIGHT_PX || spaceAbove >= spaceBelow
          ? "above"
          : "below";
      const available = beside
        ? Math.max(0, bounds.bottom - bounds.top)
        : placement === "above" ? spaceAbove : spaceBelow;
      const maxHeight = Math.min(SLASH_PALETTE_MAX_HEIGHT_PX, available);

      setSlashPaletteLayout((current) =>
        current.placement === placement && current.maxHeight === maxHeight
          ? current
          : { placement, maxHeight },
      );
    };

    updateLayout();
    const viewport = window.visualViewport;
    viewport?.addEventListener("resize", updateLayout);
    viewport?.addEventListener("scroll", updateLayout);
    window.addEventListener("resize", updateLayout);
    document.addEventListener("scroll", updateLayout, true);
    const observer = typeof ResizeObserver === "undefined" ? null : new ResizeObserver(updateLayout);
    if (formRef.current) observer?.observe(formRef.current);
    return () => {
      observer?.disconnect();
      viewport?.removeEventListener("resize", updateLayout);
      viewport?.removeEventListener("scroll", updateLayout);
      window.removeEventListener("resize", updateLayout);
      document.removeEventListener("scroll", updateLayout, true);
    };
  }, [filteredMentionCandidates.length, filteredSlashCommands.length, showAnyPalette]);

  useLayoutEffect(() => {
    const el = textareaRef.current;
    if (!el || mentionInput.isComposing) return;
    autosizeTextarea(el);
    if (mentionOverlayRef.current) mentionOverlayRef.current.scrollTop = el.scrollTop;
  }, [compactControls, mentionInput.isComposing, mentionInput.value]);

  useEffect(() => {
    // The parent projects typography tokens in its layout effect; measure after it.
    const input = textareaRef.current;
    if (input) autosizeTextarea(input);
  }, [readingTextSize, customReadingTextSize]);

  // Runs before paint so switching sessions never flashes stale draft text.
  useLayoutEffect(() => {
    if (previousPendingQueueKeyRef.current === pendingQueueKey) return;
    previousPendingQueueKeyRef.current = pendingQueueKey;
    setValue("");
    setInlineError(null);
    setSlashMenuDismissed(false);
    setCliAppMenuDismissed(false);
    setCursorPosition(0);
    clear();
  }, [clear, pendingQueueKey]);

  const appendTranscription = useCallback((text: string) => {
    const transcript = text.trim();
    if (!transcript) return;
    setValue((current) => {
      if (!current.trim()) return transcript;
      const separator = /[\s\n]$/.test(current) ? "" : " ";
      return `${current}${separator}${transcript}`;
    });
    setSlashMenuDismissed(false);
    setCliAppMenuDismissed(false);
    setInlineError(null);
    focusTextarea();
  }, [focusTextarea]);

  const clearVoiceErrorTimers = useCallback(() => {
    if (voiceErrorFadeTimerRef.current !== null) clearTimeout(voiceErrorFadeTimerRef.current);
    voiceErrorFadeTimerRef.current = null;
  }, []);
  const clearInlineError = useCallback(() => {
    clearVoiceErrorTimers();
    setVoiceErrorFading(false);
    setInlineError(null);
  }, [clearVoiceErrorTimers]);
  const setVoiceError = useCallback((key: VoiceRecorderErrorKey) => {
    clearVoiceErrorTimers();
    setVoiceErrorFading(false);
    setInlineError(t(`thread.composer.voiceErrors.${key}`));
    voiceErrorFadeTimerRef.current = setTimeout(() => {
      setVoiceErrorFading(true);
      voiceErrorFadeTimerRef.current = setTimeout(() => {
        setInlineError(null);
        setVoiceErrorFading(false);
        voiceErrorFadeTimerRef.current = null;
      }, VOICE_ERROR_FADE_MS);
    }, VOICE_ERROR_VISIBLE_MS);
  }, [clearVoiceErrorTimers, t]);
  const voiceRecorder = useVoiceRecorder({
    disabled: interactionDisabled,
    onClearError: clearInlineError,
    onError: setVoiceError,
    onTranscript: appendTranscription,
    onTranscribeAudio,
    wantsWav: transcriptionProvider === "xiaomi_mimo",
  });

  useEffect(() => () => clearVoiceErrorTimers(), [clearVoiceErrorTimers]);

  useEffect(() => {
    if (!onTranscribeAudio) return;

    function onKeyDown(event: KeyboardEvent): void {
      if (!isVoiceShortcutDown(event) || event.repeat || voiceShortcutDownRef.current) return;
      event.preventDefault();
      voiceShortcutDownRef.current = true;
      voiceRecorder.beginShortcutHold();
    }

    function onKeyUp(event: KeyboardEvent): void {
      if (!voiceShortcutDownRef.current || !isVoiceShortcutRelease(event)) return;
      event.preventDefault();
      voiceShortcutDownRef.current = false;
      voiceRecorder.endShortcutHold();
    }

    function onWindowBlur(): void {
      if (!voiceShortcutDownRef.current) return;
      voiceShortcutDownRef.current = false;
      voiceRecorder.endShortcutHold();
    }

    window.addEventListener("keydown", onKeyDown);
    window.addEventListener("keyup", onKeyUp);
    window.addEventListener("blur", onWindowBlur);
    return () => {
      window.removeEventListener("keydown", onKeyDown);
      window.removeEventListener("keyup", onKeyUp);
      window.removeEventListener("blur", onWindowBlur);
    };
  }, [onTranscribeAudio, voiceRecorder.beginShortcutHold, voiceRecorder.endShortcutHold]);

  const handleStop = useCallback(() => {
    pauseQueue();
    onStop?.();
  }, [onStop, pauseQueue]);

  const chooseSlashCommand = useCallback(
    (command: SlashPaletteCommand) => {
      if (command.command === "/stop" && isStreaming && onStop) {
        handleStop();
        setValue("");
        setSlashMenuDismissed(true);
        setCliAppMenuDismissed(false);
        setInlineError(null);
        focusTextarea();
        return;
      }

      const nextRecents = [
        command.command,
        ...recentSlashCommands.filter((item) => item !== command.command),
      ].slice(0, SLASH_RECENTS_LIMIT);
      setRecentSlashCommands(nextRecents);
      storeSlashRecents(nextRecents);

      if (skillQuery !== null) {
        const suffix = value.slice(skillQuery.end);
        const inserted = `${command.command}${suffix.startsWith(" ") ? "" : " "}`;
        const next = `${value.slice(0, skillQuery.start)}${inserted}${suffix}`;
        const nextCursor = skillQuery.start + inserted.length;
        replaceMentionInput(next, nextCursor);
      } else {
        setValue(command.argHint ? `${command.command} ` : command.command);
      }
      setSlashMenuDismissed(true);
      setCliAppMenuDismissed(false);
      setInlineError(null);
      focusTextarea();
    },
    [handleStop, isStreaming, onStop, recentSlashCommands, replaceMentionInput, focusTextarea, skillQuery, value],
  );

  const insertMention = useCallback(
    (name: string, start: number, end: number) => {
      const insertion = mentionInsertion(value, name, start, end);
      replaceMentionInput(insertion.value, insertion.cursor);
      setCliAppMenuDismissed(true);
      setSlashMenuDismissed(false);
      setInlineError(null);
      focusTextarea();
    },
    [replaceMentionInput, focusTextarea, value],
  );

  const chooseMentionCandidate = useCallback(
    (candidate: MentionCandidate) => {
      if (!cliAppMention) return;
      insertMention(candidate.name, cliAppMention.start, cliAppMention.end);
    },
    [cliAppMention, insertMention],
  );

  const handleSessionDrop = useCallback((event: React.DragEvent) => {
    if (!hasDraggedSession(event.dataTransfer)) return false;
    event.preventDefault();
    clearDraggedSession();
    const preview = sessionDragPreview;
    setSessionDragPreview(null);
    if (interactionDisabled) return true;
    const sessionKey = readDraggedSession(event.dataTransfer);
    const mention = insertableSessionMentions.find(
      (candidate) => candidate.session_key === (sessionKey ?? preview?.mention.session_key),
    );
    if (!mention) return true;
    const caret = preview?.start ?? rawSelection().start;
    insertMention(mention.name, caret, preview?.end ?? rawSelection().end);
    return true;
  }, [insertableSessionMentions, insertMention, interactionDisabled, rawSelection, sessionDragPreview]);

  const previewSessionDrop = useCallback((event: React.DragEvent) => {
    if (!hasDraggedSession(event.dataTransfer)) return false;
    if (interactionDisabled) {
      event.dataTransfer.dropEffect = "none";
      setSessionDragPreview(null);
      return true;
    }
    const sessionKey = readDraggedSession(event.dataTransfer);
    const mention = insertableSessionMentions.find(
      (candidate) => candidate.session_key === sessionKey,
    );
    if (!mention) {
      event.dataTransfer.dropEffect = "none";
      setSessionDragPreview(null);
      return true;
    }
    event.preventDefault();
    event.dataTransfer.dropEffect = "copy";
    const { start, end } = rawSelection();
    setSessionDragPreview((current) => (
      current?.mention.session_key === mention.session_key
      && current.start === start
      && current.end === end
        ? current
        : { mention, start, end }
    ));
    return true;
  }, [insertableSessionMentions, interactionDisabled, rawSelection]);

  useEffect(() => {
    if (!sessionDragPreview) return;
    const clearPreview = () => {
      clearDraggedSession();
      setSessionDragPreview(null);
    };
    document.addEventListener("dragend", clearPreview);
    return () => document.removeEventListener("dragend", clearPreview);
  }, [sessionDragPreview]);

  const clearComposerText = useCallback((restoreFocus = true) => {
    setValue("");
    setInlineError(null);
    setSlashMenuDismissed(false);
    setCliAppMenuDismissed(false);
    setCursorPosition(0);
    if (restoreFocus) focusTextarea();
  }, [focusTextarea]);

  const collectGuidancePrompt = useCallback(() => collectQueuedPrompt({
    text: value,
    images: readyImagesToQueuedImages(readyImages),
    ...(normalizedQuotedContext ? { quotedContext: normalizedQuotedContext } : {}),
    sessionMentions: activeSessionMentions,
  }), [activeSessionMentions, collectQueuedPrompt, normalizedQuotedContext, readyImages, value]);

  const queueGuidancePrompt = useCallback(() => {
    if (!canQueueGuidance) return;
    if (!enqueueQueuedPrompt(collectGuidancePrompt())) return;
    clear();
    clearComposerText();
    onQuotedContextChange?.(null);
  }, [canQueueGuidance, clear, clearComposerText, collectGuidancePrompt, onQuotedContextChange, enqueueQueuedPrompt]);

  const removeQueuedPrompt = useCallback(() => {
    clearQueuedPrompt();
    requestAnimationFrame(() => textareaRef.current?.focus());
  }, [clearQueuedPrompt]);

  const editQueuedPrompt = useCallback((pending: QueuedPromptContent) => {
    const prompt = hasComposerContent || normalizedQuotedContext ? collectGuidancePrompt() : pending;
    clearQueuedPrompt();
    replaceMentionInput(prompt.text, prompt.text.length);
    setBoundSessionMentions(prompt.sessionMentions ?? []);
    setInlineError(null);
    setSlashMenuDismissed(false);
    setCliAppMenuDismissed(false);
    onQuotedContextChange?.(prompt.quotedContext ?? null);
    if (prompt.images?.length) {
      restoreReadyImages(prompt.images as RestoredReadyImage[]);
    } else {
      clear();
    }
    focusTextarea();
  }, [clear, collectGuidancePrompt, hasComposerContent, normalizedQuotedContext, onQuotedContextChange, replaceMentionInput, focusTextarea, restoreReadyImages, clearQueuedPrompt]);

  const submit = useCallback(() => {
    if (requiresModelSetup) {
      if (hasComposerContent) {
        setModelSetupAttentionRequest((request) => request + 1);
      }
      return;
    }
    if (!canSend) return;
    if (isUserShell && (images.length > 0 || normalizedQuotedContext)) {
      setInlineError(t("thread.composer.shell.removeContext"));
      return;
    }
    const trimmed = value.trim();
    const content = trimmed;
    if (utf8Bytes(formatQuotedUserMessage(content, normalizedQuotedContext)) > maxTextBytes) {
      setInlineError(textTooLargeMessage());
      return;
    }
    // Keep self-contained local previews across drafts and optimistic bubbles.
    // The client decodes these to HTTP binary; WS messages contain only refs.
    const payload = queuedImagesToSendImages(readyImagesToQueuedImages(readyImages));
    const attachedCliApps = activeCliMentionApps.map(cliAppMentionPayload);
    const attachedMcpPresets = activeMcpPresetMentions.map(mcpPresetMentionPayload);
    const options: SendOptions | undefined = !isUserShell && (
      attachedCliApps.length > 0
      || attachedMcpPresets.length > 0
      || activeSessionMentions.length > 0
      || normalizedQuotedContext
    )
        ? {
            ...(attachedCliApps.length > 0 ? { cliApps: attachedCliApps } : {}),
            ...(attachedMcpPresets.length > 0 ? { mcpPresets: attachedMcpPresets } : {}),
            ...(activeSessionMentions.length > 0
              ? { sessionMentions: activeSessionMentions }
              : {}),
            ...(normalizedQuotedContext ? { quotedContext: normalizedQuotedContext } : {}),
          }
        : undefined;
    const hasPlainTextCommandPayload =
      payload === undefined
      && attachedCliApps.length === 0
      && attachedMcpPresets.length === 0
      && activeSessionMentions.length === 0;
    const slashLifecycle = hasPlainTextCommandPayload
      ? slashCommandLifecycle(content, slashCommands)
      : null;
    if (
      slashLifecycle === "stop_active_turn"
      && isStreaming
      && onStop
    ) {
      handleStop();
      clear();
      clearComposerText();
      onQuotedContextChange?.(null);
      return;
    }
    const isSideChannel = isUserShell || isSideChannelLifecycle(slashLifecycle);
    const finalizeActiveTurn =
      slashLifecycle === "finalize_active_turn";
    if (!isUserShell && !slashLifecycle) {
      const prompt = collectGuidancePrompt();
      const error = queuedPromptError(prompt);
      if (error) {
        setInlineError(error);
        return;
      }
      if (queuedPrompt) {
        sendQueuedPrompt(prompt, options);
        if (draftKey) draftStore?.delete(draftKey);
        clear();
        clearComposerText(!hasTouchPrimaryPointer);
        onQuotedContextChange?.(null);
        return;
      }
    }
    const submittedDraft = draftKey ? draftStore?.get(draftKey) : undefined;
    const finishSend = () => {
      // A pending send can finish after this composer unmounts and a newer draft is started.
      if (draftKey && draftStore && draftStore.get(draftKey) !== submittedDraft) return;
      if (draftKey) draftStore?.delete(draftKey);
      if (hasTouchPrimaryPointer) textareaRef.current?.blur();
      if ((!isStreaming && !isUserShell) || finalizeActiveTurn) clearQueuedPrompt();
      // Bubble owns the data URL copy; safe to revoke every staged blob
      // preview here without affecting the rendered message.
      clear();
      clearComposerText(!hasTouchPrimaryPointer);
      onQuotedContextChange?.(null);
    };
    const result = onSend(
      content,
      payload,
      isSideChannel
        ? {
            ...options,
            sideChannel: true,
            ...(isUserShell ? { userShell: true } : {}),
            ...(finalizeActiveTurn ? { finalizeActiveTurn } : {}),
          }
        : isStreaming ? { ...options, continueActiveTurn: true } : options,
    );
    if (result instanceof Promise) {
      setSendPending(true);
      void result
        .then((accepted) => {
          if (accepted !== false) finishSend();
        })
        .catch((error: unknown) => {
          setInlineError(error instanceof Error ? error.message : "Failed to send message");
        })
        .finally(() => setSendPending(false));
      return;
    }
    if (result !== false) finishSend();
  }, [
    activeCliMentionApps,
    activeMcpPresetMentions,
    activeSessionMentions,
    canSend,
    draftKey,
    draftStore,
    clear,
    clearComposerText,
    collectGuidancePrompt,
    queuedPrompt,
    queuedPromptError,
    sendQueuedPrompt,
    clearQueuedPrompt,
    hasTouchPrimaryPointer,
    hasComposerContent,
    handleStop,
    images.length,
    isStreaming,
    isUserShell,
    maxTextBytes,
    requiresModelSetup,
    onSend,
    onStop,
    onQuotedContextChange,
    normalizedQuotedContext,
    readyImages,
    slashCommands,
    t,
    textTooLargeMessage,
    value,
  ]);

  const onKeyDown = (e: ReactKeyboardEvent<HTMLTextAreaElement>) => {
    mentionInput.onKeyDown(e);
    if (e.defaultPrevented || e.nativeEvent.isComposing || mentionInput.isComposing) return;
    if (showCliAppMenu) {
      if (e.key === "ArrowDown") {
        e.preventDefault();
        setSelectedCliAppIndex((idx) => (idx + 1) % filteredMentionCandidates.length);
        return;
      }
      if (e.key === "ArrowUp") {
        e.preventDefault();
        setSelectedCliAppIndex(
          (idx) => (idx - 1 + filteredMentionCandidates.length) % filteredMentionCandidates.length,
        );
        return;
      }
      if (e.key === "Tab" || (e.key === "Enter" && !e.shiftKey)) {
        e.preventDefault();
        chooseMentionCandidate(filteredMentionCandidates[selectedCliAppIndex]);
        return;
      }
      if (e.key === "Escape") {
        e.preventDefault();
        setCliAppMenuDismissed(true);
        return;
      }
    }
    if (showSlashMenu) {
      if (e.key === "ArrowDown") {
        e.preventDefault();
        setSelectedCommandIndex((idx) => (idx + 1) % filteredSlashCommands.length);
        return;
      }
      if (e.key === "ArrowUp") {
        e.preventDefault();
        setSelectedCommandIndex(
          (idx) => (idx - 1 + filteredSlashCommands.length) % filteredSlashCommands.length,
        );
        return;
      }
      if (e.key === "Tab" || (e.key === "Enter" && !e.shiftKey)) {
        e.preventDefault();
        chooseSlashCommand(filteredSlashCommands[selectedCommandIndex]);
        return;
      }
      if (e.key === "Escape") {
        e.preventDefault();
        setSlashMenuDismissed(true);
        return;
      }
    }
    // Touch keyboards: a plain Enter inserts a newline; sending stays on the
    // send button. The select-on-Enter menu branches above take precedence.
    if (
      e.key === "Enter"
      && !e.shiftKey
      && !e.altKey
      && !e.ctrlKey
      && !e.metaKey
      && !e.nativeEvent.isComposing
      && hasCoarsePointer
    ) {
      return;
    }
    if (e.key === "Enter" && !e.shiftKey && !e.nativeEvent.isComposing) {
      e.preventDefault();
      if (canQueueGuidance) {
        if (!e.repeat) queueGuidancePrompt();
        return;
      }
      // Empty Enter explicitly sends the visible pending message, including restored drafts.
      if (
        queuedPrompt
        && value.length === 0
        && images.length === 0
        && !e.altKey
        && !e.ctrlKey
        && !e.metaKey
      ) {
        if (!e.repeat && voiceRecorder.state === "idle" && !voiceShortcutDownRef.current) {
          sendQueuedPrompt(queuedPrompt);
        }
        return;
      }
      submit();
    }
  };

  const onFilePick: React.ChangeEventHandler<HTMLInputElement> = (e) => {
    const files = Array.from(e.target.files ?? []);
    e.target.value = "";
    addFiles(files);
  };

  const removeChip = useCallback(
    (id: string) => {
      const { nextFocusId } = remove(id);
      setInlineError(null);
      requestAnimationFrame(() => {
        const el = nextFocusId ? chipRefs.current.get(nextFocusId) : null;
        if (el) {
          el.focus();
        } else {
          textareaRef.current?.focus();
        }
      });
    },
    [remove],
  );

  const onChipKey = useCallback(
    (id: string) => (e: ReactKeyboardEvent<HTMLButtonElement>) => {
      if (
        e.key === "Delete" ||
        e.key === "Backspace" ||
        e.key === "Enter" ||
        e.key === " "
      ) {
        e.preventDefault();
        removeChip(id);
      }
    },
    [removeChip],
  );

  const attachButtonDisabled = interactionDisabled || full;
  const showVoiceButton = Boolean(onTranscribeAudio) && (
    voiceRecorder.state !== "idle"
    || (!hasComposerContent && images.length === 0 && !isStreaming && !modelNeedsSetup)
  );
  const voiceRecordingStatusLabel = t("thread.composer.voice.recordingStatus", {
    time: voiceRecorder.elapsedLabel,
    defaultValue: `Recording ${voiceRecorder.elapsedLabel}`,
  });
  const voiceButtonLabel =
    voiceRecorder.state === "recording"
      ? t("thread.composer.voice.stop")
      : voiceRecorder.state === "transcribing"
        ? t("thread.composer.voice.transcribing")
        : t("thread.composer.tools.voice");
  const voiceButtonTooltip =
    voiceRecorder.state === "recording"
      ? t("thread.composer.voice.stop")
      : voiceRecorder.state === "transcribing"
        ? t("thread.composer.voice.transcribing")
        : t("thread.composer.voice.hint");
  // Touch users need an explicit send action; keep Stop while sending is unavailable.
  const showStopButton = isStreaming && !!onStop && !canSend;
  const actionState: ComposerActionState = showVoiceButton
    ? voiceRecorder.state === "transcribing" ? "busy" : voiceRecorder.isRecording ? "recording" : "voice"
    : showStopButton ? "stop" : requiresModelSetup ? "setup" : canSend || !isStreaming ? "send" : "busy";
  const relaxedHeroInput = isHero && images.length === 0 && !isStreaming;
  const compactIdle = compactWhenIdle && !compactControls && !isHero && !composerFocused
    && value.length === 0 && images.length === 0 && !inlineError
    && !normalizedQuotedContext && !queuedPrompt && !goalState?.active
    && !isDragging && !sessionDragPreview && !voiceRecorder.isRecording && !showProjectPicker;
  useLayoutEffect(() => {
    if (!compactWhenIdle || compactControls) return;
    const form = formRef.current;
    const primary = form?.querySelector<HTMLElement>(".thread-composer-footer-primary");
    const actions = form?.querySelector<HTMLElement>(".thread-composer-footer-actions");
    if (!form || !primary || !actions) return;
    const controls = Array.from(primary.children).filter((child) => getComputedStyle(child).display !== "none");
    // Reserve the real toolbar width, including translated model labels, while
    // the footer slides beneath the input. Neither control is remounted.
    const measure = () => {
      const gap = parseFloat(getComputedStyle(primary).columnGap) || 0;
      const width = controls.reduce((sum, child) => sum + child.getBoundingClientRect().width, 0)
        + Math.max(0, controls.length - 1) * gap + actions.getBoundingClientRect().width;
      form.style.setProperty("--composer-compact-controls-width", `${width}px`);
    };
    measure();
    const observer = typeof ResizeObserver === "undefined" ? null : new ResizeObserver(measure);
    controls.forEach((control) => observer?.observe(control));
    observer?.observe(actions);
    return () => observer?.disconnect();
  }, [compactControls, compactWhenIdle, modelLabel, voiceRecorder.isRecording, workspaceScope]);
  const accessControl = workspaceScope && !workspaceControlsHidden ? (
    <WorkspaceAccessMenu
      scope={workspaceScope}
      disabled={interactionDisabled || workspaceScopeDisabled}
      onChange={onWorkspaceScopeChange}
      hintBoundaryRef={formRef}
    />
  ) : null;
  const workspaceControl = showProjectPicker ? (
    <WorkspaceProjectPicker
      layoutAnchor={workspacePickerLayoutAnchor}
      disabled={interactionDisabled || workspaceScopeDisabled}
      scope={workspaceScope}
      defaultScope={workspaceDefaultScope}
      controls={workspaceControls}
      error={workspaceError}
      onFavoriteProject={onFavoriteWorkspaceProject}
      onResolveProject={onResolveWorkspaceProject}
      onLoadProjects={onLoadWorkspaceProjects}
      onBrowseDirectories={onBrowseWorkspaceDirectories}
      onChange={onWorkspaceScopeChange}
    />
  ) : null;
  const modelControl = modelLabel && !voiceRecorder.isRecording ? (
    <ModelPresetBadge
      label={modelLabel}
      modelDetail={modelDetail}
      modelPreset={modelPreset}
      modelPresets={modelPresets}
      onPresetChange={onModelPresetChange}
      onManageModels={onManageModels}
      onRequestComposerFocus={() => textareaRef.current?.focus()}
      provider={modelProvider}
      providerLabel={modelProviderLabel}
      needsSetup={modelNeedsSetup}
      attentionRequest={modelSetupAttentionRequest}
      isHero={isHero && !compactControls}
      onClick={modelNeedsSetup ? onModelBadgeClick : undefined}
    />
  ) : null;
  const usageInMeta = mobileWorkspaceControls || compactControls;
  const usageControl = !voiceRecorder.isRecording
    ? renderContextUsage?.({ showLabel: usageInMeta, compactLabel: mobileWorkspaceControls }) : null;
  const inputTextClasses = cn(
    // Keep the overlay's CJK/Latin spacing aligned with the native textarea caret.
    "w-full resize-none bg-transparent text-composer [text-autospace:no-autospace]",
    compactControls
      ? "min-h-[52px] px-4 pb-2 pt-3"
      : isHero
        ? cn(
            "min-h-[78px] px-4 sm:px-5",
            relaxedHeroInput ? "pb-2 pt-[27px]" : "pb-1.5 pt-4",
          )
        : "min-h-[50px] px-3.5 pb-1.5 pt-3 sm:px-4",
  );
  const paletteBeside = showAnyPalette && slashPaletteLayout.placement === "beside";

  return (
    <form
      ref={formRef}
      data-compact-controls={compactControls ? "true" : undefined}
      data-palette-beside={paletteBeside || undefined}
      onFocusCapture={() => {
        if (!compactWhenIdle) return;
        // Portaled model controls belong to this composer too: keep its layout
        // stable while moving between the input, toolbar, and model picker.
        if (blurFrame.current !== null) cancelAnimationFrame(blurFrame.current);
      }}
      onBlurCapture={() => {
        if (!compactWhenIdle) return;
        if (blurFrame.current !== null) cancelAnimationFrame(blurFrame.current);
        blurFrame.current = requestAnimationFrame(() => {
          blurFrame.current = null;
          setComposerFocused(false);
        });
      }}
      onSubmit={(e) => {
        e.preventDefault();
        submit();
      }}
      onDragEnter={(event) => {
        if (!previewSessionDrop(event)) onDragEnter(event);
      }}
      onDragOver={(event) => {
        if (!previewSessionDrop(event)) onDragOver(event);
      }}
      onDragLeave={(event) => {
        if (!hasDraggedSession(event.dataTransfer)) {
          onDragLeave(event);
          return;
        }
        const nextTarget = event.relatedTarget;
        if (!(nextTarget instanceof Node) || !event.currentTarget.contains(nextTarget)) {
          setSessionDragPreview(null);
        }
      }}
      onDrop={(event) => {
        if (!handleSessionDrop(event)) onDrop(event);
      }}
      className={cn(
        "thread-composer-form relative w-full [--composer-action-margin:0px]",
        isHero
          ? "px-0 [--composer-action-size:2rem] [--composer-footer-inset:0.75rem] sm:[--composer-footer-inset:1rem]"
          : "px-1 pb-0 pt-1 [--composer-action-size:2.25rem] [--composer-footer-inset:0.625rem] sm:px-0 sm:pb-1.5 sm:[--composer-footer-inset:0.75rem]",
        compactWhenIdle && "thread-composer-collapsible-layout",
        paletteBeside && "grid grid-cols-2 items-start gap-2 p-0",
      )}
    >
      {showSlashMenu ? (
        <SlashCommandPalette
          commands={filteredSlashCommands}
          selectedIndex={selectedCommandIndex}
          layout={slashPaletteLayout}
          isHero={isHero}
          onHover={setSelectedCommandIndex}
          onChoose={chooseSlashCommand}
        />
      ) : null}
      {showCliAppMenu ? (
        <CliAppMentionPalette
          candidates={filteredMentionCandidates}
          selectedIndex={selectedCliAppIndex}
          layout={slashPaletteLayout}
          isHero={isHero}
          onHover={setSelectedCliAppIndex}
          onChoose={chooseMentionCandidate}
        />
      ) : null}
      <div
        ref={surfaceRef}
        data-compact={compactIdle || undefined}
        style={paletteBeside ? { maxHeight: slashPaletteLayout.maxHeight, overflowY: "auto" } : undefined}
        className={cn(
          "thread-composer-surface group/composer relative mx-auto flex w-full flex-col overflow-visible bg-card",
          paletteBeside && "col-start-1 row-start-1",
          isHero
            ? "max-w-[var(--composer-content-width,58rem)] rounded-prominent"
            : "max-w-[var(--composer-content-width,49.5rem)] rounded-panel",
          compactWhenIdle && "thread-composer-collapsible transition-colors motion-reduce:transition-none",
          interactionDisabled && "opacity-60",
          sessionDragPreview && "ring-1 ring-primary/25",
          isDragging && "ring-2 ring-primary/40 motion-reduce:ring-0 motion-reduce:border-primary",
          goalState?.active &&
            "ring-1 ring-sky-400/35 motion-reduce:ring-sky-400/25 dark:ring-sky-400/45",
        )}
      >
        {queuedPrompt ? (
          <QueuedPromptPreview
            prompt={queuedPrompt}
            disabled={interactionDisabled}
            editDisabled={encoding || hasErrors}
            label={t("thread.composer.queued.label")}
            guideLabel={t("thread.composer.queued.guide")}
            deleteLabel={t("thread.composer.queued.delete")}
            editLabel={t("thread.composer.queued.edit")}
            onGuide={() => sendQueuedPrompt(queuedPrompt)}
            onDelete={removeQueuedPrompt}
            onEdit={() => editQueuedPrompt(queuedPrompt)}
          />
        ) : null}
        {images.length > 0 ? (
          <div
            className="flex flex-wrap items-start gap-2 px-3 pt-3"
            aria-label={t("thread.composer.attachImage")}
          >
            {images.map((img) => (
              <AttachmentChip
                key={img.id}
                image={img}
                labelRemove={t("thread.composer.remove")}
                labelEncoding={t("thread.composer.encoding")}
                normalizedHint={(orig, current) =>
                  t("thread.composer.normalizedSizeHint", {
                    orig: formatBytes(orig),
                    current: formatBytes(current),
                  })
                }
                formatError={(reason) => reason === "too_large"
                  ? formatUploadTooLarge(img.file.size, img.kind === "video" ? MAX_VIDEO_BYTES : maxFileBytes)
                  : formatRejection(reason)}
                onRemove={() => removeChip(img.id)}
                onKeyDown={onChipKey(img.id)}
                registerRef={(el) => {
                  if (el) chipRefs.current.set(img.id, el);
                  else chipRefs.current.delete(img.id);
                }}
              />
            ))}
          </div>
        ) : null}
        {normalizedQuotedContext ? (
          <div
            className="mx-3 mt-3 flex min-w-0 items-start gap-2 border-l-2 border-muted-foreground/25 pl-3 pr-1 text-muted-foreground"
            aria-label={t("thread.composer.quotedContext")}
          >
            <Quote className="mt-0.5 h-3.5 w-3.5 shrink-0" aria-hidden />
            <p className="line-clamp-2 min-w-0 flex-1 text-reading-small">
              {normalizedQuotedContext}
            </p>
            <button
              type="button"
              className="touch-target -mr-1 inline-flex h-7 w-7 shrink-0 items-center justify-center rounded-full transition-colors hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
              aria-label={t("thread.composer.removeQuotedContext")}
              onClick={() => {
                onQuotedContextChange?.(null);
                requestAnimationFrame(() => textareaRef.current?.focus());
              }}
            >
              <X className="h-3.5 w-3.5" aria-hidden />
            </button>
          </div>
        ) : null}
        <GoalStateStrip goalState={goalState} />
        <div className="thread-composer-input relative min-w-0">
          {placeholder === undefined ? (
            <span className="pointer-events-none invisible absolute h-0 w-0 overflow-hidden">
              <span ref={placeholderMeasureRef} aria-hidden className="inline-block whitespace-pre text-composer [text-autospace:no-autospace]">{resolvedPlaceholder}</span>
            </span>
          ) : null}
          {hasInlineDecorations ? (
            <ComposerInlineReferenceOverlay
              overlayRef={mentionOverlayRef}
              segments={inlineSegments}
              slashCommand={slashCommand?.command ?? null}
              isHero={isHero}
              isComposing={mentionInput.isComposing}
              className={inputTextClasses}
              ghostRange={sessionDragInsertion
                ? { start: sessionDragInsertion.tokenStart, end: sessionDragInsertion.tokenEnd }
                : null}
            />
          ) : null}
          <textarea
            ref={textareaRef}
            value={mentionInput.value}
            onFocus={() => {
              if (compactWhenIdle) setComposerFocused(true);
            }}
            onChange={mentionInput.onChange}
            onCompositionStart={mentionInput.onCompositionStart}
            onCompositionEnd={mentionInput.onCompositionEnd}
            onKeyDown={onKeyDown}
            onKeyUp={() => setCursorPosition(rawSelection().start)}
            onSelect={() => setCursorPosition(rawSelection().start)}
            onClick={() => setCursorPosition(rawSelection().start)}
            onCopy={mentionInput.onCopy}
            onCut={mentionInput.onCut}
            onScroll={(e) => {
              if (mentionOverlayRef.current) mentionOverlayRef.current.scrollTop = e.currentTarget.scrollTop;
            }}
            onPaste={onPaste}
            rows={1}
            enterKeyHint={hasCoarsePointer ? "enter" : undefined}
            placeholder={sessionDragPreview ? "" : displayedPlaceholder}
            disabled={interactionDisabled}
            aria-label={inputAriaLabel ?? t("thread.composer.inputAria")}
            aria-description={sessionDragPreview ? undefined : resolvedPlaceholder}
            className={cn(
              inputTextClasses,
              "relative z-10 block caret-foreground placeholder:text-muted-foreground",
              "focus:outline-none focus-visible:outline-none",
              "disabled:cursor-not-allowed",
              hasInlineDecorations && "text-transparent selection:bg-primary/20",
            )}
          />
        </div>
        {inlineError ? (
          <div
            role="alert"
            className={cn(
              "mx-3 mb-1 max-h-24 overflow-hidden rounded-md border border-destructive/40 bg-destructive/8 px-2.5 py-1",
              "text-[11.5px] font-medium text-destructive transition-[max-height,margin,padding,opacity] [transition-duration:220ms] ease-out motion-reduce:transition-none",
              voiceErrorFading && "mb-0 max-h-0 border-transparent py-0 opacity-0",
            )}
          >
            {inlineError}
          </div>
        ) : null}
        <div
          className={cn(
            "thread-composer-footer flex flex-nowrap items-center px-[var(--composer-footer-inset)] motion-safe:transition-[padding-bottom] motion-safe:[transition-duration:220ms] motion-safe:ease-in-out",
            isHero
              ? cn(
                  "gap-x-1.5",
                  showProjectPicker && compactControls ? "pb-1.5" : "pb-3.5",
                )
              : "gap-x-2 pb-2",
          )}
        >
          <div
            className={cn(
              "thread-composer-footer-primary flex min-w-0 flex-1 basis-0 items-center",
              isHero ? "gap-1.5" : "gap-2",
            )}
          >
            <input
              ref={fileInputRef}
              type="file"
              accept={ACCEPT_ATTR}
              multiple
              hidden
              onChange={onFilePick}
            />
            <Button
              type="button"
              size="icon"
              variant="icon"
              disabled={attachButtonDisabled}
              aria-label={t("thread.composer.attachImage")}
              onClick={() => fileInputRef.current?.click()}
              className={cn(
                "thread-composer-action thread-composer-round-action touch-target shrink-0 rounded-xl text-muted-foreground hover:text-foreground",
                "h-[var(--composer-action-size)] w-[var(--composer-action-size)]",
              )}
            >
              <AttachIcon className="h-3.5 w-3.5" />
            </Button>
            {!mobileWorkspaceControls ? accessControl : null}
            {voiceRecorder.isRecording ? (
              <VoiceRecordingMeter
                ariaLabel={voiceRecordingStatusLabel}
                className="mx-1 flex-1"
                elapsedLabel={voiceRecorder.elapsedLabel}
                isHero={isHero}
                levels={voiceRecorder.levels}
              />
            ) : null}
          </div>
          <div
            className={cn(
              "thread-composer-footer-actions ml-auto flex min-w-0 items-center justify-end",
              isHero ? "gap-1.5" : "gap-2",
            )}
          >
            {modelControl}
            {!usageInMeta ? usageControl : null}
            <TooltipProvider>
              <Tooltip>
                <TooltipTrigger asChild>
                  <Button
                    type={showVoiceButton || showStopButton || requiresModelSetup ? "button" : "submit"}
                    size="icon"
                    disabled={showVoiceButton ? voiceRecorder.buttonDisabled : showStopButton ? interactionDisabled : !canSend && !canOpenModelSettings}
                    aria-label={
                      showVoiceButton
                        ? voiceButtonLabel
                        : showStopButton
                          ? t("thread.composer.stop")
                          : requiresModelSetup
                            ? t("thread.composer.configureModel", { defaultValue: "Configure model" })
                            : isUserShell ? t("thread.composer.shell.run") : t("thread.composer.send")
                    }
                    aria-keyshortcuts={showVoiceButton ? VOICE_SHORTCUT_ARIA : undefined}
                    onPointerDown={showVoiceButton ? voiceRecorder.beginPress : undefined}
                    onPointerUp={showVoiceButton ? voiceRecorder.endPress : undefined}
                    onPointerCancel={showVoiceButton ? voiceRecorder.endPress : undefined}
                    onClickCapture={event => {
                      if (!voiceRecorder.consumeSuppressedClick()) return;
                      event.preventDefault();
                      event.stopPropagation();
                    }}
                    onClick={showVoiceButton ? voiceRecorder.handleClick : showStopButton ? handleStop : requiresModelSetup ? onModelBadgeClick : undefined}
                    className={cn(
                      "composer-primary-action thread-composer-action thread-composer-round-action touch-target rounded-full bg-clip-padding",
                      actionState === "stop"
                        ? "border border-transparent bg-foreground/[0.045] text-foreground/85 hover:bg-foreground/[0.08] hover:text-foreground disabled:text-muted-foreground/50"
                        : actionState === "voice"
                          ? "border border-transparent bg-foreground/75 text-background hover:bg-foreground/[0.85] hover:text-background disabled:bg-foreground/[0.12] disabled:text-muted-foreground"
                          : "border border-transparent bg-foreground text-background hover:bg-foreground/90 hover:text-background disabled:border-foreground disabled:bg-foreground disabled:text-background",
                      actionState === "send" && "disabled:border-transparent disabled:bg-foreground/[0.12] disabled:text-muted-foreground",
                      showVoiceButton && voiceRecorder.isRecording && "border-transparent bg-red-500 text-white hover:bg-red-500 hover:text-white",
                      isHero ? "h-8 w-8" : "h-9 w-9",
                    )}
                  >
                    {isUserShell && actionState === "send"
                      ? <ToolRunIcon className="h-4 w-4" />
                      : <ComposerActionIcon state={actionState} />}
                  </Button>
                </TooltipTrigger>
                {showVoiceButton ? (
                  <TooltipContent
                    side="top"
                    align="center"
                    className="flex items-center gap-2 rounded-full border border-border/70 bg-popover px-3 py-1.5 text-[13px] font-medium text-popover-foreground shadow-[0_8px_24px_rgba(15,23,42,0.13)] dark:border-white/10"
                  >
                    <span>{voiceButtonTooltip}</span>
                    {voiceRecorder.state === "idle" ? (
                      <kbd className="rounded-full bg-muted px-2 py-0.5 font-sans text-[12px] font-semibold leading-none text-muted-foreground dark:bg-white/10">
                        {voiceShortcutLabel}
                      </kbd>
                    ) : null}
                  </TooltipContent>
                ) : isUserShell ? (
                  <TooltipContent>{t("thread.composer.shell.run")}</TooltipContent>
                ) : null}
              </Tooltip>
            </TooltipProvider>
          </div>
        </div>
      </div>
      {workspaceControl || mobileWorkspaceControls && accessControl || usageInMeta && usageControl ? (
        <div className={cn(
          "thread-composer-meta mx-auto mt-1 flex w-full min-w-0 items-center gap-x-2 pr-2 sm:pr-3",
          mobileWorkspaceControls ? "flex-nowrap gap-x-1 pr-0" : "flex-wrap gap-y-1",
          isHero ? "max-w-[58rem]" : "max-w-[49.5rem]",
          paletteBeside && "col-start-1 row-start-2",
        )}>
          <div className={cn("thread-composer-workspace-group flex min-w-0 items-center gap-1", mobileWorkspaceControls ? "flex-1" : "flex-auto max-[359px]:flex-wrap")}>
            {workspaceControl}
          </div>
          {usageInMeta && usageControl || mobileWorkspaceControls && accessControl ? (
            <div className={cn("ml-auto flex shrink-0 items-center gap-1", mobileWorkspaceControls && "h-11 max-w-[calc(100%-3rem)]")}>
              {usageInMeta ? usageControl : null}
              {mobileWorkspaceControls ? accessControl : null}
            </div>
          ) : null}
        </div>
      ) : null}
    </form>
  );
}

function QueuedPromptPreview({
  prompt,
  disabled,
  editDisabled,
  label,
  guideLabel,
  deleteLabel,
  editLabel,
  onGuide,
  onDelete,
  onEdit,
}: {
  prompt: QueuedPromptContent;
  disabled: boolean;
  editDisabled: boolean;
  label: string;
  guideLabel: string;
  deleteLabel: string;
  editLabel: string;
  onGuide: () => void;
  onDelete: () => void;
  onEdit: () => void;
}) {
  return (
    <div
      role="group"
      data-state="enter"
      className={cn(
        "composer-status-strip relative z-20 mx-3 mt-3 overflow-hidden rounded-floating",
        "border border-black/[0.05] bg-popover/90 p-1.5",
        "shadow-[0_10px_28px_rgba(15,23,42,0.07)] backdrop-blur-md",
        "dark:border-white/[0.08] dark:bg-popover/90 dark:shadow-[0_14px_34px_rgba(0,0,0,0.30)]",
      )}
      style={{ "--composer-strip-max-height": "224px" } as CSSProperties}
      aria-label={label}
    >
      <div className="flex min-w-0 items-center gap-1 px-1 pb-1">
        <span className="min-w-0 flex-1 truncate text-[11.5px] font-semibold text-foreground/75">{label}</span>
        <Button
          type="button"
          variant="ghost"
          size="sm"
          disabled={disabled}
          className="h-7 shrink-0 rounded-full px-2 text-[11.5px] font-medium text-muted-foreground hover:bg-muted/70 hover:text-foreground dark:hover:bg-white/[0.07]"
          onClick={onGuide}
        >
          <CornerDownRight className="mr-1 h-3 w-3" aria-hidden />
          {guideLabel}
        </Button>
        <Button
          type="button"
          variant="ghost"
          size="icon"
          disabled={disabled || editDisabled}
          aria-label={editLabel}
          title={editLabel}
          className="h-7 w-7 shrink-0 rounded-full text-muted-foreground hover:text-foreground"
          onClick={onEdit}
        >
          <EditIcon className="h-3.5 w-3.5" aria-hidden />
        </Button>
        <Button
          type="button"
          variant="ghost"
          size="icon"
          disabled={disabled}
          aria-label={deleteLabel}
          className="h-7 w-7 shrink-0 rounded-full text-muted-foreground hover:text-destructive"
          onClick={onDelete}
        >
          <Trash2 className="h-3 w-3" aria-hidden />
        </Button>
      </div>
      <div className="max-h-40 overflow-y-auto px-2 pb-1 text-[13px]">
        <p className="whitespace-pre-wrap break-words font-medium leading-relaxed text-foreground/88">
          {queuedPromptLabel(prompt)}
        </p>
        {prompt.text && prompt.images?.length ? (
          <p className="mt-1 break-words text-xs text-muted-foreground">
            {prompt.images.map((image) => image.name).filter(Boolean).join(", ")}
          </p>
        ) : null}
      </div>
    </div>
  );
}

function ComposerInlineReferenceOverlay({
  overlayRef,
  segments,
  slashCommand,
  isHero,
  isComposing,
  className,
  ghostRange,
}: {
  overlayRef: Ref<HTMLDivElement>;
  segments: InlineReferenceSegment[];
  slashCommand: string | null;
  isHero: boolean;
  isComposing: boolean;
  className: string;
  ghostRange?: { start: number; end: number } | null;
}) {
  let offset = 0;
  const occurrences = new Map<string, number>();
  return (
    <div
      ref={overlayRef}
      aria-hidden
      className={cn(
        className,
        "pointer-events-none absolute inset-0 z-0 overflow-hidden whitespace-pre-wrap break-words text-foreground",
        // Native IME selection backgrounds can be opaque; keep the mirrored glyphs visible.
        isComposing && "z-20",
      )}
    >
      {segments.map((segment, index) => {
        const start = offset;
        offset += segment.text.length;
        if (segment.kind === "text") {
          const bangPrefix = index === 0 ? /^(\s*)!/.exec(segment.text) : null;
          return <span key={`text-${index}`}>{bangPrefix ? <>
            {bangPrefix[1]}
            <InlineTokenHighlight testId="composer-shell-prefix" className="font-normal" color={INLINE_REFERENCE_HIGHLIGHT_COLOR}>
              <span className="opacity-90">!</span>
            </InlineTokenHighlight>
            {segment.text.slice(bangPrefix[0].length)}
          </> : start === 0 && slashCommand ? <>
            <SlashCommandText command={slashCommand} testId="composer-slash-command" />
            {segment.text.slice(slashCommand.length)}
          </> : segment.text}</span>;
        }
        if (segment.kind === "skill") {
          return <SkillReferenceToken
            key={`skill-${segment.name}-${index}`}
            name={segment.name}
            testId={`composer-skill-reference-${segment.name.toLowerCase()}`}
          />;
        }
        const isGhost = ghostRange?.start === start && ghostRange.end === offset;
        const identity = `${segment.kind}-${segment.kind === "cli"
          ? segment.app.name : segment.kind === "mcp" ? segment.preset.name : segment.mention.session_key}`;
        const occurrence = occurrences.get(identity) ?? 0;
        occurrences.set(identity, occurrence + 1);
        return (
          <span
            key={`${identity}-${occurrence}`}
            data-testid={isGhost ? "composer-session-drag-preview" : undefined}
            className={cn(isGhost && "opacity-45 transition-opacity duration-100")}
          >
            <CapabilityMentionToken
              segment={segment}
              variant="composer"
              isHero={isHero}
            />
          </span>
        );
      })}
      {segments.at(-1)?.text.endsWith("\n") ? "\u200b" : null}
    </div>
  );
}
interface SlashCommandPaletteProps {
  commands: SlashPaletteCommand[];
  selectedIndex: number;
  layout: SlashPaletteLayout;
  isHero: boolean;
  onHover: (index: number) => void;
  onChoose: (command: SlashPaletteCommand) => void;
}

interface CliAppMentionPaletteProps {
  candidates: MentionCandidate[];
  selectedIndex: number;
  layout: SlashPaletteLayout;
  isHero: boolean;
  onHover: (index: number) => void;
  onChoose: (candidate: MentionCandidate) => void;
}

function useSelectedOptionScroll(selectedIndex: number) {
  const containerRef = useRef<HTMLDivElement | null>(null);

  useLayoutEffect(() => {
    const container = containerRef.current;
    if (!container) return;
    const option = container.querySelector<HTMLElement>(
      `[data-palette-index="${selectedIndex}"]`,
    );
    if (typeof option?.scrollIntoView === "function") {
      option.scrollIntoView({ block: "nearest" });
    }
  }, [selectedIndex]);

  return containerRef;
}

function CliAppMentionPalette({
  candidates,
  selectedIndex,
  layout,
  isHero,
  onHover,
  onChoose,
}: CliAppMentionPaletteProps) {
  const { t } = useTranslation();
  const listMaxHeight = Math.max(
    0,
    layout.maxHeight - SLASH_PALETTE_CHROME_PX,
  );
  const listRef = useSelectedOptionScroll(selectedIndex);
  const groupedCandidates = (["session", "cli", "mcp"] as const)
    .map((kind) => ({
      kind,
      label: kind === "session"
        ? t("thread.composer.mentions.sessionGroup")
        : kind === "cli"
          ? t("thread.composer.mentions.cliGroup")
          : t("thread.composer.mentions.mcpGroup"),
      items: candidates
        .map((candidate, index) => ({ candidate, index }))
        .filter(({ candidate }) => candidate.kind === kind),
    }))
    .filter((group) => group.items.length > 0);
  return (
    <div
      role="listbox"
      aria-label={t("thread.composer.mentions.ariaLabel")}
      style={{ maxHeight: layout.maxHeight }}
      className={cn(
        floatingSurfaceVisualClassName,
        "z-30 overflow-hidden",
        layout.placement === "beside"
          ? "relative col-start-2 row-start-1 w-full"
          : cn("absolute left-1/2 w-[calc(100%-0.5rem)] -translate-x-1/2",
            layout.placement === "above" ? "bottom-full mb-2" : "top-full mt-2"),
        isHero ? "max-w-[58rem]" : "max-w-[49.5rem]",
      )}
    >
      <div ref={listRef} className="overflow-y-auto" style={{ maxHeight: listMaxHeight }}>
        {groupedCandidates.map((group) => (
          <div key={group.kind} role="group" aria-label={group.label} className="mt-1.5 first:mt-0">
            <div className="px-2 pb-1 pt-1 text-[12px] font-medium text-muted-foreground/72">
              {group.label}
            </div>
            {group.items.map(({ candidate, index }) => {
              const selected = index === selectedIndex;
              const name = candidate.name;
              const handleColor = candidate.kind === "session"
                ? candidate.mention.id ? sessionHandleColor(candidate.mention.id) : INLINE_TOKEN_HIGHLIGHT_COLOR
                : undefined;
              const typeLabel = candidate.kind === "cli"
                ? t("thread.composer.mentions.cliBadge")
                : candidate.kind === "mcp"
                  ? t("thread.composer.mentions.mcpBadge")
                  : t("thread.composer.mentions.sessionBadge");
              const ariaDescription = candidate.kind === "cli"
                ? t("thread.composer.mentions.cliDescription", { name })
                : candidate.kind === "mcp"
                  ? t("thread.composer.mentions.mcpDescription", { name })
                  : t("thread.composer.mentions.sessionDescription", { name });
              return (
                <button
                  key={`${candidate.kind}-${name}`}
                  type="button"
                  role="option"
                  data-palette-index={index}
                  aria-selected={selected}
                  aria-label={`@${name} ${candidate.displayName} ${ariaDescription} ${typeLabel}`}
                  onMouseEnter={() => onHover(index)}
                  onMouseDown={(e) => {
                    e.preventDefault();
                    onChoose(candidate);
                  }}
                  className={cn(
                    floatingItemClassName,
                    floatingItemFocusClassName,
                    "touch-target flex min-h-10 w-full flex-wrap items-center gap-x-2.5 gap-y-1 px-2.5 py-1.5 text-left transition-colors",
                    selected
                      ? "bg-foreground/[0.055] text-foreground dark:bg-black/[0.12]"
                      : "text-foreground/90 hover:bg-foreground/[0.04]",
                  )}
                >
                  <span
                    className="max-w-full shrink-0 truncate text-[15px] font-normal tracking-normal text-muted-foreground/72"
                    style={{ color: handleColor }}
                  >
                    @{name}
                  </span>
                  <span className={cn(
                    "flex max-w-full flex-1 flex-wrap items-center gap-x-2.5 gap-y-1",
                    candidate.kind === "session" ? "min-w-[min(4rem,100%)]" : "min-w-[min(8rem,100%)]",
                  )}>
                    {candidate.kind !== "session" ? <MentionCandidateLogo candidate={candidate} selected={selected} /> : null}
                    <span className="min-w-[min(4rem,100%)] flex-1 truncate text-[15px] font-medium tracking-normal text-foreground">
                      {candidate.displayName}
                    </span>
                    {candidate.kind !== "session" ? (
                      <span
                        className={cn(
                          "ml-2 shrink-0 rounded-full px-2 py-0.5 text-[11px] font-semibold tracking-normal",
                          candidate.kind === "cli"
                            ? "bg-orange-500/10 text-orange-600 dark:text-orange-300"
                            : "bg-sky-500/10 text-sky-600 dark:text-sky-300",
                        )}
                      >
                        {typeLabel}
                      </span>
                    ) : null}
                  </span>
                </button>
              );
            })}
          </div>
        ))}
      </div>
    </div>
  );
}

function MentionCandidateLogo({
  candidate,
  selected,
}: {
  candidate: Extract<MentionCandidate, { kind: "cli" | "mcp" }>;
  selected: boolean;
}) {
  const color = candidate.brandColor || INLINE_TOKEN_HIGHLIGHT_COLOR;
  const logoUrls = useMemo(() => logoFallbackUrls(candidate.logoUrl), [candidate.logoUrl]);
  const { logoUrl, onLogoError, onLogoLoad } = useLogoFallback(logoUrls);

  if (logoUrl) {
    return (
      <span
        className={cn(
          "flex h-5 w-5 shrink-0 items-center justify-center overflow-hidden rounded-compact",
          selected ? "bg-background/55" : "bg-transparent",
        )}
      >
        <img
          src={logoUrl}
          alt=""
          decoding="async"
          loading="lazy"
          className="h-5 w-5 object-contain"
          onLoad={onLogoLoad}
          onError={onLogoError}
        />
      </span>
    );
  }
  return (
    <span
      className="flex h-5 w-5 shrink-0 items-center justify-center rounded-compact text-[7.5px] font-semibold text-white"
      style={{ backgroundColor: color }}
    >
      {candidate.initials}
    </span>
  );
}

function SlashCommandPalette({
  commands,
  selectedIndex,
  layout,
  isHero,
  onHover,
  onChoose,
}: SlashCommandPaletteProps) {
  const { t } = useTranslation();
  const listMaxHeight = Math.max(
    0,
    layout.maxHeight - SLASH_PALETTE_CHROME_PX,
  );
  const listRef = useSelectedOptionScroll(selectedIndex);
  return (
    <div
      role="listbox"
      aria-label={t("thread.composer.slash.ariaLabel")}
      style={{ maxHeight: layout.maxHeight }}
      className={cn(
        floatingSurfaceVisualClassName,
        "z-30 overflow-hidden",
        layout.placement === "beside"
          ? "relative col-start-2 row-start-1 w-full"
          : cn("absolute left-1/2 w-[calc(100%-0.5rem)] -translate-x-1/2",
            layout.placement === "above" ? "bottom-full mb-2" : "top-full mt-2"),
        isHero ? "max-w-[58rem]" : "max-w-[49.5rem]",
      )}
    >
      <div ref={listRef} className="overflow-y-auto pr-0.5" style={{ maxHeight: listMaxHeight }}>
        {commands.map((command, index) => {
          const Icon = command.kind === "skill" ? SkillsIcon : BUILTIN_COMMAND_ICONS[command.command] ?? COMMAND_ICONS[command.icon] ?? HelpIcon;
          const selected = index === selectedIndex;
          const isSkill = command.kind === "skill";
          const commandKey = slashCommandI18nKey(command.command);
          const title = t(`thread.composer.slash.commands.${commandKey}.title`, {
            defaultValue: command.title,
          });
          const description = t(`thread.composer.slash.commands.${commandKey}.description`, {
            defaultValue: command.description,
          });
          return (
            <button
              key={command.command}
              type="button"
              role="option"
              data-palette-index={index}
              aria-selected={selected}
              onMouseEnter={() => onHover(index)}
              onMouseDown={(e) => {
                e.preventDefault();
                onChoose(command);
              }}
              className={cn(
                floatingItemClassName,
                floatingItemFocusClassName,
                "flex min-h-[44px] w-full items-center gap-3 px-3 py-2 text-left transition-colors",
                selected
                  ? "bg-foreground/[0.065] text-foreground dark:bg-white/[0.09]"
                  : "text-foreground/86 hover:bg-foreground/[0.045] dark:hover:bg-white/[0.065]",
              )}
            >
              <span
                className={cn(
                  "flex h-7 w-7 shrink-0 items-center justify-center text-muted-foreground transition-colors",
                  selected && "text-foreground",
                )}
              >
                <Icon className="h-4 w-4" />
              </span>
              <span className="flex min-w-0 flex-1 flex-col gap-0.5 sm:flex-row sm:items-baseline sm:gap-2">
                <span
                  className={cn(
                    "text-[13.5px] font-semibold tracking-normal text-foreground",
                    isSkill
                      ? "max-w-full shrink-0 break-all sm:max-w-[55%]"
                      : "min-w-0 truncate",
                  )}
                >
                  {title}
                </span>
                <span className="min-w-0 truncate text-[13px] text-muted-foreground">
                  {command.detail || description}
                </span>
              </span>
              {!isSkill || command.badge || command.recent ? (
                <span className="ml-2 flex max-w-[42%] shrink-0 items-center gap-1.5 sm:max-w-none">
                  {command.badge || command.recent ? (
                    <span className="hidden rounded-full bg-foreground/[0.055] px-2 py-1 text-[11px] font-medium text-muted-foreground sm:inline-flex">
                      {command.badge ?? t("thread.composer.slash.badges.recent")}
                    </span>
                  ) : null}
                  {!isSkill ? (
                    <span className="font-mono text-[12px] text-muted-foreground/60">
                      {command.argHint ? `${command.command} ${command.argHint}` : command.command}
                    </span>
                  ) : null}
                </span>
              ) : null}
            </button>
          );
        })}
      </div>
    </div>
  );
}

interface AttachmentChipProps {
  image: AttachedImage;
  labelRemove: string;
  labelEncoding: string;
  normalizedHint: (origBytes: number, currentBytes: number) => string;
  formatError: (reason: AttachmentError) => string;
  onRemove: () => void;
  onKeyDown: (e: ReactKeyboardEvent<HTMLButtonElement>) => void;
  registerRef: (el: HTMLButtonElement | null) => void;
}

function AttachmentChip({
  image,
  labelRemove,
  labelEncoding,
  normalizedHint,
  formatError,
  onRemove,
  onKeyDown,
  registerRef,
}: AttachmentChipProps) {
  const sizeLabel =
    image.status === "ready" && image.normalized && image.encodedBytes
      ? normalizedHint(image.file.size, image.encodedBytes)
      : formatBytes(image.file.size);
  const isThumbnail = image.kind === "image" && image.status !== "error";
  const error = image.status === "error" && image.error ? formatError(image.error) : null;

  return (
    <div className="flex w-24 max-w-full shrink-0 flex-col gap-1" data-testid="composer-chip">
      <AttachmentCard name={image.file.name} description={sizeLabel} invalid={!!error}
        action={<button type="button" ref={registerRef} onClick={onRemove} onKeyDown={onKeyDown}
          aria-label={labelRemove} aria-description={image.file.name} title={labelRemove}
          className={cn(attachmentCardActionClassName, "group/remove focus-visible:bg-black/50 focus-visible:ring-white")}>
          <span className="grid h-5 w-5 place-items-center rounded-full bg-black/65 text-white group-hover/remove:bg-black/80">
            <X className="h-3 w-3" aria-hidden />
          </span>
        </button>}>
        {isThumbnail && image.previewUrl ? <img src={image.previewUrl} alt={image.file.name} loading="eager" draggable={false}
          className="h-full w-full object-cover" /> : <AttachmentTypeFace name={image.file.name} kind={image.kind} />}
        {image.status === "encoding" ? <span className="absolute inset-0 flex items-center justify-center bg-background/60" aria-label={labelEncoding}>
          <Loader2 className="h-4 w-4 animate-spin motion-reduce:animate-none" aria-hidden />
        </span> : null}
      </AttachmentCard>
      {error ? <span className="break-words text-center text-[11px] leading-4 text-destructive">{error}</span> : null}
    </div>
  );
}