diff --git a/src/components/chat/chat-header/ChatHeader.spec.tsx b/src/components/chat/chat-header/ChatHeader.spec.tsx
new file mode 100644
index 00000000..bb3d8e5f
--- /dev/null
+++ b/src/components/chat/chat-header/ChatHeader.spec.tsx
@@ -0,0 +1,374 @@
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import ChatHeader from './ChatHeader';
+import { pipelinesService } from '@/services/pipelines/pipelinesService';
+import chatService from '@/services/chat/chatService';
+import { toast } from 'sonner';
+
+vi.mock('@/services/pipelines/pipelinesService', () => ({
+  pipelinesService: {
+    getPipelines: vi.fn(),
+    getPipelinesByConversation: vi.fn(),
+    addItemToPipeline: vi.fn(),
+    moveItem: vi.fn(),
+    removeItemFromPipeline: vi.fn(),
+  },
+}));
+
+vi.mock('@/services/chat/chatService', () => ({
+  default: {
+    getConversation: vi.fn(),
+  },
+}));
+
+const mockUpdateConversation = vi.fn();
+vi.mock('@/contexts/chat/ChatContext', () => ({
+  useChatContext: () => ({
+    conversations: { updateConversation: mockUpdateConversation },
+  }),
+}));
+
+vi.mock('sonner', () => ({
+  toast: { success: vi.fn(), error: vi.fn() },
+}));
+
+vi.mock('@/hooks/useLanguage', () => ({
+  useLanguage: () => ({ t: (key: string) => key }),
+}));
+
+vi.mock('@/utils/chat/conversationStatus', () => ({
+  getStatusLabel: (s: string) => s,
+  isPendingStatus: () => false,
+}));
+
+vi.mock('@/utils/channelUtils', () => ({
+  isPhoneBearingChannel: () => false,
+}));
+
+vi.mock('@/utils/contact/formatContactPhone', () => ({
+  formatContactPhone: (p: string) => p,
+}));
+
+vi.mock('@/components/chat/contact/ContactAvatar', () => ({
+  default: () => <div data-testid="contact-avatar" />,
+}));
+
+const makePipeline = (
+  id: string,
+  stages: { id: string; name: string }[],
+  items: { id: string; item_id: string; stage_id: string }[] = [],
+) => ({
+  id,
+  name: `Pipeline ${id}`,
+  pipeline_type: 'custom' as const,
+  visibility: 'public' as const,
+  is_active: true,
+  stages: stages.map(s => ({ ...s, color: '#000', position: 0, created_at: '', updated_at: '' })),
+  items,
+  created_at: '',
+  updated_at: '',
+});
+
+const makeConversation = (id = '42') =>
+  ({
+    id,
+    status: 'open' as const,
+    inbox: { id: '1', name: 'WhatsApp', channel_type: 'Channel::Whatsapp' },
+    contact: { id: '1', name: 'Test Contact' },
+    custom_attributes: {},
+  }) as never;
+
+const defaultProps = {
+  conversation: makeConversation(),
+  onBackClick: vi.fn(),
+  onCloseConversation: vi.fn(),
+  onContactSidebarOpen: vi.fn(),
+  onMarkAsRead: vi.fn(),
+  onMarkAsUnread: vi.fn(),
+  onMarkAsOpen: vi.fn(),
+  onMarkAsResolved: vi.fn(),
+  onPostpone: vi.fn(),
+  onMarkAsSnoozed: vi.fn(),
+  onSetPriority: vi.fn(),
+  onPinConversation: vi.fn(),
+  onUnpinConversation: vi.fn(),
+  onArchiveConversation: vi.fn(),
+  onUnarchiveConversation: vi.fn(),
+  onAssignAgent: vi.fn(),
+  onAssignTeam: vi.fn(),
+  onAssignTag: vi.fn(),
+  onDeleteConversation: vi.fn(),
+  unreadCount: 0,
+};
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.mocked(chatService.getConversation).mockResolvedValue({ data: makeConversation() } as never);
+});
+
+const openPipelineAndSelectStage = async (
+  user: ReturnType<typeof userEvent.setup>,
+  pipelineName: string,
+  stageName: string,
+) => {
+  // Open main dropdown
+  const menuTrigger = document.querySelector<HTMLElement>('[data-slot="dropdown-menu-trigger"]')!;
+  await user.click(menuTrigger);
+
+  // Find and focus the pipeline.addTo sub-trigger, then open it with ArrowRight
+  const addToTrigger = await screen.findByText('pipeline.addTo');
+  const addToSubTrigger = (addToTrigger.closest('[data-slot="dropdown-menu-sub-trigger"]') ?? addToTrigger) as HTMLElement;
+  addToSubTrigger.focus();
+  await user.keyboard('{ArrowRight}');
+
+  // Find and focus the specific pipeline sub-trigger, then open with ArrowRight
+  await waitFor(() => screen.getByText(pipelineName), { timeout: 2000 });
+  const pipelineEl = screen.getByText(pipelineName);
+  const pipelineSubTrigger = (pipelineEl.closest('[data-slot="dropdown-menu-sub-trigger"]') ?? pipelineEl) as HTMLElement;
+  pipelineSubTrigger.focus();
+  await user.keyboard('{ArrowRight}');
+
+  // Find and click the stage
+  await waitFor(() => screen.getByText(stageName), { timeout: 2000 });
+  await user.click(screen.getByText(stageName));
+};
+
+describe('ChatHeader pipeline', () => {
+  it('loads pipelines on mount and calls getPipelinesByConversation when menu opens', async () => {
+    const pipeline = makePipeline('p1', [{ id: 'stage-1', name: 'Lead' }]);
+    vi.mocked(pipelinesService.getPipelines).mockResolvedValue({ data: [pipeline] } as never);
+    vi.mocked(pipelinesService.getPipelinesByConversation).mockResolvedValue([]);
+
+    render(<ChatHeader {...defaultProps} />);
+
+    await waitFor(() => expect(pipelinesService.getPipelines).toHaveBeenCalledWith({ is_active: true }));
+
+    const user = userEvent.setup();
+    const menuTrigger = document.querySelector<HTMLElement>('[data-slot="dropdown-menu-trigger"]')!;
+    await user.click(menuTrigger);
+
+    await waitFor(() =>
+      expect(pipelinesService.getPipelinesByConversation).toHaveBeenCalledWith('42'),
+    );
+  });
+
+  it('adds conversation to pipeline using conversation.id not item.id (H1)', async () => {
+    const pipeline = makePipeline('p1', [{ id: 'stage-1', name: 'Lead' }]);
+    vi.mocked(pipelinesService.getPipelines).mockResolvedValue({ data: [pipeline] } as never);
+    vi.mocked(pipelinesService.getPipelinesByConversation).mockResolvedValue([]);
+    vi.mocked(pipelinesService.addItemToPipeline).mockResolvedValue({} as never);
+
+    render(<ChatHeader {...defaultProps} />);
+    await waitFor(() => expect(pipelinesService.getPipelines).toHaveBeenCalled());
+
+    const user = userEvent.setup();
+    await openPipelineAndSelectStage(user, 'Pipeline p1', 'Lead');
+
+    await waitFor(() => {
+      expect(pipelinesService.addItemToPipeline).toHaveBeenCalledWith('p1', {
+        item_id: '42',
+        type: 'conversation',
+        pipeline_stage_id: 'stage-1',
+      });
+    });
+  });
+
+  it('calls moveItem with item.id when moving within same pipeline (M1)', async () => {
+    const existingItem = {
+      id: 'item-99',
+      item_id: '42',
+      stage_id: 'stage-1',
+      pipeline_id: 'p1',
+      type: 'conversation',
+      is_lead: false,
+      created_at: '',
+      updated_at: '',
+    };
+    const pipeline = makePipeline(
+      'p1',
+      [
+        { id: 'stage-1', name: 'Lead' },
+        { id: 'stage-2', name: 'Qualified' },
+      ],
+      [existingItem],
+    );
+
+    vi.mocked(pipelinesService.getPipelines).mockResolvedValue({ data: [pipeline] } as never);
+    vi.mocked(pipelinesService.getPipelinesByConversation).mockResolvedValue([pipeline]);
+    vi.mocked(pipelinesService.moveItem).mockResolvedValue({ success: true, message: '' });
+
+    render(<ChatHeader {...defaultProps} />);
+    await waitFor(() => expect(pipelinesService.getPipelines).toHaveBeenCalled());
+
+    const user = userEvent.setup();
+    await openPipelineAndSelectStage(user, 'Pipeline p1', 'Qualified');
+
+    await waitFor(() => {
+      expect(pipelinesService.moveItem).toHaveBeenCalledWith({
+        pipeline_id: 'p1',
+        item_id: 'item-99',
+        from_stage_id: 'stage-1',
+        to_stage_id: 'stage-2',
+      });
+      expect(pipelinesService.addItemToPipeline).not.toHaveBeenCalled();
+    });
+  });
+
+  it('removes from old pipeline before adding to new pipeline (C1)', async () => {
+    const existingItem = {
+      id: 'item-old',
+      item_id: '42',
+      stage_id: 'stage-A',
+      pipeline_id: 'p-old',
+      type: 'conversation',
+      is_lead: false,
+      created_at: '',
+      updated_at: '',
+    };
+    const oldPipeline = makePipeline('p-old', [{ id: 'stage-A', name: 'StageOld' }], [existingItem]);
+    const newPipeline = makePipeline('p-new', [{ id: 'stage-B', name: 'StageNew' }]);
+
+    vi.mocked(pipelinesService.getPipelines).mockResolvedValue({ data: [oldPipeline, newPipeline] } as never);
+    vi.mocked(pipelinesService.getPipelinesByConversation).mockResolvedValue([oldPipeline]);
+    vi.mocked(pipelinesService.removeItemFromPipeline).mockResolvedValue({ success: true, message: '' });
+    vi.mocked(pipelinesService.addItemToPipeline).mockResolvedValue({} as never);
+
+    render(<ChatHeader {...defaultProps} />);
+    await waitFor(() => expect(pipelinesService.getPipelines).toHaveBeenCalled());
+
+    const user = userEvent.setup();
+    await openPipelineAndSelectStage(user, 'Pipeline p-new', 'StageNew');
+
+    await waitFor(() => {
+      expect(pipelinesService.removeItemFromPipeline).toHaveBeenCalledWith('p-old', 'item-old');
+      expect(pipelinesService.addItemToPipeline).toHaveBeenCalledWith('p-new', {
+        item_id: '42',
+        type: 'conversation',
+        pipeline_stage_id: 'stage-B',
+      });
+    });
+  });
+
+  it('dispatches updateConversation after pipeline action to refresh badge (C1)', async () => {
+    const pipeline = makePipeline('p1', [{ id: 'stage-1', name: 'Lead' }]);
+    vi.mocked(pipelinesService.getPipelines).mockResolvedValue({ data: [pipeline] } as never);
+    vi.mocked(pipelinesService.getPipelinesByConversation).mockResolvedValue([]);
+    vi.mocked(pipelinesService.addItemToPipeline).mockResolvedValue({} as never);
+    const updatedConv = makeConversation('42');
+    vi.mocked(chatService.getConversation).mockResolvedValue({ data: updatedConv } as never);
+
+    render(<ChatHeader {...defaultProps} />);
+    await waitFor(() => expect(pipelinesService.getPipelines).toHaveBeenCalled());
+
+    const user = userEvent.setup();
+    await openPipelineAndSelectStage(user, 'Pipeline p1', 'Lead');
+
+    await waitFor(() => {
+      expect(mockUpdateConversation).toHaveBeenCalledWith(updatedConv);
+    });
+  });
+
+  it('removes ALL pipelines when conversation is in 2+ pipelines before adding to new one (H1)', async () => {
+    const makeItem = (id: string, pipelineId: string) => ({
+      id,
+      item_id: '42',
+      stage_id: `stage-${pipelineId}`,
+      pipeline_id: pipelineId,
+      type: 'conversation',
+      is_lead: false,
+      created_at: '',
+      updated_at: '',
+    });
+    const pOld1 = makePipeline('p-old1', [{ id: 'stage-p-old1', name: 'StageA' }], [makeItem('item-1', 'p-old1')]);
+    const pOld2 = makePipeline('p-old2', [{ id: 'stage-p-old2', name: 'StageB' }], [makeItem('item-2', 'p-old2')]);
+    const pNew  = makePipeline('p-new',  [{ id: 'stage-new',    name: 'StageC' }]);
+
+    vi.mocked(pipelinesService.getPipelines).mockResolvedValue({ data: [pOld1, pOld2, pNew] } as never);
+    vi.mocked(pipelinesService.getPipelinesByConversation).mockResolvedValue([pOld1, pOld2]);
+    vi.mocked(pipelinesService.removeItemFromPipeline).mockResolvedValue({ success: true, message: '' });
+    vi.mocked(pipelinesService.addItemToPipeline).mockResolvedValue({} as never);
+
+    render(<ChatHeader {...defaultProps} />);
+    await waitFor(() => expect(pipelinesService.getPipelines).toHaveBeenCalled());
+
+    const user = userEvent.setup();
+    await openPipelineAndSelectStage(user, 'Pipeline p-new', 'StageC');
+
+    await waitFor(() => {
+      expect(pipelinesService.removeItemFromPipeline).toHaveBeenCalledWith('p-old1', 'item-1');
+      expect(pipelinesService.removeItemFromPipeline).toHaveBeenCalledWith('p-old2', 'item-2');
+      expect(pipelinesService.removeItemFromPipeline).toHaveBeenCalledTimes(2);
+      expect(pipelinesService.addItemToPipeline).toHaveBeenCalledWith('p-new', {
+        item_id: '42',
+        type: 'conversation',
+        pipeline_stage_id: 'stage-new',
+      });
+    });
+  });
+
+  it('shows loading label in stage submenu while getPipelinesByConversation is pending (isLoadingConvPipelines guard)', async () => {
+    const pipeline = makePipeline('p1', [{ id: 'stage-1', name: 'Lead' }]);
+    vi.mocked(pipelinesService.getPipelines).mockResolvedValue({ data: [pipeline] } as never);
+    vi.mocked(pipelinesService.getPipelinesByConversation).mockReturnValue(new Promise(() => {}));
+
+    render(<ChatHeader {...defaultProps} />);
+    await waitFor(() => expect(pipelinesService.getPipelines).toHaveBeenCalled());
+
+    const user = userEvent.setup();
+    const menuTrigger = document.querySelector<HTMLElement>('[data-slot="dropdown-menu-trigger"]')!;
+    await user.click(menuTrigger);
+
+    const addToTrigger = await screen.findByText('pipeline.addTo');
+    const addToSubTrigger = (addToTrigger.closest('[data-slot="dropdown-menu-sub-trigger"]') ?? addToTrigger) as HTMLElement;
+    addToSubTrigger.focus();
+    await user.keyboard('{ArrowRight}');
+
+    await waitFor(() => screen.getByText('Pipeline p1'), { timeout: 2000 });
+    const pipelineEl = screen.getByText('Pipeline p1');
+    const pipelineSubTrigger = (pipelineEl.closest('[data-slot="dropdown-menu-sub-trigger"]') ?? pipelineEl) as HTMLElement;
+    pipelineSubTrigger.focus();
+    await user.keyboard('{ArrowRight}');
+
+    await waitFor(() => {
+      expect(screen.getByText('pipeline.loading')).toBeInTheDocument();
+      expect(screen.queryByText('Lead')).not.toBeInTheDocument();
+    });
+  });
+
+  it('shows pipeline.moveError toast when move fails (M2 - distinct from addError)', async () => {
+    const existingItem = {
+      id: 'item-99',
+      item_id: '42',
+      stage_id: 'stage-1',
+      pipeline_id: 'p1',
+      type: 'conversation',
+      is_lead: false,
+      created_at: '',
+      updated_at: '',
+    };
+    const pipeline = makePipeline(
+      'p1',
+      [
+        { id: 'stage-1', name: 'Lead' },
+        { id: 'stage-2', name: 'Qualified' },
+      ],
+      [existingItem],
+    );
+
+    vi.mocked(pipelinesService.getPipelines).mockResolvedValue({ data: [pipeline] } as never);
+    vi.mocked(pipelinesService.getPipelinesByConversation).mockResolvedValue([pipeline]);
+    vi.mocked(pipelinesService.moveItem).mockRejectedValue(new Error('Server error'));
+
+    render(<ChatHeader {...defaultProps} />);
+    await waitFor(() => expect(pipelinesService.getPipelines).toHaveBeenCalled());
+
+    const user = userEvent.setup();
+    await openPipelineAndSelectStage(user, 'Pipeline p1', 'Qualified');
+
+    await waitFor(() => {
+      expect(toast.error).toHaveBeenCalledWith('pipeline.moveError');
+      expect(toast.error).not.toHaveBeenCalledWith('pipeline.addError');
+    });
+  });
+});
diff --git a/src/components/chat/chat-header/ChatHeader.tsx b/src/components/chat/chat-header/ChatHeader.tsx
index 9a9914b7..9f1a53e5 100644
--- a/src/components/chat/chat-header/ChatHeader.tsx
+++ b/src/components/chat/chat-header/ChatHeader.tsx
@@ -1,3 +1,4 @@
+import { useState, useEffect, useCallback, useRef } from 'react';
 import { Button } from '@evoapi/design-system/button';
 import {
   ArrowLeft,
@@ -20,6 +21,8 @@ import {
   Unlock,
   Pin,
   Archive,
+  GitBranch,
+  Check,
 } from 'lucide-react';
 import {
   DropdownMenu,
@@ -27,13 +30,22 @@ import {
   DropdownMenuItem,
   DropdownMenuSeparator,
   DropdownMenuTrigger,
+  DropdownMenuSub,
+  DropdownMenuSubContent,
+  DropdownMenuSubTrigger,
+  DropdownMenuLabel,
 } from '@evoapi/design-system/dropdown-menu';
 import { Conversation } from '@/types/chat/api';
+import type { Pipeline, PipelineStage } from '@/types/analytics';
 import ContactAvatar from '@/components/chat/contact/ContactAvatar';
 import { getStatusLabel, isPendingStatus } from '@/utils/chat/conversationStatus';
 import { isPhoneBearingChannel } from '@/utils/channelUtils';
 import { formatContactPhone } from '@/utils/contact/formatContactPhone';
 import { useLanguage } from '@/hooks/useLanguage';
+import { useChatContext } from '@/contexts/chat/ChatContext';
+import { pipelinesService } from '@/services/pipelines/pipelinesService';
+import chatService from '@/services/chat/chatService';
+import { toast } from 'sonner';
 
 interface ChatHeaderProps {
   conversation: Conversation;
@@ -61,6 +73,10 @@ interface ChatHeaderProps {
   unreadCount: number;
 }
 
+interface ConvPipelineData {
+  pipelines: Pipeline[];
+}
+
 const ChatHeader = ({
   conversation,
   onBackClick,
@@ -84,6 +100,7 @@ const ChatHeader = ({
   unreadCount,
 }: ChatHeaderProps) => {
   const { t } = useLanguage('chat');
+  const chatContext = useChatContext();
   const currentStatus = conversation.status;
   const hasUnreadMessages = unreadCount > 0;
   const isPinned = Boolean(conversation.custom_attributes?.pinned);
@@ -94,9 +111,237 @@ const ChatHeader = ({
     ? formatContactPhone(conversation.contact?.phone_number)
     : null;
 
+  const [menuOpen, setMenuOpen] = useState(false);
+  const [allPipelines, setAllPipelines] = useState<Pipeline[]>([]);
+  const [isLoadingPipelines, setIsLoadingPipelines] = useState(false);
+  const [pipelinesLoaded, setPipelinesLoaded] = useState(false);
+  const [pipelinesLoadFailed, setPipelinesLoadFailed] = useState(false);
+  const [convPipelineData, setConvPipelineData] = useState<ConvPipelineData | null>(null);
+  const [isLoadingConvPipelines, setIsLoadingConvPipelines] = useState(false);
+  const pipelineFetchCountRef = useRef(0);
+
+  useEffect(() => {
+    let cancelled = false;
+    (async () => {
+      try {
+        const resp = await pipelinesService.getPipelines({ is_active: true });
+        if (!cancelled) {
+          setAllPipelines(resp.data ?? []);
+          setPipelinesLoaded(true);
+        }
+      } catch {
+        if (!cancelled) setPipelinesLoadFailed(true);
+      }
+    })();
+    return () => { cancelled = true; };
+  }, []);
+
+  useEffect(() => {
+    setConvPipelineData(null);
+  }, [conversation.id]);
+
+  useEffect(() => {
+    if (!menuOpen) return;
+
+    const fetchId = ++pipelineFetchCountRef.current;
+    setIsLoadingConvPipelines(true);
+    (async () => {
+      try {
+        const pipelines = await pipelinesService.getPipelinesByConversation(
+          String(conversation.id),
+        );
+        if (pipelineFetchCountRef.current !== fetchId) return;
+        setConvPipelineData({ pipelines });
+      } catch {
+        if (pipelineFetchCountRef.current === fetchId) {
+          setConvPipelineData({ pipelines: [] });
+        }
+      } finally {
+        if (pipelineFetchCountRef.current === fetchId) {
+          setIsLoadingConvPipelines(false);
+        }
+      }
+    })();
+  }, [menuOpen, conversation.id]);
+
+  const refreshConversationBadge = useCallback(async () => {
+    try {
+      const raw = await chatService.getConversation(String(conversation.id));
+      const envelope = raw as unknown as { data?: Conversation } | null;
+      const updated: Conversation | null = envelope?.data ?? (raw as unknown as Conversation);
+      if (updated) {
+        chatContext.conversations.updateConversation(updated);
+        const pipelines = await pipelinesService.getPipelinesByConversation(
+          String(conversation.id),
+        );
+        setConvPipelineData({ pipelines });
+      }
+    } catch {
+      // badge refresh is best-effort
+    }
+  }, [conversation.id, chatContext]);
+
+  const handlePipelineStageSelect = useCallback(
+    async (pipeline: Pipeline, stage: PipelineStage) => {
+      const currentPipelines = convPipelineData?.pipelines ?? [];
+      const existingInSamePipeline = currentPipelines.find(p => p.id === pipeline.id);
+      const existingInOtherPipelines = currentPipelines.filter(p => p.id !== pipeline.id);
+
+      if (existingInSamePipeline) {
+        const item = existingInSamePipeline.items?.find(
+          i => String(i.item_id) === String(conversation.id),
+        );
+        const itemId = item?.id;
+        if (!itemId) return;
+        try {
+          await pipelinesService.moveItem({
+            pipeline_id: pipeline.id,
+            item_id: itemId,
+            from_stage_id: item.stage_id,
+            to_stage_id: stage.id,
+          });
+          toast.success(t('pipeline.moveSuccess'));
+          await refreshConversationBadge();
+        } catch {
+          toast.error(t('pipeline.moveError'));
+        }
+      } else {
+        if (existingInOtherPipelines.length > 0) {
+          const removeResults = await Promise.allSettled(
+            existingInOtherPipelines.map(p => {
+              const item = p.items?.find(i => String(i.item_id) === String(conversation.id));
+              return item?.id
+                ? pipelinesService.removeItemFromPipeline(p.id, item.id)
+                : Promise.resolve();
+            }),
+          );
+          if (removeResults.some(r => r.status === 'rejected')) {
+            toast.error(t('pipeline.removeError'));
+            return;
+          }
+        }
+        try {
+          await pipelinesService.addItemToPipeline(pipeline.id, {
+            item_id: String(conversation.id),
+            type: 'conversation',
+            pipeline_stage_id: stage.id,
+          });
+          toast.success(t('pipeline.addSuccess'));
+          await refreshConversationBadge();
+        } catch {
+          toast.error(t('pipeline.addError'));
+        }
+      }
+    },
+    [convPipelineData, conversation.id, t, refreshConversationBadge],
+  );
+
+  const handleRemoveFromPipeline = useCallback(
+    async (pipeline: Pipeline) => {
+      const item = pipeline.items?.find(i => String(i.item_id) === String(conversation.id));
+      const itemId = item?.id;
+      if (!itemId) return;
+      try {
+        await pipelinesService.removeItemFromPipeline(pipeline.id, itemId);
+        toast.success(t('pipeline.removeSuccess'));
+        await refreshConversationBadge();
+      } catch {
+        toast.error(t('pipeline.removeError'));
+      }
+    },
+    [conversation.id, t, refreshConversationBadge],
+  );
+
+  const renderPipelineSubmenuContent = () => {
+    if (pipelinesLoadFailed) {
+      return (
+        <DropdownMenuLabel
+          className="text-destructive text-xs cursor-pointer"
+          onClick={async () => {
+            setPipelinesLoadFailed(false);
+            setIsLoadingPipelines(true);
+            try {
+              const resp = await pipelinesService.getPipelines({ is_active: true });
+              setAllPipelines(resp.data ?? []);
+              setPipelinesLoaded(true);
+            } catch {
+              setPipelinesLoadFailed(true);
+            } finally {
+              setIsLoadingPipelines(false);
+            }
+          }}
+        >
+          {t('pipeline.loadError')}
+        </DropdownMenuLabel>
+      );
+    }
+
+    if (isLoadingPipelines || !pipelinesLoaded) {
+      return <DropdownMenuLabel className="text-xs">{t('pipeline.loading')}</DropdownMenuLabel>;
+    }
+
+    if (allPipelines.length === 0) {
+      return <DropdownMenuLabel className="text-xs">{t('pipeline.noPipelines')}</DropdownMenuLabel>;
+    }
+
+    const currentPipelines = convPipelineData?.pipelines ?? [];
+
+    return (
+      <>
+        {allPipelines.map(pipeline => (
+          <DropdownMenuSub key={pipeline.id}>
+            <DropdownMenuSubTrigger className="flex items-center gap-2">
+              <GitBranch className="h-4 w-4" />
+              {pipeline.name}
+            </DropdownMenuSubTrigger>
+            <DropdownMenuSubContent>
+              {isLoadingConvPipelines ? (
+                <DropdownMenuLabel className="text-xs">{t('pipeline.loading')}</DropdownMenuLabel>
+              ) : (
+                <>
+                  {(pipeline.stages ?? []).map(stage => {
+                    const convInThisPipeline = currentPipelines.find(p => p.id === pipeline.id);
+                    const currentItem = convInThisPipeline?.items?.find(
+                      i => String(i.item_id) === String(conversation.id),
+                    );
+                    const isCurrentStage = currentItem?.stage_id === stage.id;
+
+                    return (
+                      <DropdownMenuItem
+                        key={stage.id}
+                        onClick={() => handlePipelineStageSelect(pipeline, stage)}
+                        className="flex items-center gap-2"
+                      >
+                        {isCurrentStage && <Check className="h-3 w-3 text-primary" />}
+                        {!isCurrentStage && <span className="w-3" />}
+                        {stage.name}
+                      </DropdownMenuItem>
+                    );
+                  })}
+                  {currentPipelines.some(p => p.id === pipeline.id) && (
+                    <>
+                      <DropdownMenuSeparator />
+                      <DropdownMenuItem
+                        onClick={() => handleRemoveFromPipeline(pipeline)}
+                        className="flex items-center gap-2 text-destructive focus:text-destructive"
+                      >
+                        <X className="h-4 w-4" />
+                        {t('pipeline.removeFrom')}
+                      </DropdownMenuItem>
+                    </>
+                  )}
+                </>
+              )}
+            </DropdownMenuSubContent>
+          </DropdownMenuSub>
+        ))}
+      </>
+    );
+  };
+
   const renderConversationStatusDropdown = () => {
     return (
-      <DropdownMenu>
+      <DropdownMenu open={menuOpen} onOpenChange={setMenuOpen}>
         <DropdownMenuTrigger asChild>
           <Button variant="ghost" size="sm" className="h-8 w-8 p-0">
             <MoreVertical className="h-4 w-4" />
@@ -240,6 +485,19 @@ const ChatHeader = ({
 
           <DropdownMenuSeparator />
 
+          {/* Pipeline Actions */}
+          <DropdownMenuSub>
+            <DropdownMenuSubTrigger className="flex items-center gap-2">
+              <GitBranch className="h-4 w-4" />
+              {t('pipeline.addTo')}
+            </DropdownMenuSubTrigger>
+            <DropdownMenuSubContent className="w-48">
+              {renderPipelineSubmenuContent()}
+            </DropdownMenuSubContent>
+          </DropdownMenuSub>
+
+          <DropdownMenuSeparator />
+
           <DropdownMenuItem
             onClick={() => onAssignAgent(conversation)}
             className="flex items-center gap-2"
diff --git a/src/components/chat/chat-sidebar/ChatSidebar.spec.tsx b/src/components/chat/chat-sidebar/ChatSidebar.spec.tsx
new file mode 100644
index 00000000..3280ad7c
--- /dev/null
+++ b/src/components/chat/chat-sidebar/ChatSidebar.spec.tsx
@@ -0,0 +1,279 @@
+import { render, screen, waitFor, fireEvent } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import ChatSidebar from './ChatSidebar';
+import { pipelinesService } from '@/services/pipelines/pipelinesService';
+import { toast } from 'sonner';
+
+vi.mock('@/services/pipelines/pipelinesService', () => ({
+  pipelinesService: {
+    getPipelines: vi.fn(),
+    getPipelinesByConversation: vi.fn(),
+    addItemToPipeline: vi.fn(),
+    moveItem: vi.fn(),
+    removeItemFromPipeline: vi.fn(),
+  },
+}));
+
+vi.mock('@/services/chat/chatService', () => ({
+  default: { getConversation: vi.fn() },
+}));
+
+vi.mock('sonner', () => ({
+  toast: { success: vi.fn(), error: vi.fn() },
+}));
+
+vi.mock('@/hooks/useLanguage', () => ({
+  useLanguage: () => ({ t: (key: string) => key }),
+}));
+
+vi.mock('@/hooks/useDebounce', () => ({
+  useDebounce: (v: unknown) => v,
+}));
+
+vi.mock('react-router-dom', () => ({
+  useNavigate: () => vi.fn(),
+}));
+
+vi.mock('@/utils/channelUtils', () => ({
+  isPhoneBearingChannel: () => false,
+}));
+
+vi.mock('@/utils/contact/formatContactPhone', () => ({
+  formatContactPhone: (p: string) => p,
+}));
+
+vi.mock('@/utils/time/timeHelpers', () => ({
+  formatConversationTime: () => '10:00',
+  formatDetailedTime: () => '2026-05-13 10:00',
+  normalizeToUnixSeconds: (v: number) => v,
+}));
+
+vi.mock('@/utils/chat/mediaLabels', () => ({
+  attachmentLabel: () => '',
+  mediaTypeFromAttributes: () => null,
+  senderNameFromAttributes: () => null,
+}));
+
+vi.mock('../loading-states', () => ({
+  ConversationSkeleton: () => <div data-testid="skeleton" />,
+}));
+
+vi.mock('../empty-states', () => ({
+  NoConversations: () => <div data-testid="no-conversations" />,
+}));
+
+vi.mock('../contact/ContactAvatar', () => ({
+  default: () => <div data-testid="contact-avatar" />,
+}));
+
+vi.mock('../conversation/ConversationBadges', () => ({
+  default: () => <div data-testid="conversation-badges" />,
+}));
+
+vi.mock('../conversation/ConversationsFilter', () => ({
+  default: () => <div data-testid="conversations-filter" />,
+}));
+
+vi.mock('../search/GlobalSearchPanel', () => ({
+  default: () => <div data-testid="global-search-panel" />,
+}));
+
+const makeConversation = (id = '42') =>
+  ({
+    id,
+    status: 'open' as const,
+    inbox: { id: '1', name: 'WhatsApp', channel_type: 'Channel::Whatsapp' },
+    contact: { id: '1', name: 'Test Contact' },
+    custom_attributes: {},
+    timestamp: Date.now(),
+    unread_count: 0,
+  }) as never;
+
+const makePipeline = (
+  id: string,
+  stages: { id: string; name: string }[],
+  items: { id: string; item_id: string; stage_id: string; pipeline_id: string }[] = [],
+) => ({
+  id,
+  name: `Pipeline ${id}`,
+  pipeline_type: 'custom' as const,
+  visibility: 'public' as const,
+  is_active: true,
+  stages: stages.map(s => ({ ...s, color: '#000', position: 0, created_at: '', updated_at: '' })),
+  items,
+  created_at: '',
+  updated_at: '',
+});
+
+const mockConversation = makeConversation();
+
+const makeMockContext = () => ({
+  conversations: {
+    state: {
+      conversations: [mockConversation],
+      conversationsLoading: false,
+      conversationsError: null,
+      selectedConversationId: null,
+      conversationsPagination: null,
+    },
+    getUnreadCount: () => 0,
+    loadConversations: vi.fn().mockResolvedValue(undefined),
+    loadMoreConversations: vi.fn().mockResolvedValue(undefined),
+    updateConversation: vi.fn(),
+  },
+  filters: {
+    state: { activeFilters: [], isApplyingFilters: false },
+    applyFilters: vi.fn(),
+    clearFilters: vi.fn(),
+  },
+});
+
+vi.mock('@/contexts/chat/ChatContext', () => ({
+  useChatContext: () => makeMockContext(),
+}));
+
+const defaultProps = {
+  mobileView: 'list' as const,
+  searchInput: '',
+  onSearchChange: vi.fn(),
+  onConversationSelect: vi.fn(),
+  onFilterApply: vi.fn(),
+  onFilterClear: vi.fn(),
+  onMarkAsRead: vi.fn(),
+  onMarkAsUnread: vi.fn(),
+  onMarkAsOpen: vi.fn(),
+  onMarkAsResolved: vi.fn(),
+  onPostpone: vi.fn(),
+  onMarkAsSnoozed: vi.fn(),
+  onSetPriority: vi.fn(),
+  onPinConversation: vi.fn(),
+  onUnpinConversation: vi.fn(),
+  onArchiveConversation: vi.fn(),
+  onUnarchiveConversation: vi.fn(),
+  onAssignAgent: vi.fn(),
+  onAssignTeam: vi.fn(),
+  onAssignTag: vi.fn(),
+  onDeleteConversation: vi.fn(),
+};
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+const openContextMenuPipelineStage = async (
+  user: ReturnType<typeof userEvent.setup>,
+  pipelineName: string,
+  stageName: string,
+) => {
+  const row = screen.getByText('Test Contact').closest('div[class*="p-4"]') as HTMLElement;
+  fireEvent.contextMenu(row);
+
+  const addToTrigger = await screen.findByText('pipeline.addTo', {}, { timeout: 2000 });
+  const addToSubTrigger = (
+    addToTrigger.closest('[data-slot="context-menu-sub-trigger"]') ?? addToTrigger
+  ) as HTMLElement;
+  addToSubTrigger.focus();
+  await user.keyboard('{ArrowRight}');
+
+  await waitFor(() => screen.getByText(pipelineName), { timeout: 2000 });
+  const pipelineEl = screen.getByText(pipelineName);
+  const pipelineSubTrigger = (
+    pipelineEl.closest('[data-slot="context-menu-sub-trigger"]') ?? pipelineEl
+  ) as HTMLElement;
+  pipelineSubTrigger.focus();
+  await user.keyboard('{ArrowRight}');
+
+  await waitFor(() => screen.getByText(stageName), { timeout: 3000 });
+  await user.click(screen.getByText(stageName));
+};
+
+describe('ChatSidebar pipeline', () => {
+  it('shows loading label in stage submenu while getPipelinesByConversation is pending (isLoadingConvPipelines guard)', async () => {
+    const pipeline = makePipeline('p1', [{ id: 'stage-1', name: 'Lead' }]);
+    vi.mocked(pipelinesService.getPipelines).mockResolvedValue({ data: [pipeline] } as never);
+    vi.mocked(pipelinesService.getPipelinesByConversation).mockReturnValue(new Promise(() => {}));
+
+    render(<ChatSidebar {...defaultProps} />);
+    await waitFor(() => expect(pipelinesService.getPipelines).toHaveBeenCalled());
+
+    const user = userEvent.setup();
+    const row = screen.getByText('Test Contact').closest('div[class*="p-4"]') as HTMLElement;
+    fireEvent.contextMenu(row);
+
+    await waitFor(() =>
+      expect(pipelinesService.getPipelinesByConversation).toHaveBeenCalledWith('42'),
+    );
+
+    const addToTrigger = await screen.findByText('pipeline.addTo', {}, { timeout: 2000 });
+    const addToSubTrigger = (
+      addToTrigger.closest('[data-slot="context-menu-sub-trigger"]') ?? addToTrigger
+    ) as HTMLElement;
+    addToSubTrigger.focus();
+    await user.keyboard('{ArrowRight}');
+
+    await waitFor(() => screen.getByText('Pipeline p1'), { timeout: 2000 });
+    const pipelineEl = screen.getByText('Pipeline p1');
+    const pipelineSubTrigger = (
+      pipelineEl.closest('[data-slot="context-menu-sub-trigger"]') ?? pipelineEl
+    ) as HTMLElement;
+    pipelineSubTrigger.focus();
+    await user.keyboard('{ArrowRight}');
+
+    await waitFor(() => {
+      expect(screen.getByText('pipeline.loading')).toBeInTheDocument();
+      expect(screen.queryByText('Lead')).not.toBeInTheDocument();
+    });
+  });
+
+  it('removes ALL pipelines when conversation is in 2+ pipelines before adding to new one (H1)', async () => {
+    const makeItem = (id: string, pipelineId: string) => ({
+      id,
+      item_id: '42',
+      stage_id: `stage-${pipelineId}`,
+      pipeline_id: pipelineId,
+      type: 'conversation',
+      is_lead: false,
+      created_at: '',
+      updated_at: '',
+    });
+    const pOld1 = makePipeline(
+      'p-old1',
+      [{ id: 'stage-p-old1', name: 'StageA' }],
+      [makeItem('item-1', 'p-old1')],
+    );
+    const pOld2 = makePipeline(
+      'p-old2',
+      [{ id: 'stage-p-old2', name: 'StageB' }],
+      [makeItem('item-2', 'p-old2')],
+    );
+    const pNew = makePipeline('p-new', [{ id: 'stage-new', name: 'StageC' }]);
+
+    vi.mocked(pipelinesService.getPipelines).mockResolvedValue({
+      data: [pOld1, pOld2, pNew],
+    } as never);
+    vi.mocked(pipelinesService.getPipelinesByConversation).mockResolvedValue([pOld1, pOld2]);
+    vi.mocked(pipelinesService.removeItemFromPipeline).mockResolvedValue({
+      success: true,
+      message: '',
+    });
+    vi.mocked(pipelinesService.addItemToPipeline).mockResolvedValue({} as never);
+
+    render(<ChatSidebar {...defaultProps} />);
+    await waitFor(() => expect(pipelinesService.getPipelines).toHaveBeenCalled());
+
+    const user = userEvent.setup();
+    await openContextMenuPipelineStage(user, 'Pipeline p-new', 'StageC');
+
+    await waitFor(() => {
+      expect(pipelinesService.removeItemFromPipeline).toHaveBeenCalledWith('p-old1', 'item-1');
+      expect(pipelinesService.removeItemFromPipeline).toHaveBeenCalledWith('p-old2', 'item-2');
+      expect(pipelinesService.removeItemFromPipeline).toHaveBeenCalledTimes(2);
+      expect(pipelinesService.addItemToPipeline).toHaveBeenCalledWith('p-new', {
+        item_id: '42',
+        type: 'conversation',
+        pipeline_stage_id: 'stage-new',
+      });
+    });
+  });
+});
diff --git a/src/components/chat/chat-sidebar/ChatSidebar.tsx b/src/components/chat/chat-sidebar/ChatSidebar.tsx
index b0b41274..f9522aff 100644
--- a/src/components/chat/chat-sidebar/ChatSidebar.tsx
+++ b/src/components/chat/chat-sidebar/ChatSidebar.tsx
@@ -8,6 +8,10 @@ import {
   ContextMenuContent,
   ContextMenuItem,
   ContextMenuSeparator,
+  ContextMenuSub,
+  ContextMenuSubContent,
+  ContextMenuSubTrigger,
+  ContextMenuLabel,
 } from '@evoapi/design-system/context-menu';
 import {
   Search,
@@ -30,10 +34,13 @@ import {
   FileText,
   Pin,
   Archive,
+  GitBranch,
+  Check,
 } from 'lucide-react';
 import { useNavigate } from 'react-router-dom';
 import { useChatContext } from '@/contexts/chat/ChatContext';
 import { Conversation, ConversationFilter } from '@/types/chat/api';
+import type { Pipeline, PipelineStage } from '@/types/analytics';
 import {
   attachmentLabel,
   mediaTypeFromAttributes,
@@ -52,6 +59,8 @@ import { BaseFilter } from '@/types/core';
 import { useLanguage } from '@/hooks/useLanguage';
 import { useDebounce } from '@/hooks/useDebounce';
 import chatService from '@/services/chat/chatService';
+import { pipelinesService } from '@/services/pipelines/pipelinesService';
+import { toast } from 'sonner';
 import type {
   SearchConversationResult,
   SearchContactResult,
@@ -136,6 +145,279 @@ const ChatSidebar = ({
   const sidebarScrollRef = useRef<HTMLDivElement | null>(null);
   const loadingMoreRef = useRef(false);
 
+  // Pipeline state
+  const [allPipelines, setAllPipelines] = useState<Pipeline[]>([]);
+  const [isPipelinesLoaded, setIsPipelinesLoaded] = useState(false);
+  const [pipelinesLoadFailed, setPipelinesLoadFailed] = useState(false);
+  const [convPipelineStates, setConvPipelineStates] = useState<Map<string, Pipeline[]>>(new Map());
+  const [loadingConvPipelines, setLoadingConvPipelines] = useState<Set<string>>(new Set());
+  const pipelineFetchCountRef = useRef<Map<string, number>>(new Map());
+
+  useEffect(() => {
+    let cancelled = false;
+    (async () => {
+      try {
+        const resp = await pipelinesService.getPipelines({ is_active: true });
+        if (!cancelled) {
+          setAllPipelines(resp.data ?? []);
+          setIsPipelinesLoaded(true);
+        }
+      } catch {
+        if (!cancelled) setPipelinesLoadFailed(true);
+      }
+    })();
+    return () => { cancelled = true; };
+  }, []);
+
+  const loadConversationPipelineState = useCallback(async (convId: string) => {
+    const current = pipelineFetchCountRef.current.get(convId) ?? 0;
+    const fetchId = current + 1;
+    pipelineFetchCountRef.current.set(convId, fetchId);
+
+    setLoadingConvPipelines(prev => new Set([...prev, convId]));
+    try {
+      const pipelines = await pipelinesService.getPipelinesByConversation(convId);
+      if (pipelineFetchCountRef.current.get(convId) !== fetchId) return;
+      setConvPipelineStates(prev => {
+        const next = new Map(prev);
+        next.set(convId, pipelines);
+        return next;
+      });
+    } catch {
+      if (pipelineFetchCountRef.current.get(convId) === fetchId) {
+        setConvPipelineStates(prev => {
+          const next = new Map(prev);
+          next.set(convId, []);
+          return next;
+        });
+      }
+    } finally {
+      if (pipelineFetchCountRef.current.get(convId) === fetchId) {
+        setLoadingConvPipelines(prev => {
+          const next = new Set(prev);
+          next.delete(convId);
+          return next;
+        });
+      }
+    }
+  }, []);
+
+  const refreshConversationBadge = useCallback(async (convId: string) => {
+    try {
+      const raw = await chatService.getConversation(convId);
+      const envelope = raw as unknown as { data?: Conversation } | null;
+      const updated: Conversation | null = envelope?.data ?? (raw as unknown as Conversation);
+      if (updated) {
+        chatContext.conversations.updateConversation(updated);
+      }
+    } catch {
+      // badge refresh is best-effort
+    }
+  }, [chatContext]);
+
+  const handlePipelineStageSelect = useCallback(
+    async (conversation: Conversation, pipeline: Pipeline, stage: PipelineStage) => {
+      const convId = String(conversation.id);
+      const currentPipelines = convPipelineStates.get(convId) ?? [];
+      const existingInSamePipeline = currentPipelines.find(p => p.id === pipeline.id);
+      const existingInOtherPipelines = currentPipelines.filter(p => p.id !== pipeline.id);
+
+      if (existingInSamePipeline) {
+        const item = existingInSamePipeline.items?.find(
+          i => String(i.item_id) === convId,
+        );
+        const itemId = item?.id;
+        if (!itemId) return;
+        try {
+          await pipelinesService.moveItem({
+            pipeline_id: pipeline.id,
+            item_id: itemId,
+            from_stage_id: item.stage_id,
+            to_stage_id: stage.id,
+          });
+          toast.success(t('pipeline.moveSuccess'));
+          setConvPipelineStates(prev => {
+            const next = new Map(prev);
+            next.delete(convId);
+            return next;
+          });
+          await Promise.all([
+            loadConversationPipelineState(convId),
+            refreshConversationBadge(convId),
+          ]);
+        } catch {
+          toast.error(t('pipeline.moveError'));
+        }
+      } else {
+        if (existingInOtherPipelines.length > 0) {
+          const removeResults = await Promise.allSettled(
+            existingInOtherPipelines.map(p => {
+              const item = p.items?.find(i => String(i.item_id) === convId);
+              return item?.id
+                ? pipelinesService.removeItemFromPipeline(p.id, item.id)
+                : Promise.resolve();
+            }),
+          );
+          if (removeResults.some(r => r.status === 'rejected')) {
+            toast.error(t('pipeline.removeError'));
+            return;
+          }
+        }
+        try {
+          await pipelinesService.addItemToPipeline(pipeline.id, {
+            item_id: convId,
+            type: 'conversation',
+            pipeline_stage_id: stage.id,
+          });
+          toast.success(t('pipeline.addSuccess'));
+          setConvPipelineStates(prev => {
+            const next = new Map(prev);
+            next.delete(convId);
+            return next;
+          });
+          await Promise.all([
+            loadConversationPipelineState(convId),
+            refreshConversationBadge(convId),
+          ]);
+        } catch {
+          toast.error(t('pipeline.addError'));
+        }
+      }
+    },
+    [convPipelineStates, t, loadConversationPipelineState, refreshConversationBadge],
+  );
+
+  const handleRemoveFromPipeline = useCallback(
+    async (conversation: Conversation, pipeline: Pipeline) => {
+      const convId = String(conversation.id);
+      const item = pipeline.items?.find(i => String(i.item_id) === convId);
+      const itemId = item?.id;
+      if (!itemId) return;
+      try {
+        await pipelinesService.removeItemFromPipeline(pipeline.id, itemId);
+        toast.success(t('pipeline.removeSuccess'));
+        setConvPipelineStates(prev => {
+          const next = new Map(prev);
+          next.delete(convId);
+          return next;
+        });
+        await Promise.all([
+          loadConversationPipelineState(convId),
+          refreshConversationBadge(convId),
+        ]);
+      } catch {
+        toast.error(t('pipeline.removeError'));
+      }
+    },
+    [t, loadConversationPipelineState, refreshConversationBadge],
+  );
+
+  const renderPipelineSubContent = useCallback(
+    (conversation: Conversation) => {
+      if (pipelinesLoadFailed) {
+        return (
+          <ContextMenuLabel
+            className="text-destructive text-xs cursor-pointer"
+            onClick={async () => {
+              setPipelinesLoadFailed(false);
+              try {
+                const resp = await pipelinesService.getPipelines({ is_active: true });
+                setAllPipelines(resp.data ?? []);
+                setIsPipelinesLoaded(true);
+              } catch {
+                setPipelinesLoadFailed(true);
+              }
+            }}
+          >
+            {t('pipeline.loadError')}
+          </ContextMenuLabel>
+        );
+      }
+
+      if (!isPipelinesLoaded) {
+        return <ContextMenuLabel className="text-xs">{t('pipeline.loading')}</ContextMenuLabel>;
+      }
+
+      if (allPipelines.length === 0) {
+        return (
+          <ContextMenuLabel className="text-xs">{t('pipeline.noPipelines')}</ContextMenuLabel>
+        );
+      }
+
+      const convId = String(conversation.id);
+      const isConvLoading = loadingConvPipelines.has(convId);
+      const currentPipelines = convPipelineStates.get(convId) ?? [];
+
+      return (
+        <>
+          {allPipelines.map(pipeline => (
+            <ContextMenuSub key={pipeline.id}>
+              <ContextMenuSubTrigger className="flex items-center gap-2">
+                <GitBranch className="h-4 w-4" />
+                {pipeline.name}
+              </ContextMenuSubTrigger>
+              <ContextMenuSubContent>
+                {isConvLoading ? (
+                  <ContextMenuLabel className="text-xs">{t('pipeline.loading')}</ContextMenuLabel>
+                ) : (
+                  <>
+                    {(pipeline.stages ?? []).map(stage => {
+                      const convInThisPipeline = currentPipelines.find(p => p.id === pipeline.id);
+                      const currentItem = convInThisPipeline?.items?.find(
+                        i => String(i.item_id) === convId,
+                      );
+                      const isCurrentStage = currentItem?.stage_id === stage.id;
+
+                      return (
+                        <ContextMenuItem
+                          key={stage.id}
+                          onClick={e => {
+                            e.stopPropagation();
+                            handlePipelineStageSelect(conversation, pipeline, stage);
+                          }}
+                          className="flex items-center gap-2"
+                        >
+                          {isCurrentStage && <Check className="h-3 w-3 text-primary" />}
+                          {!isCurrentStage && <span className="w-3" />}
+                          {stage.name}
+                        </ContextMenuItem>
+                      );
+                    })}
+                    {currentPipelines.some(p => p.id === pipeline.id) && (
+                      <>
+                        <ContextMenuSeparator />
+                        <ContextMenuItem
+                          onClick={e => {
+                            e.stopPropagation();
+                            handleRemoveFromPipeline(conversation, pipeline);
+                          }}
+                          className="flex items-center gap-2 text-destructive focus:text-destructive"
+                        >
+                          <X className="h-4 w-4" />
+                          {t('pipeline.removeFrom')}
+                        </ContextMenuItem>
+                      </>
+                    )}
+                  </>
+                )}
+              </ContextMenuSubContent>
+            </ContextMenuSub>
+          ))}
+        </>
+      );
+    },
+    [
+      pipelinesLoadFailed,
+      isPipelinesLoaded,
+      allPipelines,
+      convPipelineStates,
+      loadingConvPipelines,
+      t,
+      handlePipelineStageSelect,
+      handleRemoveFromPipeline,
+    ],
+  );
+
   // 🎯 SYNC: Sincronizar local state com FiltersContext para compatibilidade com o modal
   useEffect(() => {
     // Quando filters.state.activeFilters mudar (ex: por applyFilters chamado diretamente),
@@ -348,7 +630,12 @@ const ChatSidebar = ({
     const isArchived = Boolean(conversation.custom_attributes?.archived);
 
     return (
-      <ContextMenu key={conversation.id}>
+      <ContextMenu
+        key={conversation.id}
+        onOpenChange={open => {
+          if (open) loadConversationPipelineState(String(conversation.id));
+        }}
+      >
         <ContextMenuTrigger asChild>{children}</ContextMenuTrigger>
         <ContextMenuContent className="w-56">
           {/* Read/Unread Actions */}
@@ -529,6 +816,19 @@ const ChatSidebar = ({
 
           <ContextMenuSeparator />
 
+          {/* Pipeline Actions */}
+          <ContextMenuSub>
+            <ContextMenuSubTrigger className="flex items-center gap-2">
+              <GitBranch className="h-4 w-4" />
+              {t('pipeline.addTo')}
+            </ContextMenuSubTrigger>
+            <ContextMenuSubContent className="w-48">
+              {renderPipelineSubContent(conversation)}
+            </ContextMenuSubContent>
+          </ContextMenuSub>
+
+          <ContextMenuSeparator />
+
           <ContextMenuItem
             onClick={e => {
               e.stopPropagation();
@@ -758,7 +1058,7 @@ const ChatSidebar = ({
                             {Boolean(conversation.custom_attributes?.pinned) && (
                               <Pin className="h-3.5 w-3.5 text-primary flex-shrink-0" />
                             )}
-                            {/* 📌 Indicador de Post do Facebook */}
+                            {/* ðŸ"Œ Indicador de Post do Facebook */}
                             {conversation.additional_attributes?.conversation_type === 'post' && (
                               <Badge
                                 variant="outline"
@@ -816,7 +1116,7 @@ const ChatSidebar = ({
                     </div>
                     <div className="flex flex-col items-end gap-1 flex-shrink-0">
                       {(() => {
-                        // 🔵 INDICADOR PADRÃO: Bolinha pequena seguindo padrão do sistema
+                        // ðŸ"µ INDICADOR PADRÃO: Bolinha pequena seguindo padrão do sistema
                         const hasUnreadMessages =
                           (conversations.getUnreadCount(conversation.id) || 0) > 0;
 
@@ -866,5 +1166,3 @@ const ChatSidebar = ({
 };
 
 export default ChatSidebar;
-
-
diff --git a/src/components/chat/contact-sidebar/ContactSidebar.tsx b/src/components/chat/contact-sidebar/ContactSidebar.tsx
index d1347531..f07b1ff4 100644
--- a/src/components/chat/contact-sidebar/ContactSidebar.tsx
+++ b/src/components/chat/contact-sidebar/ContactSidebar.tsx
@@ -15,7 +15,6 @@ import EditableContactCustomAttributes from './EditableContactCustomAttributes';
 import EditableConversationCustomAttributes from './EditableConversationCustomAttributes';
 
 import ConversationPipelineItem from '@/components/pipelines/ConversationPipelineItem';
-import PipelineManagement from '@/components/chat/contact-sidebar/PipelineManagement';
 import { pipelinesService } from '@/services/pipelines';
 import type { Pipeline } from '@/types/analytics';
 
@@ -233,23 +232,14 @@ const ContactSidebar: React.FC<ContactSidebarProps> = ({
               {showPipeline && (
                 <CardContent className="pt-0 px-3 pb-3">
                   {conversation && (
-                    <>
-                      <div className="max-h-60 overflow-y-auto scrollbar-thin pr-1">
-                        <ConversationPipelineItem
-                          conversationId={conversation.id}
-                          pipelines={conversationPipelines}
-                          isLoadingPipelines={isLoadingPipelines}
-                          onPipelineUpdated={handlePipelineUpdated}
-                        />
-                      </div>
-                      <div className="pt-4 border-t border-border mt-4">
-                        <PipelineManagement
-                          conversationId={conversation.id}
-                          pipelines={conversationPipelines}
-                          onPipelineUpdated={handlePipelineUpdated}
-                        />
-                      </div>
-                    </>
+                    <div className="max-h-60 overflow-y-auto scrollbar-thin pr-1">
+                      <ConversationPipelineItem
+                        conversationId={conversation.id}
+                        pipelines={conversationPipelines}
+                        isLoadingPipelines={isLoadingPipelines}
+                        onPipelineUpdated={handlePipelineUpdated}
+                      />
+                    </div>
                   )}
                 </CardContent>
               )}
diff --git a/src/components/chat/contact-sidebar/PipelineManagement.spec.tsx b/src/components/chat/contact-sidebar/PipelineManagement.spec.tsx
deleted file mode 100644
index 35edb218..00000000
--- a/src/components/chat/contact-sidebar/PipelineManagement.spec.tsx
+++ /dev/null
@@ -1,293 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from 'vitest';
-import { fireEvent, render, screen, waitFor } from '@testing-library/react';
-import PipelineManagement from './PipelineManagement';
-import type { Pipeline } from '@/types/analytics';
-
-// Mock pipelinesService
-const mockMoveItem = vi.fn().mockResolvedValue({ success: true, message: 'ok' });
-const mockAddItemToPipeline = vi.fn().mockResolvedValue({ data: {} });
-const mockRemoveItemFromPipeline = vi.fn().mockResolvedValue({ success: true });
-const mockGetPipelines = vi.fn().mockResolvedValue({ data: [] });
-
-vi.mock('@/services/pipelines/pipelinesService', () => ({
-  pipelinesService: {
-    moveItem: (...args: unknown[]) => mockMoveItem(...args),
-    addItemToPipeline: (...args: unknown[]) => mockAddItemToPipeline(...args),
-    removeItemFromPipeline: (...args: unknown[]) => mockRemoveItemFromPipeline(...args),
-    getPipelines: (...args: unknown[]) => mockGetPipelines(...args),
-  },
-}));
-
-// Mock toast
-const mockToastSuccess = vi.fn();
-const mockToastError = vi.fn();
-vi.mock('sonner', () => ({
-  toast: {
-    success: (...args: unknown[]) => mockToastSuccess(...args),
-    error: (...args: unknown[]) => mockToastError(...args),
-  },
-}));
-
-vi.mock('@/hooks/useLanguage', () => ({
-  useLanguage: () => ({ t: (key: string) => key }),
-}));
-
-// Mock design-system components
-vi.mock('@evoapi/design-system/button', () => ({
-  Button: ({ children, onClick, disabled, ...props }: any) => (
-    <button type="button" onClick={onClick} disabled={disabled} {...props}>{children}</button>
-  ),
-}));
-
-vi.mock('@evoapi/design-system/select', () => ({
-  Select: ({ children, value, onValueChange }: any) => (
-    <div data-testid="select" data-value={value}>
-      {typeof children === 'function' ? children({ onValueChange }) : children}
-    </div>
-  ),
-  SelectTrigger: ({ children, ...props }: any) => <div {...props}>{children}</div>,
-  SelectValue: ({ placeholder }: any) => <span>{placeholder}</span>,
-  SelectContent: ({ children }: any) => <div>{children}</div>,
-  SelectItem: ({ children, value, onClick }: any) => (
-    <option value={value} onClick={onClick}>{children}</option>
-  ),
-}));
-
-vi.mock('@evoapi/design-system/label', () => ({
-  Label: ({ children, ...props }: any) => <label {...props}>{children}</label>,
-}));
-
-vi.mock('@evoapi/design-system/alert-dialog', () => ({
-  AlertDialog: ({ children, open }: any) => open ? <div data-testid="alert-dialog">{children}</div> : null,
-  AlertDialogContent: ({ children }: any) => <div>{children}</div>,
-  AlertDialogHeader: ({ children }: any) => <div>{children}</div>,
-  AlertDialogTitle: ({ children }: any) => <h2>{children}</h2>,
-  AlertDialogDescription: ({ children }: any) => <p>{children}</p>,
-  AlertDialogFooter: ({ children }: any) => <div>{children}</div>,
-  AlertDialogAction: ({ children, onClick }: any) => (
-    <button type="button" data-testid="confirm-action" onClick={onClick}>{children}</button>
-  ),
-  AlertDialogCancel: ({ children }: any) => <button type="button">{children}</button>,
-}));
-
-vi.mock('lucide-react', () => ({
-  Loader2: () => <span data-testid="icon-loader" />,
-  GitBranch: () => <span data-testid="icon-branch" />,
-  Trash2: () => <span data-testid="icon-trash" />,
-  Save: () => <span data-testid="icon-save" />,
-  AlertTriangle: () => <span data-testid="icon-alert" />,
-}));
-
-const CONVERSATION_ID = 'conv-123';
-const PIPELINE_ID = 'pipeline-1';
-const STAGE_1_ID = 'stage-1';
-const STAGE_2_ID = 'stage-2';
-const ITEM_ID = 'item-1';
-
-function createPipeline(overrides?: Partial<Pipeline>): Pipeline {
-  return {
-    id: PIPELINE_ID,
-    name: 'Sales Pipeline',
-    pipeline_type: 'sales',
-    visibility: 'public',
-    is_active: true,
-    created_at: '2026-01-01',
-    updated_at: '2026-01-01',
-    stages: [
-      {
-        id: STAGE_1_ID,
-        name: 'Lead',
-        color: '#blue',
-        position: 0,
-        created_at: '2026-01-01',
-        updated_at: '2026-01-01',
-        items: [
-          {
-            id: ITEM_ID,
-            item_id: CONVERSATION_ID,
-            type: 'conversation' as const,
-            pipeline_id: PIPELINE_ID,
-            stage_id: STAGE_1_ID,
-            is_lead: false,
-            created_at: '2026-01-01',
-            updated_at: '2026-01-01',
-            tasks_info: {
-              pending_count: 0,
-              overdue_count: 0,
-              due_soon_count: 0,
-              completed_count: 0,
-              total_count: 0,
-            },
-          },
-        ],
-      },
-      {
-        id: STAGE_2_ID,
-        name: 'Qualified',
-        color: '#green',
-        position: 1,
-        created_at: '2026-01-01',
-        updated_at: '2026-01-01',
-        items: [],
-      },
-    ],
-    ...overrides,
-  } as Pipeline;
-}
-
-describe('PipelineManagement', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockGetPipelines.mockResolvedValue({ data: [createPipeline()] });
-  });
-
-  it('renders without crashing', () => {
-    render(
-      <PipelineManagement
-        conversationId={CONVERSATION_ID}
-        pipelines={[createPipeline()]}
-      />,
-    );
-    expect(screen.getByText('contactSidebar.pipeline.label')).toBeTruthy();
-  });
-
-  describe('confirmSave — existing item (stage move)', () => {
-    it('calls moveItem with correct params when conversation already in pipeline', async () => {
-      const onPipelineUpdated = vi.fn();
-      const pipeline = createPipeline();
-
-      const { container } = render(
-        <PipelineManagement
-          conversationId={CONVERSATION_ID}
-          pipelines={[pipeline]}
-          onPipelineUpdated={onPipelineUpdated}
-        />,
-      );
-
-      // Wait for initial data load
-      await waitFor(() => {
-        expect(mockGetPipelines).toHaveBeenCalled();
-      });
-
-      // Directly test the confirmSave logic by simulating the internal state:
-      // The component sets selectedPipelineId and selectedStageId from loadData.
-      // We trigger save button click which opens the confirm dialog.
-      const saveButtons = container.querySelectorAll('button');
-      const saveButton = Array.from(saveButtons).find(
-        btn => btn.textContent?.includes('contactSidebar.pipeline.save')
-      );
-
-      // The save button should exist
-      expect(saveButton).toBeTruthy();
-    });
-
-    it('uses moveItem (move_to_stage) not updateItemInPipeline for existing items', async () => {
-      // This test validates the core bug fix:
-      // When a conversation is already in a pipeline, changing stage should use
-      // moveItem() (same endpoint as Kanban drag-and-drop) instead of updateItemInPipeline()
-      const pipeline = createPipeline();
-
-      // Simulate the confirmSave logic directly
-      // Find pipeline item by searching through stages
-      const conversationPipeline = pipeline;
-      let conversationItem: any;
-      if (conversationPipeline?.stages) {
-        for (const stage of conversationPipeline.stages) {
-          const found = stage.items?.find(
-            (item: any) => String(item.item_id) === CONVERSATION_ID
-          );
-          if (found) {
-            conversationItem = found;
-            break;
-          }
-        }
-      }
-
-      // The item MUST be found with the correct search logic
-      expect(conversationItem).toBeDefined();
-      expect(conversationItem.id).toBe(ITEM_ID);
-      expect(conversationItem.item_id).toBe(CONVERSATION_ID);
-      expect(conversationItem.stage_id).toBe(STAGE_1_ID);
-
-      // Simulate what confirmSave does for existing items
-      await mockMoveItem({
-        item_id: conversationItem.id,
-        pipeline_id: PIPELINE_ID,
-        from_stage_id: conversationItem.stage_id,
-        to_stage_id: STAGE_2_ID,
-      });
-
-      expect(mockMoveItem).toHaveBeenCalledWith({
-        item_id: ITEM_ID,
-        pipeline_id: PIPELINE_ID,
-        from_stage_id: STAGE_1_ID,
-        to_stage_id: STAGE_2_ID,
-      });
-    });
-
-    it('OLD BUG: item.id !== stage_id so old logic would never find the item', () => {
-      // This test documents the bug that was fixed.
-      // The old code compared item.id with selectedStageId which are unrelated IDs.
-      const pipeline = createPipeline();
-      const selectedStageId = STAGE_2_ID;
-
-      // OLD buggy logic: items?.find(item => item.id === selectedStageId && item.item_id === conversationId)
-      const oldResult = pipeline.items?.find(
-        (item: any) => String(item.id) === selectedStageId && String(item.item_id) === CONVERSATION_ID
-      );
-      // pipeline.items is undefined (items are nested in stages), so this would be undefined
-      expect(oldResult).toBeUndefined();
-
-      // Even if we checked conversationPipeline.items, item.id (ITEM_ID='item-1') !== selectedStageId ('stage-2')
-      // So the old code would NEVER find an existing item, always falling through to addItemToPipeline
-    });
-  });
-
-  describe('confirmSave — new item (add to pipeline)', () => {
-    it('calls addItemToPipeline when conversation is NOT in the pipeline', async () => {
-      // Pipeline with no items matching our conversation
-      const emptyPipeline = createPipeline({
-        stages: [
-          {
-            id: STAGE_1_ID,
-            name: 'Lead',
-            color: '#blue',
-            position: 0,
-            created_at: '2026-01-01',
-            updated_at: '2026-01-01',
-            items: [],
-          },
-        ],
-      });
-
-      // Simulate the search logic - should NOT find an item
-      let conversationItem: any;
-      if (emptyPipeline.stages) {
-        for (const stage of emptyPipeline.stages) {
-          const found = stage.items?.find(
-            (item: any) => String(item.item_id) === CONVERSATION_ID
-          );
-          if (found) {
-            conversationItem = found;
-            break;
-          }
-        }
-      }
-
-      expect(conversationItem).toBeUndefined();
-
-      // When no item found, addItemToPipeline should be called
-      await mockAddItemToPipeline(PIPELINE_ID, {
-        item_id: CONVERSATION_ID,
-        type: 'conversation',
-        pipeline_stage_id: STAGE_1_ID,
-      });
-
-      expect(mockAddItemToPipeline).toHaveBeenCalledWith(PIPELINE_ID, {
-        item_id: CONVERSATION_ID,
-        type: 'conversation',
-        pipeline_stage_id: STAGE_1_ID,
-      });
-    });
-  });
-});
diff --git a/src/components/chat/contact-sidebar/PipelineManagement.tsx b/src/components/chat/contact-sidebar/PipelineManagement.tsx
deleted file mode 100644
index 38f4e0ad..00000000
--- a/src/components/chat/contact-sidebar/PipelineManagement.tsx
+++ /dev/null
@@ -1,411 +0,0 @@
-import React, { useState, useEffect } from 'react';
-import { Button } from '@evoapi/design-system/button';
-import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@evoapi/design-system/select';
-import { Label } from '@evoapi/design-system/label';
-import {
-  AlertDialog,
-  AlertDialogAction,
-  AlertDialogCancel,
-  AlertDialogContent,
-  AlertDialogDescription,
-  AlertDialogFooter,
-  AlertDialogHeader,
-  AlertDialogTitle,
-} from '@evoapi/design-system/alert-dialog';
-import { Loader2, GitBranch, Trash2, Save, AlertTriangle } from 'lucide-react';
-import { toast } from 'sonner';
-import { pipelinesService } from '@/services/pipelines/pipelinesService';
-import type { Pipeline, PipelineItem, PipelineStage } from '@/types/analytics';
-import { useLanguage } from '@/hooks/useLanguage';
-
-interface PipelineManagementProps {
-  conversationId: string;
-  pipelines: Pipeline[];
-  onPipelineUpdated?: () => void;
-}
-
-interface ConversationPipelineData {
-  pipeline: Pipeline;
-  stage: PipelineStage;
-}
-
-const PipelineManagement: React.FC<PipelineManagementProps> = ({
-  conversationId,
-  pipelines, 
-  onPipelineUpdated,
-}) => {
-  const { t } = useLanguage('chat');
-  const [currentPipeline, setCurrentPipeline] = useState<ConversationPipelineData | null>(null);
-  const [selectedPipelineId, setSelectedPipelineId] = useState<string>('');
-  const [selectedStageId, setSelectedStageId] = useState<string>('');
-  const [isSaving, setIsSaving] = useState(false);
-  const [showSaveConfirm, setShowSaveConfirm] = useState(false);
-  const [showRemoveConfirm, setShowRemoveConfirm] = useState(false);
-  const [originalPipelines, setOriginalPipelines] = useState<Pipeline[]>([]);
-
-  const loadData = async () => {
-    const pipelinesResponse = await pipelinesService.getPipelines();
-    setOriginalPipelines(pipelinesResponse.data || []);
-    
-    let foundPipeline: ConversationPipelineData | null = null;
-    
-    for (const pipeline of pipelines) {
-      if (pipeline.stages) {
-        // Procurar o item da conversation nos stages
-        for (const stage of pipeline.stages) {
-          if (stage.items && stage.items.length > 0) {
-            foundPipeline = { pipeline, stage };
-            setSelectedPipelineId(String(pipeline.id));
-            setSelectedStageId(String(stage.id));
-            break;
-          }
-        }
-      }
-    }
-    
-    if (!foundPipeline) return;
-
-    setCurrentPipeline(foundPipeline);
-  };
-
-  useEffect(() => {
-    loadData();
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [conversationId, pipelines]);
-
-  const selectedPipeline = pipelines.find(p => String(p.id) === selectedPipelineId);
-
-  // Load stages when pipeline is selected
-  const [availableStages, setAvailableStages] = useState<PipelineStage[]>([]);
-
-  useEffect(() => {
-    const loadStages = async () => {
-      if (!selectedPipelineId) {
-        setAvailableStages([]);
-        return;
-      }
-
-      try {
-        const pipelinesToSearch = originalPipelines || [];
-        const selectedPipeline = pipelinesToSearch.find(
-          (p) => String(p.id) === selectedPipelineId,
-        );
-
-        setAvailableStages(selectedPipeline?.stages || []);
-      } catch (error) {
-        console.error('Error loading stages:', error);
-        setAvailableStages([]);
-      }
-    };
-
-    loadStages();
-  }, [selectedPipelineId, originalPipelines]);
-
-  const handlePipelineChange = (value: string) => {
-    setSelectedPipelineId(value);
-    // Reset stage when pipeline changes
-    setSelectedStageId('');
-  };
-
-  const handleSaveClick = () => {
-    if (!selectedPipelineId || !selectedStageId) {
-      toast.error(t('contactSidebar.pipeline.selectError'));
-      return;
-    }
-    setShowSaveConfirm(true);
-  };
-
-  const confirmSave = async () => {
-    if (!selectedPipelineId || !selectedStageId) return;
-
-    try {
-      setIsSaving(true);
-      setShowSaveConfirm(false);
-
-      // Find the pipeline item for this conversation by searching through stages
-      const conversationPipeline = pipelines?.find(
-        (pipeline: Pipeline) => String(pipeline.id) === selectedPipelineId
-      );
-
-      let conversationItem: PipelineItem | undefined;
-      if (conversationPipeline?.stages) {
-        for (const stage of conversationPipeline.stages) {
-          const found = stage.items?.find(
-            (item: PipelineItem) => String(item.item_id) === conversationId
-          );
-          if (found) {
-            conversationItem = found;
-            break;
-          }
-        }
-      }
-
-      if (conversationItem) {
-        // Use move_to_stage endpoint (same as Kanban drag-and-drop)
-        await pipelinesService.moveItem({
-          item_id: conversationItem.id,
-          pipeline_id: selectedPipelineId,
-          from_stage_id: conversationItem.stage_id,
-          to_stage_id: selectedStageId,
-        });
-      } else {
-        await pipelinesService.addItemToPipeline(selectedPipelineId, {
-          item_id: conversationId,
-          type: 'conversation',
-          pipeline_stage_id: selectedStageId,
-        });
-      }
-
-      toast.success(t('contactSidebar.pipeline.saveSuccess'));
-      await loadData();
-      onPipelineUpdated?.();
-    } catch (error) {
-      console.error('Error updating pipeline:', error);
-      toast.error(t('contactSidebar.pipeline.saveError'));
-    } finally {
-      setIsSaving(false);
-    }
-  };
-
-  const handleRemoveClick = () => {
-    setShowRemoveConfirm(true);
-  };
-
-  const confirmRemove = async () => {
-    if (!currentPipeline) return;
-
-    try {
-      setIsSaving(true);
-      setShowRemoveConfirm(false);
-      await pipelinesService.removeItemFromPipeline(
-        String(currentPipeline.pipeline.id),
-        conversationId,
-      );
-      toast.success(t('contactSidebar.pipeline.removeSuccess'));
-      setSelectedPipelineId('');
-      setSelectedStageId('');
-      setCurrentPipeline(null);
-      onPipelineUpdated?.();
-    } catch (error) {
-      console.error('Error removing from pipeline:', error);
-      toast.error(t('contactSidebar.pipeline.removeError'));
-    } finally {
-      setIsSaving(false);
-    }
-  };
-
-  return (
-    <div className="space-y-4">
-      {/* Current Pipeline Status */}
-      {currentPipeline && (
-        <div className="p-3 rounded-lg bg-primary/10 border border-primary/20">
-          <div className="flex items-center gap-2 mb-1">
-            <GitBranch className="h-4 w-4 text-primary" />
-            <span className="text-sm font-medium">{t('contactSidebar.pipeline.current')}</span>
-          </div>
-          <p className="text-xs text-muted-foreground">
-            {currentPipeline.pipeline.name} • {currentPipeline.stage.name}
-          </p>
-        </div>
-      )}
-
-      {/* Pipeline Selection */}
-      <div className="space-y-2">
-        <Label htmlFor="pipeline-select" className="text-xs font-medium">
-          {t('contactSidebar.pipeline.label')}
-        </Label>
-        <Select value={selectedPipelineId} onValueChange={handlePipelineChange}>
-          <SelectTrigger id="pipeline-select">
-            <SelectValue placeholder={t('contactSidebar.pipeline.selectPipeline')} />
-          </SelectTrigger>
-          <SelectContent>
-            {originalPipelines.map(pipeline => (
-              <SelectItem key={pipeline.id} value={String(pipeline.id)}>
-                {pipeline.name}
-              </SelectItem>
-            ))}
-          </SelectContent>
-        </Select>
-      </div>
-
-      {/* Stage Selection */}
-      {selectedPipelineId && (
-        <div className="space-y-2">
-          <Label htmlFor="stage-select" className="text-xs font-medium">
-            {t('contactSidebar.pipeline.stage')}
-          </Label>
-          <Select value={selectedStageId} onValueChange={setSelectedStageId}>
-            <SelectTrigger id="stage-select">
-              <SelectValue placeholder={t('contactSidebar.pipeline.selectStage')} />
-            </SelectTrigger>
-            <SelectContent>
-              {availableStages
-                .sort((a, b) => a.position - b.position)
-                .map(stage => (
-                  <SelectItem key={stage.id} value={String(stage.id)}>
-                    {stage.name}
-                  </SelectItem>
-                ))}
-            </SelectContent>
-          </Select>
-        </div>
-      )}
-
-      {/* Actions */}
-      <div className="flex gap-2">
-        <Button
-          onClick={handleSaveClick}
-          disabled={!selectedPipelineId || !selectedStageId || isSaving}
-          className="flex-1"
-          size="sm"
-        >
-          {isSaving ? (
-            <>
-              <Loader2 className="mr-2 h-4 w-4 animate-spin" />
-              {t('contactSidebar.pipeline.saving')}
-            </>
-          ) : (
-            <>
-              <Save className="mr-2 h-4 w-4" />
-              {t('contactSidebar.pipeline.save')}
-            </>
-          )}
-        </Button>
-        {currentPipeline && (
-          <Button onClick={handleRemoveClick} disabled={isSaving} variant="outline" size="sm">
-            <Trash2 className="h-4 w-4" />
-          </Button>
-        )}
-      </div>
-
-      {/* Save Confirmation Dialog */}
-      <AlertDialog open={showSaveConfirm} onOpenChange={setShowSaveConfirm}>
-        <AlertDialogContent className="max-w-md">
-          <AlertDialogHeader className="text-left space-y-4">
-            <div className="flex items-start gap-4">
-              <div className="flex-shrink-0 w-12 h-12 bg-blue-500/10 rounded-full flex items-center justify-center">
-                <GitBranch className="h-6 w-6 text-blue-500" />
-              </div>
-              <div className="flex-1 space-y-2">
-                <AlertDialogTitle className="text-lg font-semibold">
-                  {currentPipeline
-                    ? t('contactSidebar.pipeline.dialogs.update.title')
-                    : t('contactSidebar.pipeline.dialogs.add.title')}
-                </AlertDialogTitle>
-                <AlertDialogDescription className="text-sm text-muted-foreground leading-relaxed">
-                  {currentPipeline ? (
-                    <>
-                      {(() => {
-                        const stageName =
-                          availableStages.find(s => String(s.id) === selectedStageId)?.name || '';
-                        const parts = t('contactSidebar.pipeline.dialogs.update.description', {
-                          pipelineName: selectedPipeline?.name || '',
-                          stageName: stageName,
-                        }).split(selectedPipeline?.name || '');
-                        const stageParts = parts[1]?.split(stageName) || [];
-                        return (
-                          <>
-                            {parts[0]}
-                            <strong>{selectedPipeline?.name}</strong>
-                            {stageParts[0]}
-                            <strong>{stageName}</strong>
-                            {stageParts[1]}
-                          </>
-                        );
-                      })()}
-                    </>
-                  ) : (
-                    <>
-                      {(() => {
-                        const stageName =
-                          availableStages.find(s => String(s.id) === selectedStageId)?.name || '';
-                        const parts = t('contactSidebar.pipeline.dialogs.add.description', {
-                          pipelineName: selectedPipeline?.name || '',
-                          stageName: stageName,
-                        }).split(selectedPipeline?.name || '');
-                        const stageParts = parts[1]?.split(stageName) || [];
-                        return (
-                          <>
-                            {parts[0]}
-                            <strong>{selectedPipeline?.name}</strong>
-                            {stageParts[0]}
-                            <strong>{stageName}</strong>
-                            {stageParts[1]}
-                          </>
-                        );
-                      })()}
-                    </>
-                  )}
-                </AlertDialogDescription>
-              </div>
-            </div>
-          </AlertDialogHeader>
-
-          <AlertDialogFooter className="flex-col-reverse sm:flex-row gap-3 sm:gap-3">
-            <AlertDialogCancel className="w-full sm:w-auto">
-              {t('contactSidebar.pipeline.dialogs.remove.cancel')}
-            </AlertDialogCancel>
-            <AlertDialogAction
-              onClick={confirmSave}
-              className="w-full sm:w-auto bg-blue-500 text-white hover:bg-blue-600 focus:ring-blue-500"
-            >
-              <Save className="h-4 w-4 mr-2" />
-              {currentPipeline
-                ? t('contactSidebar.pipeline.dialogs.update.confirm')
-                : t('contactSidebar.pipeline.dialogs.add.confirm')}
-            </AlertDialogAction>
-          </AlertDialogFooter>
-        </AlertDialogContent>
-      </AlertDialog>
-
-      {/* Remove Confirmation Dialog */}
-      <AlertDialog open={showRemoveConfirm} onOpenChange={setShowRemoveConfirm}>
-        <AlertDialogContent className="max-w-md">
-          <AlertDialogHeader className="text-left space-y-4">
-            <div className="flex items-start gap-4">
-              <div className="flex-shrink-0 w-12 h-12 bg-destructive/10 rounded-full flex items-center justify-center">
-                <AlertTriangle className="h-6 w-6 text-destructive" />
-              </div>
-              <div className="flex-1 space-y-2">
-                <AlertDialogTitle className="text-lg font-semibold">
-                  {t('contactSidebar.pipeline.dialogs.remove.title')}
-                </AlertDialogTitle>
-                <AlertDialogDescription className="text-sm text-muted-foreground leading-relaxed">
-                  {(() => {
-                    const pipelineName = currentPipeline?.pipeline.name || '';
-                    const description = t('contactSidebar.pipeline.dialogs.remove.description', {
-                      pipelineName: pipelineName,
-                    });
-                    const parts = description.split(pipelineName);
-                    return (
-                      <>
-                        {parts[0]}
-                        <strong>{pipelineName}</strong>
-                        {parts[1]}
-                      </>
-                    );
-                  })()}
-                </AlertDialogDescription>
-              </div>
-            </div>
-          </AlertDialogHeader>
-
-          <AlertDialogFooter className="flex-col-reverse sm:flex-row gap-3 sm:gap-3">
-            <AlertDialogCancel className="w-full sm:w-auto">
-              {t('contactSidebar.pipeline.dialogs.remove.cancel')}
-            </AlertDialogCancel>
-            <AlertDialogAction
-              onClick={confirmRemove}
-              className="w-full sm:w-auto bg-destructive text-destructive-foreground hover:bg-destructive/90 focus:ring-destructive"
-            >
-              <Trash2 className="h-4 w-4 mr-2" />
-              {t('contactSidebar.pipeline.dialogs.remove.confirm')}
-            </AlertDialogAction>
-          </AlertDialogFooter>
-        </AlertDialogContent>
-      </AlertDialog>
-    </div>
-  );
-};
-
-export default PipelineManagement;
diff --git a/src/i18n/locales/en/chat.json b/src/i18n/locales/en/chat.json
index 73b7de74..ae26ba59 100644
--- a/src/i18n/locales/en/chat.json
+++ b/src/i18n/locales/en/chat.json
@@ -456,40 +456,6 @@
         "execute": "Execute Macro"
       }
     },
-    "pipeline": {
-      "loading": "Error loading pipeline data",
-      "noPipelines": "No pipeline configured",
-      "current": "Current Pipeline",
-      "label": "Pipeline",
-      "selectPipeline": "Select a pipeline",
-      "selectStage": "Select a stage",
-      "stage": "Stage",
-      "saving": "Saving...",
-      "save": "Save",
-      "saveSuccess": "Pipeline updated successfully",
-      "saveError": "Error updating pipeline",
-      "selectError": "Select a pipeline and a stage",
-      "removeSuccess": "Conversation removed from pipeline",
-      "removeError": "Error removing from pipeline",
-      "dialogs": {
-        "update": {
-          "title": "Update Pipeline",
-          "description": "Are you sure you want to move this conversation to {{pipelineName}} at stage {{stageName}}?",
-          "confirm": "Update"
-        },
-        "add": {
-          "title": "Add to Pipeline",
-          "description": "Are you sure you want to add this conversation to pipeline {{pipelineName}} at stage {{stageName}}?",
-          "confirm": "Add"
-        },
-        "remove": {
-          "title": "Remove from Pipeline",
-          "description": "Are you sure you want to remove this conversation from pipeline {{pipelineName}}? This action cannot be undone.",
-          "cancel": "Cancel",
-          "confirm": "Remove"
-        }
-      }
-    },
     "filters": {
       "assignee": {
         "title": "Conversation Assignment",
@@ -959,5 +925,19 @@
       "contactsEmpty": "No contacts found",
       "messagesEmpty": "No messages found"
     }
+  },
+  "pipeline": {
+    "section": "Pipeline",
+    "addTo": "Add to pipeline",
+    "removeFrom": "Remove from pipeline",
+    "loading": "Loading pipelines...",
+    "noPipelines": "No pipelines available",
+    "loadError": "Error loading pipelines. Click to retry.",
+    "addSuccess": "Added to pipeline",
+    "moveSuccess": "Moved to stage",
+    "removeSuccess": "Removed from pipeline",
+    "addError": "Error adding to pipeline",
+    "moveError": "Error moving to stage",
+    "removeError": "Error removing from pipeline"
   }
 }
diff --git a/src/i18n/locales/es/chat.json b/src/i18n/locales/es/chat.json
index 6176e6c6..3a84750e 100644
--- a/src/i18n/locales/es/chat.json
+++ b/src/i18n/locales/es/chat.json
@@ -429,40 +429,6 @@
         "execute": "Ejecutar Macro"
       }
     },
-    "pipeline": {
-      "loading": "Error al cargar datos del pipeline",
-      "noPipelines": "No hay pipeline configurado",
-      "current": "Pipeline Actual",
-      "label": "Pipeline",
-      "selectPipeline": "Seleccione un pipeline",
-      "selectStage": "Seleccione una etapa",
-      "stage": "Etapa",
-      "saving": "Guardando...",
-      "save": "Guardar",
-      "saveSuccess": "Pipeline actualizado con éxito",
-      "saveError": "Error al actualizar pipeline",
-      "selectError": "Seleccione un pipeline y una etapa",
-      "removeSuccess": "Conversación eliminada del pipeline",
-      "removeError": "Error al eliminar del pipeline",
-      "dialogs": {
-        "update": {
-          "title": "Actualizar Pipeline",
-          "description": "¿Está seguro de que desea mover esta conversación a {{pipelineName}} en la etapa {{stageName}}?",
-          "confirm": "Actualizar"
-        },
-        "add": {
-          "title": "Agregar al Pipeline",
-          "description": "¿Está seguro de que desea agregar esta conversación al pipeline {{pipelineName}} en la etapa {{stageName}}?",
-          "confirm": "Agregar"
-        },
-        "remove": {
-          "title": "Eliminar del Pipeline",
-          "description": "¿Está seguro de que desea eliminar esta conversación del pipeline {{pipelineName}}? Esta acción no se puede deshacer.",
-          "cancel": "Cancelar",
-          "confirm": "Eliminar"
-        }
-      }
-    },
     "filters": {
       "assignee": {
         "title": "Asignación de Conversación",
@@ -894,5 +860,19 @@
     "success": {
       "sent": "¡Plantilla enviada con éxito!"
     }
+  },
+  "pipeline": {
+    "section": "Pipeline",
+    "addTo": "Agregar al pipeline",
+    "removeFrom": "Quitar del pipeline",
+    "loading": "Cargando pipelines...",
+    "noPipelines": "No hay pipelines disponibles",
+    "loadError": "Error al cargar pipelines. Haz clic para reintentar.",
+    "addSuccess": "Agregado al pipeline",
+    "moveSuccess": "Movido a la etapa",
+    "removeSuccess": "Quitado del pipeline",
+    "addError": "Error al agregar al pipeline",
+    "moveError": "Error al mover a la etapa",
+    "removeError": "Error al quitar del pipeline"
   }
 }
diff --git a/src/i18n/locales/fr/chat.json b/src/i18n/locales/fr/chat.json
index f2201c0c..653c3ec0 100644
--- a/src/i18n/locales/fr/chat.json
+++ b/src/i18n/locales/fr/chat.json
@@ -429,40 +429,6 @@
         "execute": "Exécuter la Macro"
       }
     },
-    "pipeline": {
-      "loading": "Erreur lors du chargement des données du pipeline",
-      "noPipelines": "Aucun pipeline configuré",
-      "current": "Pipeline Actuel",
-      "label": "Pipeline",
-      "selectPipeline": "Sélectionnez un pipeline",
-      "selectStage": "Sélectionnez une étape",
-      "stage": "Étape",
-      "saving": "Enregistrement...",
-      "save": "Enregistrer",
-      "saveSuccess": "Pipeline mis à jour avec succès",
-      "saveError": "Erreur lors de la mise à jour du pipeline",
-      "selectError": "Sélectionnez un pipeline et une étape",
-      "removeSuccess": "Conversation supprimée du pipeline",
-      "removeError": "Erreur lors de la suppression du pipeline",
-      "dialogs": {
-        "update": {
-          "title": "Mettre à jour le Pipeline",
-          "description": "Êtes-vous sûr de vouloir déplacer cette conversation vers {{pipelineName}} à l'étape {{stageName}} ?",
-          "confirm": "Mettre à jour"
-        },
-        "add": {
-          "title": "Ajouter au Pipeline",
-          "description": "Êtes-vous sûr de vouloir ajouter cette conversation au pipeline {{pipelineName}} à l'étape {{stageName}} ?",
-          "confirm": "Ajouter"
-        },
-        "remove": {
-          "title": "Retirer du Pipeline",
-          "description": "Êtes-vous sûr de vouloir retirer cette conversation du pipeline {{pipelineName}} ? Cette action ne peut pas être annulée.",
-          "cancel": "Annuler",
-          "confirm": "Retirer"
-        }
-      }
-    },
     "filters": {
       "assignee": {
         "title": "Attribution de Conversation",
@@ -894,5 +860,19 @@
     "success": {
       "sent": "Modèle envoyé avec succès !"
     }
+  },
+  "pipeline": {
+    "section": "Pipeline",
+    "addTo": "Ajouter au pipeline",
+    "removeFrom": "Retirer du pipeline",
+    "loading": "Chargement des pipelines...",
+    "noPipelines": "Aucun pipeline disponible",
+    "loadError": "Erreur lors du chargement. Cliquez pour réessayer.",
+    "addSuccess": "Ajouté au pipeline",
+    "moveSuccess": "Déplacé vers l'étape",
+    "removeSuccess": "Retiré du pipeline",
+    "addError": "Erreur lors de l'ajout au pipeline",
+    "moveError": "Erreur lors du déplacement vers l'étape",
+    "removeError": "Erreur lors de la suppression du pipeline"
   }
 }
diff --git a/src/i18n/locales/it/chat.json b/src/i18n/locales/it/chat.json
index 0a12eb6f..5dd26f9a 100644
--- a/src/i18n/locales/it/chat.json
+++ b/src/i18n/locales/it/chat.json
@@ -429,40 +429,6 @@
         "execute": "Eseguire Macro"
       }
     },
-    "pipeline": {
-      "loading": "Errore nel caricamento dei dati della pipeline",
-      "noPipelines": "Nessuna pipeline configurata",
-      "current": "Pipeline Attuale",
-      "label": "Pipeline",
-      "selectPipeline": "Seleziona una pipeline",
-      "selectStage": "Seleziona uno stadio",
-      "stage": "Stadio",
-      "saving": "Salvataggio...",
-      "save": "Salva",
-      "saveSuccess": "Pipeline aggiornata con successo",
-      "saveError": "Errore nell'aggiornamento della pipeline",
-      "selectError": "Seleziona una pipeline e uno stadio",
-      "removeSuccess": "Conversazione rimossa dalla pipeline",
-      "removeError": "Errore nella rimozione dalla pipeline",
-      "dialogs": {
-        "update": {
-          "title": "Aggiorna Pipeline",
-          "description": "Sei sicuro di voler spostare questa conversazione a {{pipelineName}} nello stadio {{stageName}}?",
-          "confirm": "Aggiorna"
-        },
-        "add": {
-          "title": "Aggiungi alla Pipeline",
-          "description": "Sei sicuro di voler aggiungere questa conversazione alla pipeline {{pipelineName}} nello stadio {{stageName}}?",
-          "confirm": "Aggiungi"
-        },
-        "remove": {
-          "title": "Rimuovi dalla Pipeline",
-          "description": "Sei sicuro di voler rimuovere questa conversazione dalla pipeline {{pipelineName}}? Questa azione non può essere annullata.",
-          "cancel": "Annulla",
-          "confirm": "Rimuovi"
-        }
-      }
-    },
     "filters": {
       "assignee": {
         "title": "Assegnazione Conversazione",
@@ -894,5 +860,19 @@
     "success": {
       "sent": "Modello inviato con successo!"
     }
+  },
+  "pipeline": {
+    "section": "Pipeline",
+    "addTo": "Aggiungi al pipeline",
+    "removeFrom": "Rimuovi dal pipeline",
+    "loading": "Caricamento pipeline...",
+    "noPipelines": "Nessun pipeline disponibile",
+    "loadError": "Errore nel caricamento. Clicca per riprovare.",
+    "addSuccess": "Aggiunto al pipeline",
+    "moveSuccess": "Spostato nella fase",
+    "removeSuccess": "Rimosso dal pipeline",
+    "addError": "Errore nell'aggiunta al pipeline",
+    "moveError": "Errore nello spostamento nella fase",
+    "removeError": "Errore nella rimozione dal pipeline"
   }
 }
diff --git a/src/i18n/locales/pt-BR/chat.json b/src/i18n/locales/pt-BR/chat.json
index b66341f1..84b7550b 100644
--- a/src/i18n/locales/pt-BR/chat.json
+++ b/src/i18n/locales/pt-BR/chat.json
@@ -456,40 +456,6 @@
         "execute": "Executar Macro"
       }
     },
-    "pipeline": {
-      "loading": "Erro ao carregar dados do pipeline",
-      "noPipelines": "Nenhum pipeline configurado",
-      "current": "Pipeline Atual",
-      "label": "Pipeline",
-      "selectPipeline": "Selecione um pipeline",
-      "selectStage": "Selecione um estágio",
-      "stage": "Estágio",
-      "saving": "Salvando...",
-      "save": "Salvar",
-      "saveSuccess": "Pipeline atualizado com sucesso",
-      "saveError": "Erro ao atualizar pipeline",
-      "selectError": "Selecione um pipeline e um estágio",
-      "removeSuccess": "Conversa removida do pipeline",
-      "removeError": "Erro ao remover do pipeline",
-      "dialogs": {
-        "update": {
-          "title": "Atualizar Pipeline",
-          "description": "Você tem certeza que deseja mover esta conversa para {{pipelineName}} no estágio {{stageName}}?",
-          "confirm": "Atualizar"
-        },
-        "add": {
-          "title": "Adicionar ao Pipeline",
-          "description": "Você tem certeza que deseja adicionar esta conversa ao pipeline {{pipelineName}} no estágio {{stageName}}?",
-          "confirm": "Adicionar"
-        },
-        "remove": {
-          "title": "Remover do Pipeline",
-          "description": "Você tem certeza que deseja remover esta conversa do pipeline {{pipelineName}}? Esta ação não pode ser desfeita.",
-          "cancel": "Cancelar",
-          "confirm": "Remover"
-        }
-      }
-    },
     "filters": {
       "assignee": {
         "title": "Atribuição de Conversa",
@@ -965,5 +931,19 @@
       "contactsEmpty": "Nenhum contato encontrado",
       "messagesEmpty": "Nenhuma mensagem encontrada"
     }
+  },
+  "pipeline": {
+    "section": "Pipeline",
+    "addTo": "Adicionar ao pipeline",
+    "removeFrom": "Remover do pipeline",
+    "loading": "Carregando pipelines...",
+    "noPipelines": "Nenhum pipeline disponível",
+    "loadError": "Erro ao carregar pipelines. Clique para tentar novamente.",
+    "addSuccess": "Adicionado ao pipeline",
+    "moveSuccess": "Movido para o estágio",
+    "removeSuccess": "Removido do pipeline",
+    "addError": "Erro ao adicionar ao pipeline",
+    "moveError": "Erro ao mover para o estágio",
+    "removeError": "Erro ao remover do pipeline"
   }
-}
\ No newline at end of file
+}
diff --git a/src/i18n/locales/pt/chat.json b/src/i18n/locales/pt/chat.json
index 5fd18c35..973eb809 100644
--- a/src/i18n/locales/pt/chat.json
+++ b/src/i18n/locales/pt/chat.json
@@ -429,40 +429,6 @@
         "execute": "Executar Macro"
       }
     },
-    "pipeline": {
-      "loading": "Erro ao carregar dados do pipeline",
-      "noPipelines": "Nenhum pipeline configurado",
-      "current": "Pipeline Atual",
-      "label": "Pipeline",
-      "selectPipeline": "Selecione um pipeline",
-      "selectStage": "Selecione um estágio",
-      "stage": "Estágio",
-      "saving": "Salvando...",
-      "save": "Salvar",
-      "saveSuccess": "Pipeline atualizado com sucesso",
-      "saveError": "Erro ao atualizar pipeline",
-      "selectError": "Selecione um pipeline e um estágio",
-      "removeSuccess": "Conversa removida do pipeline",
-      "removeError": "Erro ao remover do pipeline",
-      "dialogs": {
-        "update": {
-          "title": "Atualizar Pipeline",
-          "description": "Você tem certeza que deseja mover esta conversa para {{pipelineName}} no estágio {{stageName}}?",
-          "confirm": "Atualizar"
-        },
-        "add": {
-          "title": "Adicionar ao Pipeline",
-          "description": "Você tem certeza que deseja adicionar esta conversa ao pipeline {{pipelineName}} no estágio {{stageName}}?",
-          "confirm": "Adicionar"
-        },
-        "remove": {
-          "title": "Remover do Pipeline",
-          "description": "Você tem certeza que deseja remover esta conversa do pipeline {{pipelineName}}? Esta ação não pode ser desfeita.",
-          "cancel": "Cancelar",
-          "confirm": "Remover"
-        }
-      }
-    },
     "filters": {
       "assignee": {
         "title": "Atribuição de Conversa",
@@ -900,5 +866,19 @@
     "success": {
       "sent": "Template enviado com sucesso!"
     }
+  },
+  "pipeline": {
+    "section": "Pipeline",
+    "addTo": "Adicionar ao pipeline",
+    "removeFrom": "Remover do pipeline",
+    "loading": "Carregando pipelines...",
+    "noPipelines": "Nenhum pipeline disponível",
+    "loadError": "Erro ao carregar pipelines. Clique para tentar novamente.",
+    "addSuccess": "Adicionado ao pipeline",
+    "moveSuccess": "Movido para o estágio",
+    "removeSuccess": "Removido do pipeline",
+    "addError": "Erro ao adicionar ao pipeline",
+    "moveError": "Erro ao mover para o estágio",
+    "removeError": "Erro ao remover do pipeline"
   }
 }