diff --git a/src/renderer/components/ChatInterface.tsx b/src/renderer/components/ChatInterface.tsx
index 220c15a51..65f6e04eb 100644
--- a/src/renderer/components/ChatInterface.tsx
+++ b/src/renderer/components/ChatInterface.tsx
@@ -1,5 +1,5 @@
 import React, { useEffect, useState, useMemo, useCallback, useRef } from 'react';
-import { Plus, X } from 'lucide-react';
+import { PinOff, Plus, X } from 'lucide-react';
 import { useToast } from '../hooks/use-toast';
 import { useTheme } from '../hooks/useTheme';
 import { TerminalPane, type TerminalPaneHandle } from './TerminalPane';
@@ -62,6 +62,9 @@ interface Props {
   onRenameTask?: (project: Project, task: Task, newName: string) => Promise<void>;
 }
 
+// Cross-panel signal emitted from TaskTerminalPanel when a pinned terminal is selected.
+const FOCUS_PINNED_TERMINAL_EVENT = 'emdash:focus-pinned-terminal';
+
 function ConversationTabButton({
   conversation,
   activeConversationId,
@@ -142,13 +145,64 @@ function ConversationTabButton({
   );
 }
 
+function PinnedTerminalTabButton({
+  label,
+  isActive,
+  onClick,
+  onUnpin,
+}: {
+  label: string;
+  isActive: boolean;
+  onClick: () => void;
+  onUnpin: () => void;
+}) {
+  return (
+    <button
+      onClick={onClick}
+      aria-current={isActive ? 'page' : undefined}
+      className={cn(
+        'inline-flex h-7 flex-shrink-0 items-center gap-1.5 rounded-md border border-border px-2.5 text-xs font-medium transition-colors',
+        'ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2',
+        isActive
+          ? 'bg-background text-foreground shadow-sm'
+          : 'bg-muted text-muted-foreground hover:bg-muted/80 hover:text-foreground'
+      )}
+      title={label}
+    >
+      <span className="inline-flex w-3.5 flex-shrink-0 justify-center text-[10px] leading-none text-muted-foreground/90">
+        {'>_'}
+      </span>
+      <span className="max-w-[10rem] truncate">{label}</span>
+      <span
+        role="button"
+        tabIndex={0}
+        onClick={(e) => {
+          e.stopPropagation();
+          onUnpin();
+        }}
+        onKeyDown={(e) => {
+          if (e.key === 'Enter' || e.key === ' ') {
+            e.preventDefault();
+            e.stopPropagation();
+            onUnpin();
+          }
+        }}
+        className="ml-1 rounded hover:bg-background/20"
+        title="Unpin terminal"
+      >
+        <PinOff className="h-3 w-3" />
+      </span>
+    </button>
+  );
+}
+
 const ChatInterface: React.FC<Props> = ({
   task,
   project,
   projectName: _projectName,
   projectPath,
   projectRemoteConnectionId,
-  projectRemotePath: _projectRemotePath,
+  projectRemotePath,
   defaultBranch,
   className,
   initialAgent,
@@ -175,6 +229,7 @@ const ChatInterface: React.FC<Props> = ({
   const [conversationsLoaded, setConversationsLoaded] = useState(false);
   const [showCreateChatModal, setShowCreateChatModal] = useState(false);
   const [busyByConversationId, setBusyByConversationId] = useState<Record<string, boolean>>({});
+  const [activePinnedTerminalKey, setActivePinnedTerminalKey] = useState<string | null>(null);
   const lockedAgentWriteRef = useRef<string | null>(null);
   const tabsContainerRef = useRef<HTMLDivElement>(null);
   const [tabsOverflow, setTabsOverflow] = useState(false);
@@ -285,8 +340,65 @@ const ChatInterface: React.FC<Props> = ({
       }),
     [conversations]
   );
-
   const { activeTerminalId } = useTaskTerminals(task.id, task.path);
+  const sidebarTaskKey = `${task.id}::${task.path}`;
+  const sidebarTaskTerminals = useTaskTerminals(sidebarTaskKey, task.path);
+  const sidebarGlobalKey = task.path
+    ? `global::${task.path}`
+    : projectPath
+      ? `global::${projectPath}`
+      : 'global::home';
+  const sidebarGlobalTerminals = useTaskTerminals(sidebarGlobalKey, projectPath || undefined);
+  const pinnedTerminals = useMemo(() => {
+    const taskPins = sidebarTaskTerminals.terminals
+      .filter((terminal) => terminal.pinned)
+      .map((terminal) => ({
+        key: `task::${terminal.id}`,
+        terminalId: terminal.id,
+        tabLabel: `${terminal.title} (worktree)`,
+        cwd: terminal.cwd,
+        scope: 'task' as const,
+      }));
+    const globalPins = sidebarGlobalTerminals.terminals
+      .filter((terminal) => terminal.pinned)
+      .map((terminal) => ({
+        key: `global::${terminal.id}`,
+        terminalId: terminal.id,
+        tabLabel: `${terminal.title} (project)`,
+        cwd: terminal.cwd,
+        scope: 'global' as const,
+      }));
+    return [...taskPins, ...globalPins];
+  }, [sidebarTaskTerminals.terminals, sidebarGlobalTerminals.terminals]);
+  const activePinnedTerminal = useMemo(
+    () => pinnedTerminals.find((terminal) => terminal.key === activePinnedTerminalKey) ?? null,
+    [pinnedTerminals, activePinnedTerminalKey]
+  );
+  const numberedTabs = useMemo(
+    () => [
+      ...sortedConversations.map((conversation) => ({
+        type: 'conversation' as const,
+        conversationId: conversation.id,
+      })),
+      ...pinnedTerminals.map((terminal) => ({
+        type: 'pinned' as const,
+        terminalKey: terminal.key,
+      })),
+    ],
+    [sortedConversations, pinnedTerminals]
+  );
+  const effectiveRemoteProjectPath = useMemo(
+    () => workspaceRemotePath || projectRemotePath || undefined,
+    [workspaceRemotePath, projectRemotePath]
+  );
+  const activeTerminalPaneId = activePinnedTerminal?.terminalId ?? terminalId;
+  const activeTerminalPaneCwd = useMemo(() => {
+    if (!activePinnedTerminal) return effectiveCwd;
+    if (activePinnedTerminal.scope === 'task') {
+      return effectiveRemoteProjectPath || activePinnedTerminal.cwd || task.path;
+    }
+    return activePinnedTerminal.cwd || projectPath || task.path;
+  }, [activePinnedTerminal, effectiveCwd, effectiveRemoteProjectPath, task.path, projectPath]);
 
   // Wire comment injection to pendingInjectionManager
   useCommentInjection(task.id, task.path);
@@ -312,6 +424,12 @@ const ChatInterface: React.FC<Props> = ({
     onTaskInterfaceReady();
   }, [task.id, onTaskInterfaceReady]);
 
+  useEffect(() => {
+    if (!activePinnedTerminalKey) return;
+    if (pinnedTerminals.some((terminal) => terminal.key === activePinnedTerminalKey)) return;
+    setActivePinnedTerminalKey(null);
+  }, [activePinnedTerminalKey, pinnedTerminals]);
+
   const syncConversations = useCallback(async () => {
     setConversationsLoaded(false);
     const loadedConversations = await rpc.db.getConversations(task.id);
@@ -472,7 +590,7 @@ const ChatInterface: React.FC<Props> = ({
     handleSearchQueryChange,
     stepSearch,
   } = useTerminalSearch({
-    terminalId,
+    terminalId: activeTerminalPaneId,
     containerRef: terminalPanelRef,
     enabled: true,
     onCloseFocus: () => terminalRef.current?.focus(),
@@ -495,13 +613,13 @@ const ChatInterface: React.FC<Props> = ({
     if (!conversationsLoaded) return;
     // Small delay to ensure terminal is mounted and attached
     const timer = setTimeout(() => {
-      const session = terminalSessionRegistry.getSession(terminalId);
+      const session = terminalSessionRegistry.getSession(activeTerminalPaneId);
       if (session) {
         session.focus();
       }
     }, 100);
     return () => clearTimeout(timer);
-  }, [task.id, terminalId, conversationsLoaded]);
+  }, [task.id, activeTerminalPaneId, conversationsLoaded]);
 
   // Focus terminal when this task becomes active (for already-mounted terminals)
   useEffect(() => {
@@ -519,7 +637,7 @@ const ChatInterface: React.FC<Props> = ({
       timer = setTimeout(() => {
         timer = null;
         if (!mounted) return;
-        const session = terminalSessionRegistry.getSession(terminalId);
+        const session = terminalSessionRegistry.getSession(activeTerminalPaneId);
         if (session) session.focus();
       }, 0);
     };
@@ -529,9 +647,10 @@ const ChatInterface: React.FC<Props> = ({
       if (timer !== null) clearTimeout(timer);
       window.removeEventListener('focus', handleWindowFocus);
     };
-  }, [terminalId]);
+  }, [activeTerminalPaneId]);
 
   useEffect(() => {
+    if (activePinnedTerminal) return;
     const meta = agentMeta[agent];
     if (!meta?.terminalOnly || !meta.autoStartCommand) return;
 
@@ -568,7 +687,7 @@ const ChatInterface: React.FC<Props> = ({
       } catch {}
       clearTimeout(t);
     };
-  }, [agent, terminalId]);
+  }, [agent, terminalId, activePinnedTerminal]);
 
   useEffect(() => {
     setCliStartError(null);
@@ -709,6 +828,7 @@ const ChatInterface: React.FC<Props> = ({
         conversationId,
       });
       setActiveConversationId(conversationId);
+      setActivePinnedTerminalKey(null);
 
       // Update provider based on conversation
       const conv = conversations.find((c) => c.id === conversationId);
@@ -719,6 +839,54 @@ const ChatInterface: React.FC<Props> = ({
     [task.id, conversations]
   );
 
+  const handleSelectPinnedTerminal = useCallback(
+    (terminalKey: string) => {
+      const current = pinnedTerminals.find((terminal) => terminal.key === terminalKey);
+      if (!current) return;
+      if (activePinnedTerminalKey === terminalKey) {
+        terminalSessionRegistry.getSession(current.terminalId)?.focus();
+        return;
+      }
+      setActivePinnedTerminalKey(terminalKey);
+    },
+    [activePinnedTerminalKey, pinnedTerminals]
+  );
+
+  const handleUnpinPinnedTerminal = useCallback(
+    (terminalKey: string) => {
+      const terminal = pinnedTerminals.find((item) => item.key === terminalKey);
+      if (!terminal) return;
+      if (terminal.scope === 'task') {
+        sidebarTaskTerminals.setPinned(terminal.terminalId, false);
+      } else {
+        sidebarGlobalTerminals.setPinned(terminal.terminalId, false);
+      }
+      if (activePinnedTerminalKey === terminalKey) {
+        setActivePinnedTerminalKey(null);
+      }
+    },
+    [pinnedTerminals, sidebarTaskTerminals, sidebarGlobalTerminals, activePinnedTerminalKey]
+  );
+
+  useEffect(() => {
+    const onFocusPinned = (event: Event) => {
+      const detail = (
+        event as CustomEvent<{
+          taskId?: string | null;
+          scope?: 'task' | 'global';
+          terminalId?: string;
+        }>
+      ).detail;
+      if (!detail?.terminalId || !detail.scope) return;
+      if (detail.taskId !== task.id) return;
+      handleSelectPinnedTerminal(`${detail.scope}::${detail.terminalId}`);
+    };
+
+    window.addEventListener(FOCUS_PINNED_TERMINAL_EVENT, onFocusPinned as EventListener);
+    return () =>
+      window.removeEventListener(FOCUS_PINNED_TERMINAL_EVENT, onFocusPinned as EventListener);
+  }, [task.id, handleSelectPinnedTerminal]);
+
   const handleCloseChat = useCallback(
     async (conversationId: string) => {
       if (conversations.length <= 1) {
@@ -905,19 +1073,24 @@ const ChatInterface: React.FC<Props> = ({
       const customEvent = event as CustomEvent<{ tabIndex: number }>;
       const tabIndex = customEvent.detail?.tabIndex;
       if (typeof tabIndex !== 'number') return;
-      if (tabIndex < 0 || tabIndex >= sortedConversations.length) return;
+      if (tabIndex < 0 || tabIndex >= numberedTabs.length) return;
 
-      const selectedConversation = sortedConversations[tabIndex];
-      if (selectedConversation) {
-        handleSwitchChat(selectedConversation.id);
+      const selectedTab = numberedTabs[tabIndex];
+      if (!selectedTab) return;
+
+      if (selectedTab.type === 'conversation') {
+        handleSwitchChat(selectedTab.conversationId);
+        return;
       }
+
+      handleSelectPinnedTerminal(selectedTab.terminalKey);
     };
 
     window.addEventListener('emdash:select-agent-tab', handleAgentTabSelection);
     return () => {
       window.removeEventListener('emdash:select-agent-tab', handleAgentTabSelection);
     };
-  }, [sortedConversations, handleSwitchChat]);
+  }, [numberedTabs, handleSwitchChat, handleSelectPinnedTerminal]);
 
   // Close active chat tab on Cmd+W
   useEffect(() => {
@@ -1178,7 +1351,7 @@ const ChatInterface: React.FC<Props> = ({
                       <ConversationTabButton
                         key={conv.id}
                         conversation={conv}
-                        activeConversationId={activeConversationId}
+                        activeConversationId={activePinnedTerminal ? null : activeConversationId}
                         onSwitchChat={handleSwitchChat}
                         onCloseChat={handleCloseChat}
                         totalConversationCount={conversations.length}
@@ -1187,6 +1360,15 @@ const ChatInterface: React.FC<Props> = ({
                       />
                     );
                   })}
+                  {pinnedTerminals.map((terminal) => (
+                    <PinnedTerminalTabButton
+                      key={terminal.key}
+                      label={terminal.tabLabel}
+                      isActive={activePinnedTerminal?.key === terminal.key}
+                      onClick={() => handleSelectPinnedTerminal(terminal.key)}
+                      onUnpin={() => handleUnpinPinnedTerminal(terminal.key)}
+                    />
+                  ))}
                 </div>
                 <button
                   onClick={handleCreateNewChat}
@@ -1213,34 +1395,35 @@ const ChatInterface: React.FC<Props> = ({
                   )}
                 </div>
               </div>
-              {(() => {
-                if (isAgentInstalled === false) {
-                  return (
-                    <InstallBanner
-                      agent={agent as any}
-                      terminalId={terminalId}
-                      installCommand={getInstallCommandForProvider(agent as any)}
-                      onRunInstall={runInstallCommand}
-                      onOpenExternal={(url) => window.electronAPI.openExternal(url)}
-                      mode="missing"
-                    />
-                  );
-                }
-                if (cliStartError) {
-                  return (
-                    <InstallBanner
-                      agent={agent as any}
-                      terminalId={terminalId}
-                      installCommand={null}
-                      onRunInstall={runInstallCommand}
-                      onOpenExternal={(url) => window.electronAPI.openExternal(url)}
-                      mode="start_failed"
-                      details={cliStartError}
-                    />
-                  );
-                }
-                return null;
-              })()}
+              {!activePinnedTerminal &&
+                (() => {
+                  if (isAgentInstalled === false) {
+                    return (
+                      <InstallBanner
+                        agent={agent as any}
+                        terminalId={terminalId}
+                        installCommand={getInstallCommandForProvider(agent as any)}
+                        onRunInstall={runInstallCommand}
+                        onOpenExternal={(url) => window.electronAPI.openExternal(url)}
+                        mode="missing"
+                      />
+                    );
+                  }
+                  if (cliStartError) {
+                    return (
+                      <InstallBanner
+                        agent={agent as any}
+                        terminalId={terminalId}
+                        installCommand={null}
+                        onRunInstall={runInstallCommand}
+                        onOpenExternal={(url) => window.electronAPI.openExternal(url)}
+                        mode="start_failed"
+                        details={cliStartError}
+                      />
+                    );
+                  }
+                  return null;
+                })()}
             </div>
           </div>
           <div
@@ -1281,20 +1464,25 @@ const ChatInterface: React.FC<Props> = ({
               {conversationsLoaded && (!isWorkspaceTask || workspaceConnectionId) && (
                 <TerminalPane
                   ref={terminalRef}
-                  id={terminalId}
-                  cwd={effectiveCwd}
+                  id={activeTerminalPaneId}
+                  cwd={activeTerminalPaneCwd}
                   remote={effectiveRemote}
-                  providerId={agent}
-                  autoApprove={autoApproveEnabled}
-                  env={taskEnv}
+                  providerId={activePinnedTerminal ? undefined : agent}
+                  autoApprove={activePinnedTerminal ? undefined : autoApproveEnabled}
+                  env={activePinnedTerminal ? undefined : taskEnv}
                   keepAlive={true}
                   mapShiftEnterToCtrlJ
                   disableSnapshots={false}
-                  onActivity={handleTerminalActivity}
-                  onStartError={(message) => {
-                    setCliStartError(message);
-                  }}
+                  onActivity={activePinnedTerminal ? undefined : handleTerminalActivity}
+                  onStartError={
+                    activePinnedTerminal
+                      ? undefined
+                      : (message) => {
+                          setCliStartError(message);
+                        }
+                  }
                   onStartSuccess={() => {
+                    if (activePinnedTerminal) return;
                     setCliStartError(null);
                     if (
                       isMainConversation &&
@@ -1355,6 +1543,7 @@ const ChatInterface: React.FC<Props> = ({
                       : undefined
                   }
                   initialPrompt={
+                    !activePinnedTerminal &&
                     agentMeta[agent]?.initialPromptFlag !== undefined &&
                     !agentMeta[agent]?.useKeystrokeInjection &&
                     ((isMainConversation && !task.metadata?.initialInjectionSent) ||
@@ -1364,7 +1553,13 @@ const ChatInterface: React.FC<Props> = ({
                         : (reviewPrompt ?? undefined)
                       : undefined
                   }
-                  onFirstMessage={shouldCaptureFirstMessage ? handleFirstMessage : undefined}
+                  onFirstMessage={
+                    activePinnedTerminal
+                      ? undefined
+                      : shouldCaptureFirstMessage
+                        ? handleFirstMessage
+                        : undefined
+                  }
                   className="h-full w-full"
                 />
               )}
diff --git a/src/renderer/components/TaskTerminalPanel.tsx b/src/renderer/components/TaskTerminalPanel.tsx
index cf673594c..7b5607bab 100644
--- a/src/renderer/components/TaskTerminalPanel.tsx
+++ b/src/renderer/components/TaskTerminalPanel.tsx
@@ -1,10 +1,10 @@
 import React, { useMemo, useState, useEffect, useCallback, useRef } from 'react';
 import { TerminalPane } from './TerminalPane';
 import { LifecycleTerminalView } from './LifecycleTerminalView';
-import { Plus, Play, RotateCw, Square, X, Maximize2 } from 'lucide-react';
+import { Plus, Play, RotateCw, Square, X, Maximize2, Pin, PinOff } from 'lucide-react';
 import { useTheme } from '../hooks/useTheme';
 import { useTaskTerminals } from '@/lib/taskTerminalsStore';
-import { useTerminalSelection } from '../hooks/useTerminalSelection';
+import { parseTerminalValue, useTerminalSelection } from '../hooks/useTerminalSelection';
 import { cn } from '@/lib/utils';
 import { TooltipProvider, Tooltip, TooltipTrigger, TooltipContent } from './ui/tooltip';
 import { Button } from './ui/button';
@@ -55,6 +55,8 @@ interface Props {
 }
 
 type LifecyclePhaseStatus = 'idle' | 'running' | 'succeeded' | 'failed';
+// Cross-panel signal used to activate a pinned terminal tab in ChatInterface.
+const FOCUS_PINNED_TERMINAL_EVENT = 'emdash:focus-pinned-terminal';
 
 const TaskTerminalPanelComponent: React.FC<Props> = ({
   task,
@@ -84,6 +86,22 @@ const TaskTerminalPanelComponent: React.FC<Props> = ({
   const globalTerminals = useTaskTerminals(globalKey, effectiveCwd);
 
   const selection = useTerminalSelection({ task, taskTerminals, globalTerminals });
+  const pinnedTaskTerminalIds = useMemo(
+    () => new Set(taskTerminals.terminals.filter((terminal) => terminal.pinned).map((t) => t.id)),
+    [taskTerminals.terminals]
+  );
+  const pinnedGlobalTerminalIds = useMemo(
+    () => new Set(globalTerminals.terminals.filter((terminal) => terminal.pinned).map((t) => t.id)),
+    [globalTerminals.terminals]
+  );
+  const visibleTaskTerminals = useMemo(
+    () => taskTerminals.terminals.filter((terminal) => !terminal.pinned),
+    [taskTerminals.terminals]
+  );
+  const visibleGlobalTerminals = useMemo(
+    () => globalTerminals.terminals.filter((terminal) => !terminal.pinned),
+    [globalTerminals.terminals]
+  );
 
   const [expandedTerminalId, setExpandedTerminalId] = useState<string | null>(null);
   // Tracks which terminal needs a key bump to force re-attach after modal close
@@ -259,7 +277,74 @@ const TaskTerminalPanelComponent: React.FC<Props> = ({
     }
   }, [runStatus, selection.onChange]);
 
-  const totalTerminals = taskTerminals.terminals.length + globalTerminals.terminals.length;
+  const totalTerminals = visibleTaskTerminals.length + visibleGlobalTerminals.length;
+  // Ignore the next Select onValueChange emitted from the same interaction
+  // used to click a row-level pin button.
+  const pinButtonClickedRef = useRef(false);
+
+  const handleSelectionChange = useCallback(
+    (value: string) => {
+      if (pinButtonClickedRef.current) {
+        pinButtonClickedRef.current = false;
+        return;
+      }
+      const parsed = parseTerminalValue(value);
+      if (!parsed) return;
+      if (parsed.mode === 'task' && pinnedTaskTerminalIds.has(parsed.id)) {
+        window.dispatchEvent(
+          new CustomEvent(FOCUS_PINNED_TERMINAL_EVENT, {
+            detail: {
+              taskId: task?.id ?? null,
+              scope: 'task',
+              terminalId: parsed.id,
+            },
+          })
+        );
+        selection.setIsOpen(false);
+        return;
+      }
+      if (parsed.mode === 'global' && pinnedGlobalTerminalIds.has(parsed.id)) {
+        window.dispatchEvent(
+          new CustomEvent(FOCUS_PINNED_TERMINAL_EVENT, {
+            detail: {
+              taskId: task?.id ?? null,
+              scope: 'global',
+              terminalId: parsed.id,
+            },
+          })
+        );
+        selection.setIsOpen(false);
+        return;
+      }
+      selection.onChange(value);
+    },
+    [selection, pinnedTaskTerminalIds, pinnedGlobalTerminalIds, task?.id]
+  );
+
+  const handleTogglePinned = useCallback(
+    (mode: 'task' | 'global', terminalId: string) => {
+      const store = mode === 'task' ? taskTerminals : globalTerminals;
+      store.togglePinned(terminalId);
+
+      const selected = selection.parsed;
+      if (selected?.mode === mode && selected.id === terminalId) {
+        const fallback =
+          mode === 'task'
+            ? visibleTaskTerminals.find((terminal) => terminal.id !== terminalId)
+            : visibleGlobalTerminals.find((terminal) => terminal.id !== terminalId);
+        if (fallback) {
+          selection.onChange(`${mode}::${fallback.id}`);
+          return;
+        }
+        if (mode === 'task' && visibleGlobalTerminals.length > 0) {
+          selection.onChange(`global::${visibleGlobalTerminals[0].id}`);
+        } else if (mode === 'global' && visibleTaskTerminals.length > 0) {
+          selection.onChange(`task::${visibleTaskTerminals[0].id}`);
+        }
+      }
+    },
+    [taskTerminals, globalTerminals, selection, visibleTaskTerminals, visibleGlobalTerminals]
+  );
 
   const lifecycleLogContent = useMemo(() => {
     if (!selection.selectedLifecycle) return '';
@@ -268,6 +353,13 @@ const TaskTerminalPanelComponent: React.FC<Props> = ({
   }, [lifecycleLogs, selection.selectedLifecycle]);
 
   const hasActiveTerminal = !selection.selectedLifecycle && !!selection.activeTerminalId;
+  const selectedPinnedTerminal = useMemo(() => {
+    const selected = selection.parsed;
+    if (!selected) return false;
+    if (selected.mode === 'task') return pinnedTaskTerminalIds.has(selected.id);
+    if (selected.mode === 'global') return pinnedGlobalTerminalIds.has(selected.id);
+    return false;
+  }, [selection.parsed, pinnedTaskTerminalIds, pinnedGlobalTerminalIds]);
 
   const canStartRun =
     !!task &&
@@ -501,7 +593,7 @@ const TaskTerminalPanelComponent: React.FC<Props> = ({
       <div className="flex items-center gap-2 border-b border-border bg-muted px-2 py-1.5 dark:bg-background">
         <Select
           value={selection.value}
-          onValueChange={selection.onChange}
+          onValueChange={handleSelectionChange}
           open={selection.isOpen}
           onOpenChange={selection.setIsOpen}
         >
@@ -541,6 +633,33 @@ const TaskTerminalPanelComponent: React.FC<Props> = ({
                     key={`task::${terminal.id}`}
                     value={`task::${terminal.id}`}
                     className="text-xs"
+                    action={
+                      <button
+                        type="button"
+                        className="flex h-3.5 w-3.5 items-center justify-center rounded-sm text-muted-foreground hover:bg-accent hover:text-accent-foreground"
+                        onPointerDown={(e) => {
+                          e.preventDefault();
+                          e.stopPropagation();
+                          pinButtonClickedRef.current = true;
+                          handleTogglePinned('task', terminal.id);
+                        }}
+                        onClick={(e) => {
+                          e.preventDefault();
+                          e.stopPropagation();
+                        }}
+                        title={
+                          terminal.pinned
+                            ? 'Unpin terminal from main panel'
+                            : 'Pin terminal to main panel'
+                        }
+                      >
+                        {terminal.pinned ? (
+                          <PinOff className="h-3 w-3" />
+                        ) : (
+                          <Pin className="h-3 w-3" />
+                        )}
+                      </button>
+                    }
                   >
                     {terminal.title}
                   </SelectItem>
@@ -579,6 +698,33 @@ const TaskTerminalPanelComponent: React.FC<Props> = ({
                     key={`global::${terminal.id}`}
                     value={`global::${terminal.id}`}
                     className="text-xs"
+                    action={
+                      <button
+                        type="button"
+                        className="flex h-3.5 w-3.5 items-center justify-center rounded-sm text-muted-foreground hover:bg-accent hover:text-accent-foreground"
+                        onPointerDown={(e) => {
+                          e.preventDefault();
+                          e.stopPropagation();
+                          pinButtonClickedRef.current = true;
+                          handleTogglePinned('global', terminal.id);
+                        }}
+                        onClick={(e) => {
+                          e.preventDefault();
+                          e.stopPropagation();
+                        }}
+                        title={
+                          terminal.pinned
+                            ? 'Unpin terminal from main panel'
+                            : 'Pin terminal to main panel'
+                        }
+                      >
+                        {terminal.pinned ? (
+                          <PinOff className="h-3 w-3" />
+                        ) : (
+                          <Pin className="h-3 w-3" />
+                        )}
+                      </button>
+                    }
                   >
                     {terminal.title}
                   </SelectItem>
@@ -688,9 +834,9 @@ const TaskTerminalPanelComponent: React.FC<Props> = ({
         {(() => {
           const canDelete =
             selection.parsed?.mode === 'task'
-              ? taskTerminals.terminals.length > 1
+              ? visibleTaskTerminals.length > 1
               : selection.parsed?.mode === 'global'
-                ? globalTerminals.terminals.length > 1
+                ? visibleGlobalTerminals.length > 1
                 : false;
           return (
             <TooltipProvider delayDuration={200}>
@@ -777,7 +923,7 @@ const TaskTerminalPanelComponent: React.FC<Props> = ({
           ) : (
             <>
               {task &&
-                taskTerminals.terminals.map((terminal) => {
+                visibleTaskTerminals.map((terminal) => {
                   const isActive =
                     selection.parsed?.mode === 'task' && terminal.id === selection.activeTerminalId;
                   return (
@@ -809,7 +955,7 @@ const TaskTerminalPanelComponent: React.FC<Props> = ({
                     </div>
                   );
                 })}
-              {globalTerminals.terminals.map((terminal) => {
+              {visibleGlobalTerminals.map((terminal) => {
                 const isActive =
                   selection.parsed?.mode === 'global' && terminal.id === selection.activeTerminalId;
                 return (
@@ -842,7 +988,7 @@ const TaskTerminalPanelComponent: React.FC<Props> = ({
               })}
               {totalTerminals === 0 ? (
                 <div className="flex h-full flex-col items-center justify-center text-xs text-muted-foreground">
-                  <p>No terminal found.</p>
+                  <p>{selectedPinnedTerminal ? 'Terminal pinned.' : 'No terminal found.'}</p>
                 </div>
               ) : null}
             </>
diff --git a/src/renderer/components/ui/select.tsx b/src/renderer/components/ui/select.tsx
index c598a5a24..8976ea4bd 100644
--- a/src/renderer/components/ui/select.tsx
+++ b/src/renderer/components/ui/select.tsx
@@ -102,26 +102,31 @@ const SelectLabel = React.forwardRef<
 ));
 SelectLabel.displayName = SelectPrimitive.Label.displayName;
 
-const SelectItem = React.forwardRef<
-  React.ElementRef<typeof SelectPrimitive.Item>,
-  React.ComponentPropsWithoutRef<typeof SelectPrimitive.Item>
->(({ className, children, ...props }, ref) => (
-  <SelectPrimitive.Item
-    ref={ref}
-    className={cn(
-      'relative flex w-full cursor-pointer select-none items-center rounded-sm py-1.5 pl-2 pr-8 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50',
-      className
-    )}
-    {...props}
-  >
-    <span className="absolute right-2 flex h-3.5 w-3.5 items-center justify-center">
-      <SelectPrimitive.ItemIndicator>
-        <Check className="h-4 w-4" />
-      </SelectPrimitive.ItemIndicator>
-    </span>
-    <SelectPrimitive.ItemText>{children}</SelectPrimitive.ItemText>
-  </SelectPrimitive.Item>
-));
+type SelectItemProps = React.ComponentPropsWithoutRef<typeof SelectPrimitive.Item> & {
+  action?: React.ReactNode;
+};
+
+const SelectItem = React.forwardRef<React.ElementRef<typeof SelectPrimitive.Item>, SelectItemProps>(
+  ({ className, children, action, ...props }, ref) => (
+    <SelectPrimitive.Item
+      ref={ref}
+      className={cn(
+        'relative flex w-full cursor-pointer select-none items-center rounded-sm py-1.5 pl-2 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50',
+        action ? 'pr-12' : 'pr-8',
+        className
+      )}
+      {...props}
+    >
+      {action ? <span className="absolute right-7 flex items-center">{action}</span> : null}
+      <span className="absolute right-2 flex h-3.5 w-3.5 items-center justify-center">
+        <SelectPrimitive.ItemIndicator>
+          <Check className="h-4 w-4" />
+        </SelectPrimitive.ItemIndicator>
+      </span>
+      <SelectPrimitive.ItemText>{children}</SelectPrimitive.ItemText>
+    </SelectPrimitive.Item>
+  )
+);
 SelectItem.displayName = SelectPrimitive.Item.displayName;
 
 const SelectSeparator = React.forwardRef<
diff --git a/src/renderer/lib/taskTerminalsStore.ts b/src/renderer/lib/taskTerminalsStore.ts
index 8d585eaf4..fd859b98a 100644
--- a/src/renderer/lib/taskTerminalsStore.ts
+++ b/src/renderer/lib/taskTerminalsStore.ts
@@ -6,6 +6,7 @@ type TaskTerminal = {
   title: string;
   cwd?: string;
   shell?: string;
+  pinned?: boolean;
   createdAt: number;
 };
 
@@ -75,6 +76,7 @@ function loadFromStorage(taskId: string): TaskTerminalsState | null {
               title,
               cwd: typeof item.cwd === 'string' && item.cwd ? item.cwd : undefined,
               shell: typeof item.shell === 'string' && item.shell ? item.shell : undefined,
+              pinned: item.pinned === true,
               createdAt:
                 typeof item.createdAt === 'number' && Number.isFinite(item.createdAt)
                   ? item.createdAt
@@ -296,6 +298,22 @@ function closeTerminal(taskId: string, terminalId: string, taskPath?: string) {
   }
 }
 
+function setPinned(taskId: string, terminalId: string, pinned: boolean, taskPath?: string) {
+  updateTaskState(taskId, taskPath, (draft) => {
+    draft.terminals = draft.terminals.map((terminal) =>
+      terminal.id === terminalId ? { ...terminal, pinned } : terminal
+    );
+  });
+}
+
+function togglePinned(taskId: string, terminalId: string, taskPath?: string) {
+  updateTaskState(taskId, taskPath, (draft) => {
+    draft.terminals = draft.terminals.map((terminal) =>
+      terminal.id === terminalId ? { ...terminal, pinned: !terminal.pinned } : terminal
+    );
+  });
+}
+
 export function disposeTaskTerminals(taskKey: string): void {
   const state = taskStates.get(taskKey) ?? loadFromStorage(taskKey);
   if (state) {
@@ -350,6 +368,9 @@ export function useTaskTerminals(
         createTerminal(resolvedId, options?.cwd || resolvedPath, options),
       setActiveTerminal: (terminalId: string) => setActive(resolvedId, terminalId, resolvedPath),
       closeTerminal: (terminalId: string) => closeTerminal(resolvedId, terminalId, resolvedPath),
+      setPinned: (terminalId: string, pinned: boolean) =>
+        setPinned(resolvedId, terminalId, pinned, resolvedPath),
+      togglePinned: (terminalId: string) => togglePinned(resolvedId, terminalId, resolvedPath),
     };
   }, [resolvedId, resolvedPath]);