@mndrk/agx 2.3.3 → 2.4.2

package/cloud-runtime/standalone/apps/local/components/{LinearBoard.tsx → TrackerBoard.tsx}

@@ -4,55 +4,74 @@ import React, { useCallback, useEffect, useMemo, useRef, useState } from "react"
 import dynamic from "next/dynamic";
 import { ArrowDown, ArrowUp, ChevronLeft, Clock, FileText, Play, Plus, RefreshCw, Search, Settings, User, X } from "lucide-react";
 import { useUrlSelection } from "@/hooks/useUrlSelection";
-import { useLinearIssues, type LinearIssue } from "@/hooks/useLinearIssues";
-import { useLinearConnection } from "@/hooks/useLinearConnection";
-import { useLinearRuns, type LinearRun } from "@/hooks/useLinearRuns";
-import { useLinearRunScripts } from "@/hooks/useLinearRunScripts";
+import { useTrackerItems } from "@/hooks/useTrackerItems";
+import type { TrackerItem, TrackerStatusCategory } from "@/lib/tracker/types";
+import { useTrackerConnection } from "@/hooks/useTrackerConnection";
+import { useTrackerRuns } from "@/hooks/useTrackerRuns";
+import type { TrackerRunRecord } from "@/lib/tracker/tracker-run-store";
+import { useTrackerRunScripts } from "@/hooks/useTrackerRunScripts";
 import { useGroupChat } from "@/hooks/useGroupChat";
 import { useProcessPolling } from "@/hooks/useProcessPolling";
 import { Markdown } from "@/components/chat-ui/Markdown";
-import RunScriptManager from "@/components/linear/RunScriptManager";
+import RunScriptManager from "@/components/tracker/RunScriptManager";
 import { stripMarkers } from "@/lib/chat-utils";
 import { useInputCapabilities } from "@/hooks/useInputCapabilities";
 import {
-  loadLinearBoardFilters,
-  persistLinearBoardFilters,
-} from "@/state/linearBoardFilters";
+  loadTrackerBoardFilters,
+  persistTrackerBoardFilters,
+} from "@/state/trackerBoardFilters";
 import {
-  loadPinnedIssueIds,
-  persistPinnedIssueIds,
-} from "@/state/linearBoardPins";
+  loadPinnedTrackerItemIds,
+  persistPinnedTrackerItemIds,
+} from "@/state/trackerBoardPins";
 import {
   loadLinearTicketPanelWidth,
   persistLinearTicketPanelWidth,
 } from "@/state/windowState";
+import { loadLastRunForIssue, persistLastRunForIssue } from "@/state/lastSession";
 import {
   orderParticipantIds,
   type ComposerRoutingMetadata,
 } from "@/lib/chat/composer-routing";
-import { buildLinearExecutionPrompt } from "@/lib/linear-execution-prompt";
+import { buildTrackerExecutionPrompt } from "@/lib/tracker/tracker-execution-prompt";
 import type { Participant } from "@/lib/types";
-import LinearSetup from "@/components/LinearSetup";
-import LinearSettingsModal from "@/components/linear/LinearSettingsModal";
+import LinearSetup from "@/components/tracking/TrackerSetup";
+import TrackerSettingsModal from "@/components/tracker/TrackerSettingsModal";
 import {
   getRunDisplayState,
   getRunTitle,
   STATUS_BADGE_STYLES,
   STATUS_DOT_COLORS,
+  STATUS_LABELS,
   STATUS_TEXT_COLORS,
-} from "@/lib/linear-run-status";
+} from "@/lib/tracker-run-status";
 import { ResizeHandle } from "@/components/ui/ResizeHandle";
 import {
   FilterSelect,
   IssueStatusSelect,
   MultiFilterPopdown,
   type FilterOption,
-} from "@/components/linear/LinearBoardFilters";
-import { TicketRow } from "@/components/linear/TicketRow";
-import { TicketPanel } from "@/components/linear/TicketPanel";
-import { useLinearParticipants } from "@/hooks/useLinearParticipants";
-import { useLinearActiveAgents } from "@/hooks/useLinearActiveAgents";
-import { agentAvatarUrl } from "@/lib/linear-board-utils";
+} from "@/components/tracker/TrackerBoardFilters";
+import { TicketRow } from "@/components/tracker/TicketRow";
+import { TicketPanel } from "@/components/tracker/TicketPanel";
+import { useTrackerParticipants } from "@/hooks/useTrackerParticipants";
+import { useTrackerActiveAgents } from "@/hooks/useTrackerActiveAgents";
+import { agentAvatarUrl } from "@/lib/tracker-board-utils";
+import { useTaskGroups, type TaskGroup } from "@/hooks/useTaskGroups";
+import { FolderRow } from "@/components/tracker/FolderRow";
+import { GroupPanel } from "@/components/tracker/GroupPanel";
+import { GroupNamePrompt, PENDING_GROUP_DROP_ID } from "@/components/tracker/GroupNamePrompt";
+import { SelectionBar } from "@/components/tracker/SelectionBar";
+import {
+  DndContext,
+  DragOverlay,
+  closestCenter,
+  PointerSensor,
+  useSensor,
+  useSensors,
+  type DragEndEvent,
+  type DragStartEvent,
+} from "@dnd-kit/core";
 
 const Composer = dynamic(
   () => import("@/components/chat-ui/Composer").then((module) => module.Composer),
@@ -70,34 +89,31 @@ function formatRunTime(iso: string): string {
   });
 }
 
-interface CycleOption {
+interface GroupOption {
   id: string;
-  number: number;
-  name: string | null;
-  startsAt: string;
-  endsAt: string;
+  name: string;
 }
 
-interface LinearEntityOption {
+interface TrackerEntityOption {
   id: string;
   name: string;
 }
 
 function ThreadMessageList({
-  issue,
+  item,
   run,
   participants,
-  issueStatusOptions,
-  issueStatusUpdating,
-  onIssueStatusChange,
+  itemStatusOptions,
+  itemStatusUpdating,
+  onItemStatusChange,
   onBack,
 }: {
-  issue: LinearIssue;
-  run: LinearRun;
+  item: TrackerItem;
+  run: TrackerRunRecord;
   participants: Participant[];
-  issueStatusOptions: FilterOption[];
-  issueStatusUpdating: boolean;
-  onIssueStatusChange: (issue: LinearIssue, status: string) => void;
+  itemStatusOptions: FilterOption[];
+  itemStatusUpdating: boolean;
+  onItemStatusChange: (item: TrackerItem, status: string) => void;
   onBack?: () => void;
 }) {
   const { messages, setMessages, sendMessage, loadHistory, stop } = useGroupChat(
@@ -115,7 +131,7 @@ function ThreadMessageList({
   const runDisplay = useMemo(() => {
     const latestChatRun = chatRuns[0];
     if (!latestChatRun) return getRunDisplayState(run);
-    const mappedStatus: Record<string, LinearRun["status"]> = {
+    const mappedStatus: Record<string, TrackerRunRecord["status"]> = {
       queued: "queued",
       running: "running",
       awaiting_user: "running",
@@ -196,7 +212,7 @@ function ThreadMessageList({
             </button>
           )}
           <span className="shrink-0 font-mono text-sm text-[var(--muted-foreground)]">
-            {issue.identifier}
+            {item.identifier}
           </span>
           <div className="h-1 w-1 shrink-0 rounded-full bg-[var(--card-border)]" />
           <span className="truncate text-sm font-medium text-[var(--foreground)]">
@@ -206,11 +222,11 @@ function ThreadMessageList({
 
         <div className="flex shrink-0 items-center gap-4">
           <IssueStatusSelect
-            status={issue.status}
-            options={issueStatusOptions}
-            disabled={issueStatusOptions.length === 0}
-            updating={issueStatusUpdating}
-            onChange={(status) => onIssueStatusChange(issue, status)}
+            status={item.status}
+            options={itemStatusOptions}
+            disabled={itemStatusOptions.length === 0}
+            updating={itemStatusUpdating}
+            onChange={(status) => onItemStatusChange(item, status)}
           />
           <div
             className={`flex items-center gap-2 rounded-md border px-2.5 py-1 ${STATUS_BADGE_STYLES[runDisplay.tone]}`}
@@ -355,13 +371,14 @@ function ThreadMessageList({
   );
 }
 
-interface LinearBoardProps {
+interface TrackerBoardProps {
+  trackerType: string;
   projectId?: string;
   projectSlug?: string;
   initialShowSettings?: boolean;
 }
 
-export default function LinearBoard({ projectId, projectSlug, initialShowSettings }: LinearBoardProps) {
+export default function TrackerBoard({ trackerType, projectId, projectSlug, initialShowSettings }: TrackerBoardProps) {
   const { isTouchLayout } = useInputCapabilities();
   const {
     connected,
@@ -373,32 +390,32 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
     connectWithKey,
     disconnect,
     configureMcp,
-  } = useLinearConnection(projectId ?? "");
+  } = useTrackerConnection(trackerType, projectId ?? "");
 
-  const [setupDismissed, setSetupDismissed] = useState(false);
+  const lastRestoredItemRef = useRef<string | null>(null);
   const [showSettings, setShowSettings] = useState(initialShowSettings ?? false);
   const [showRunScripts, setShowRunScripts] = useState(false);
   const [ticketPanelWidth, setTicketPanelWidth] = useState(() => loadLinearTicketPanelWidth() || 576);
   const [search, setSearch] = useState("");
   const [debouncedSearch, setDebouncedSearch] = useState("");
   const [filterOptionsLoaded, setFilterOptionsLoaded] = useState(false);
-  const [assignees, setAssignees] = useState<LinearEntityOption[]>([]);
-  const [statuses, setStatuses] = useState<string[]>([]);
-  const [workspaces, setWorkspaces] = useState<LinearEntityOption[]>([]);
+  const [assignees, setAssignees] = useState<TrackerEntityOption[]>([]);
+  const [statusCategories, setStatusCategories] = useState<{ value: string; label: string }[]>([]);
+  const [workspaces, setWorkspaces] = useState<TrackerEntityOption[]>([]);
   const [selectedAssigneeIds, setSelectedAssigneeIds] = useState<string[]>([]);
-  const [selectedStatuses, setSelectedStatuses] = useState<string[]>([]);
-  const [cycles, setCycles] = useState<CycleOption[]>([]);
-  const [selectedCycleId, setSelectedCycleId] = useState("");
+  const [selectedStatusCategories, setSelectedStatusCategories] = useState<string[]>([]);
+  const [groups, setGroups] = useState<GroupOption[]>([]);
+  const [selectedGroupId, setSelectedGroupId] = useState("");
   const [selectedWorkspaceId, setSelectedWorkspaceId] = useState("");
   const [sortBy, setSortBy] = useState<"activity" | "identifier" | "status" | "created">("activity");
   const [sortDir, setSortDir] = useState<"asc" | "desc">("desc");
   const [hasActivity, setHasActivity] = useState(false);
-  const [pinnedIssueIds, setPinnedIssueIds] = useState<Set<string>>(() => loadPinnedIssueIds(projectSlug));
-  const [selectedIssueFallback, setSelectedIssueFallback] = useState<LinearIssue | null>(null);
-  const [updatingIssueId, setUpdatingIssueId] = useState<string | null>(null);
-  const { participants } = useLinearParticipants(projectId);
-  const { issueActiveAgents } = useLinearActiveAgents(projectId);
-  const [pickerIssue, setPickerIssue] = useState<LinearIssue | null>(null);
+  const [pinnedItemIds, setPinnedItemIds] = useState<Set<string>>(() => loadPinnedTrackerItemIds(trackerType, projectSlug));
+  const [selectedItemFallback, setSelectedItemFallback] = useState<TrackerItem | null>(null);
+  const [updatingItemId, setUpdatingItemId] = useState<string | null>(null);
+  const { participants } = useTrackerParticipants(trackerType, projectId);
+  const { issueActiveAgents } = useTrackerActiveAgents(trackerType, projectId);
+  const [pickerItem, setPickerItem] = useState<TrackerItem | null>(null);
   const [pickerAnchor, setPickerAnchor] = useState<{ top: number; left: number } | null>(null);
   const [touchPanelTab, setTouchPanelTab] = useState<"runs" | "ticket">("runs");
   const searchDebounceRef = useRef<ReturnType<typeof setTimeout> | null>(null);
@@ -406,8 +423,158 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
   const runScriptsButtonRef = useRef<HTMLButtonElement | null>(null);
   const runScriptsPanelRef = useRef<HTMLDivElement | null>(null);
   const { getSelection, pushSelection, replaceSelection } = useUrlSelection();
-  const selectedIssueId = getSelection("issue");
+  const selectedItemId = getSelection("issue");
   const selectedRunId = getSelection("run");
+  const selectedGroupTaskGroupId = getSelection("group");
+
+  // Task groups
+  const {
+    groups: taskGroups,
+    createGroup,
+    updateGroup,
+    deleteGroup,
+    addTasksToGroup,
+    removeTaskFromGroup: removeTaskFromGroupApi,
+    refetch: refetchGroups,
+  } = useTaskGroups(projectId);
+
+  // Multi-select state
+  const [multiSelectedItemIds, setMultiSelectedItemIds] = useState<Set<string>>(new Set());
+  const [showGroupNamePrompt, setShowGroupNamePrompt] = useState(false);
+  const [pendingGroupTaskIds, setPendingGroupTaskIds] = useState<string[]>([]);
+  const [pendingGroupTargetId, setPendingGroupTargetId] = useState<string | null>(null);
+
+  // Drag state
+  const dndSensors = useSensors(
+    useSensor(PointerSensor, {
+      activationConstraint: { distance: 8 },
+    }),
+  );
+  const [dragActiveId, setDragActiveId] = useState<string | null>(null);
+
+  const toggleItemMultiSelect = useCallback((itemId: string) => {
+    setMultiSelectedItemIds((prev) => {
+      const next = new Set(prev);
+      if (next.has(itemId)) {
+        next.delete(itemId);
+      } else {
+        next.add(itemId);
+      }
+      return next;
+    });
+  }, []);
+
+  const handleCreateGroup = useCallback(
+    async (name: string) => {
+      if (pendingGroupTaskIds.length < 2) return;
+      await createGroup(name, pendingGroupTaskIds);
+      setPendingGroupTaskIds([]);
+      setShowGroupNamePrompt(false);
+      setPendingGroupTargetId(null);
+      setMultiSelectedItemIds(new Set());
+    },
+    [pendingGroupTaskIds, createGroup],
+  );
+
+  // Ref to sortedItems so handleMultiSelectGroup can access it without
+  // hoisting issues (sortedItems is declared further down).
+  const sortedItemsRef = useRef<TrackerItem[]>([]);
+
+  const handleMultiSelectGroup = useCallback(() => {
+    const ids = Array.from(multiSelectedItemIds);
+    // Find the topmost selected item in the sorted list to position the prompt
+    const topmost = sortedItemsRef.current.find((i) => multiSelectedItemIds.has(i.id));
+    setPendingGroupTaskIds(ids);
+    setPendingGroupTargetId(topmost?.id ?? ids[0] ?? null);
+    setShowGroupNamePrompt(true);
+  }, [multiSelectedItemIds]);
+
+  const selectedGroup = taskGroups.find((g) => g.id === selectedGroupTaskGroupId);
+  const groupedItemIds = useMemo(
+    () => new Set(taskGroups.flatMap((g) => g.task_ids)),
+    [taskGroups],
+  );
+
+  const handleDragStart = useCallback((event: DragStartEvent) => {
+    setDragActiveId(event.active.id as string);
+  }, []);
+
+  const handleDragEnd = useCallback(
+    async (event: DragEndEvent) => {
+      setDragActiveId(null);
+      const { active, over } = event;
+
+      const activeItemId = active.id as string;
+
+      // While the pending group prompt is open, handle adds/removes
+      if (showGroupNamePrompt) {
+        const activeInPending = pendingGroupTaskIds.includes(activeItemId);
+
+        if (!over || active.id === over.id) {
+          // Dropped on nothing or self — if it was a pending item, remove it
+          if (activeInPending) {
+            setPendingGroupTaskIds((prev) => {
+              const next = prev.filter((id) => id !== activeItemId);
+              if (next.length < 2) {
+                setShowGroupNamePrompt(false);
+                setPendingGroupTargetId(null);
+                return [];
+              }
+              return next;
+            });
+          }
+          return;
+        }
+
+        const overId = over.id as string;
+        const droppedOnPending = overId === PENDING_GROUP_DROP_ID || pendingGroupTaskIds.includes(overId);
+
+        if (activeInPending && !droppedOnPending) {
+          // Dragged out of pending group — remove it
+          setPendingGroupTaskIds((prev) => {
+            const next = prev.filter((id) => id !== activeItemId);
+            if (next.length < 2) {
+              setShowGroupNamePrompt(false);
+              setPendingGroupTargetId(null);
+              return [];
+            }
+            return next;
+          });
+        } else if (!activeInPending) {
+          // Dragged into pending group — add it
+          setPendingGroupTaskIds((prev) => [...prev, activeItemId]);
+        }
+        return;
+      }
+
+      if (!over || active.id === over.id) return;
+      const overId = over.id as string;
+
+      // Check if dropping on a folder
+      const targetGroup = taskGroups.find((g) => g.id === overId);
+      if (targetGroup) {
+        await addTasksToGroup(targetGroup.id, [activeItemId]);
+        return;
+      }
+
+      // Check if dropping on another loose ticket (create folder)
+      const overIsLoose = !groupedItemIds.has(overId);
+      const activeIsLoose = !groupedItemIds.has(activeItemId);
+      if (activeIsLoose && overIsLoose) {
+        setPendingGroupTaskIds([activeItemId, overId]);
+        setPendingGroupTargetId(overId);
+        setShowGroupNamePrompt(true);
+        return;
+      }
+
+      // Ticket dragged out of a folder
+      const activeGroup = taskGroups.find((g) => g.task_ids.includes(activeItemId));
+      if (activeGroup && overIsLoose) {
+        await removeTaskFromGroupApi(activeGroup.id, activeItemId);
+      }
+    },
+    [taskGroups, groupedItemIds, addTasksToGroup, removeTaskFromGroupApi, showGroupNamePrompt, pendingGroupTaskIds],
+  );
 
   const handleSearchChange = useCallback((value: string) => {
     setSearch(value);
@@ -417,18 +584,18 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
     searchDebounceRef.current = setTimeout(() => setDebouncedSearch(value), 300);
   }, []);
 
-  const togglePin = useCallback((issueId: string) => {
-    setPinnedIssueIds((prev) => {
+  const togglePin = useCallback((itemId: string) => {
+    setPinnedItemIds((prev) => {
       const next = new Set(prev);
-      if (next.has(issueId)) {
-        next.delete(issueId);
+      if (next.has(itemId)) {
+        next.delete(itemId);
       } else {
-        next.add(issueId);
+        next.add(itemId);
       }
-      persistPinnedIssueIds(projectSlug, next);
+      persistPinnedTrackerItemIds(trackerType, projectSlug, next);
       return next;
     });
-  }, [projectSlug]);
+  }, [trackerType, projectSlug]);
 
   useEffect(() => {
     return () => {
@@ -439,19 +606,19 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
   }, []);
 
   useEffect(() => {
-    const storedFilters = loadLinearBoardFilters(projectSlug);
+    const storedFilters = loadTrackerBoardFilters(trackerType, projectSlug);
     skipNextFilterPersistRef.current = true;
     setSearch(storedFilters.search);
     setDebouncedSearch(storedFilters.search);
     setSelectedAssigneeIds(storedFilters.assigneeIds);
-    setSelectedStatuses(storedFilters.statuses);
-    setSelectedWorkspaceId(storedFilters.teamId);
-    setSelectedCycleId(storedFilters.cycleId);
+    setSelectedStatusCategories(storedFilters.statusCategories);
+    setSelectedWorkspaceId(storedFilters.groupIds?.[0] ?? "");
+    setSelectedGroupId(storedFilters.groupIds?.[0] ?? "");
     setSortBy(storedFilters.sortBy);
     setSortDir(storedFilters.sortDir);
     setHasActivity(storedFilters.hasActivity);
-    setPinnedIssueIds(loadPinnedIssueIds(projectSlug));
-  }, [projectSlug]);
+    setPinnedItemIds(loadPinnedTrackerItemIds(trackerType, projectSlug));
+  }, [trackerType, projectSlug]);
 
   useEffect(() => {
     if (skipNextFilterPersistRef.current) {
@@ -459,17 +626,16 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
       return;
     }
 
-    persistLinearBoardFilters(projectSlug, {
+    persistTrackerBoardFilters(trackerType, projectSlug, {
       search,
       assigneeIds: selectedAssigneeIds,
-      statuses: selectedStatuses,
-      teamId: selectedWorkspaceId,
-      cycleId: selectedCycleId,
+      statusCategories: selectedStatusCategories,
+      groupIds: selectedGroupId ? [selectedGroupId] : [],
       sortBy,
       sortDir,
       hasActivity,
     });
-  }, [projectSlug, search, selectedAssigneeIds, selectedStatuses, selectedWorkspaceId, selectedCycleId, sortBy, sortDir, hasActivity]);
+  }, [trackerType, projectSlug, search, selectedAssigneeIds, selectedStatusCategories, selectedWorkspaceId, selectedGroupId, sortBy, sortDir, hasActivity]);
 
   // Fetch filter options when connected
   useEffect(() => {
@@ -481,7 +647,7 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
     if (projectSlug) {
       params.set("projectSlug", projectSlug);
     }
-    const url = `/api/linear/options?${params.toString()}`;
+    const url = `/api/trackers/${trackerType}/options?${params.toString()}`;
     fetch(url)
       .then((res) => res.json())
       .then((data) => {
@@ -489,24 +655,24 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
           return;
         }
         setAssignees(Array.isArray(data.assignees) ? data.assignees : []);
-        setStatuses(Array.isArray(data.statuses) ? data.statuses : []);
+        setStatusCategories(Array.isArray(data.statuses) ? data.statuses.map((s: { name: string; category: string }) => ({ value: s.name, label: s.name })) : []);
         setWorkspaces(Array.isArray(data.teams) ? data.teams : []);
-        setCycles(Array.isArray(data.cycles) ? data.cycles : []);
+        setGroups(Array.isArray(data.cycles) ? data.cycles : []);
         setFilterOptionsLoaded(true);
       })
       .catch(() => {
         if (!cancelled) {
           setAssignees([]);
-          setStatuses([]);
+          setStatusCategories([]);
           setWorkspaces([]);
-          setCycles([]);
+          setGroups([]);
           setFilterOptionsLoaded(true);
         }
       });
     return () => {
       cancelled = true;
     };
-  }, [connected, projectId, projectSlug]);
+  }, [connected, trackerType, projectId, projectSlug]);
 
   useEffect(() => {
     if (!filterOptionsLoaded) {
@@ -524,11 +690,12 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
     if (!filterOptionsLoaded) {
       return;
     }
-    const validStatuses = selectedStatuses.filter((status) => statuses.includes(status));
-    if (validStatuses.length !== selectedStatuses.length) {
-      setSelectedStatuses(validStatuses);
+    const validValues = statusCategories.map((s) => s.value);
+    const validStatuses = selectedStatusCategories.filter((status) => validValues.includes(status));
+    if (validStatuses.length !== selectedStatusCategories.length) {
+      setSelectedStatusCategories(validStatuses);
     }
-  }, [filterOptionsLoaded, selectedStatuses, statuses]);
+  }, [filterOptionsLoaded, selectedStatusCategories, statusCategories]);
 
   useEffect(() => {
     if (!filterOptionsLoaded) {
@@ -548,67 +715,66 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
     if (!filterOptionsLoaded) {
       return;
     }
-    if (selectedCycleId && !cycles.some((cycle) => cycle.id === selectedCycleId)) {
-      setSelectedCycleId("");
+    if (selectedGroupId && !groups.some((group) => group.id === selectedGroupId)) {
+      setSelectedGroupId("");
     }
-  }, [cycles, filterOptionsLoaded, selectedCycleId]);
+  }, [groups, filterOptionsLoaded, selectedGroupId]);
 
   const filters = useMemo(
     () => ({
       search: debouncedSearch || undefined,
       statuses:
-        selectedStatuses.length > 0 && selectedStatuses.length < statuses.length
-          ? selectedStatuses
+        selectedStatusCategories.length > 0 && selectedStatusCategories.length < statusCategories.length
+          ? selectedStatusCategories
           : undefined,
       assigneeIds: selectedAssigneeIds.length > 0 ? selectedAssigneeIds : undefined,
-      teamId: selectedWorkspaceId || undefined,
-      cycleId: selectedCycleId || undefined,
+      groupIds: selectedGroupId ? [selectedGroupId] : undefined,
       sortBy,
       sortDir,
       hasActivity: hasActivity || undefined,
     }),
-    [debouncedSearch, selectedAssigneeIds, selectedCycleId, selectedStatuses, selectedWorkspaceId, statuses.length, sortBy, sortDir, hasActivity]
+    [debouncedSearch, selectedAssigneeIds, selectedGroupId, selectedStatusCategories, statusCategories.length, sortBy, sortDir, hasActivity]
   );
 
   const {
-    issues,
-    loading: issuesLoading,
+    items,
+    loading: itemsLoading,
     hasMore,
     loadMore,
-    refresh: refreshIssues,
-    updateIssue,
-  } = useLinearIssues(filters, connected && filterOptionsLoaded && Boolean(projectId), {
+    refresh: refreshItems,
+    updateItem,
+  } = useTrackerItems(trackerType, filters, connected && filterOptionsLoaded && Boolean(projectId), {
     projectId: projectId ?? "",
-    projectSlug,
   });
-  const selectedIssueFromList = useMemo(
-    () => (selectedIssueId ? issues.find((issue) => issue.id === selectedIssueId) ?? null : null),
-    [issues, selectedIssueId],
+  const selectedItemFromList = useMemo(
+    () => (selectedItemId ? items.find((item) => item.id === selectedItemId) ?? null : null),
+    [items, selectedItemId],
   );
-  const selectedIssue =
-    selectedIssueFromList ??
-    (selectedIssueFallback?.id === selectedIssueId ? selectedIssueFallback : null);
-
-  const sortedIssues = useMemo(() => {
-    if (pinnedIssueIds.size === 0) return issues;
-    const pinned: LinearIssue[] = [];
-    const unpinned: LinearIssue[] = [];
-    for (const issue of issues) {
-      if (pinnedIssueIds.has(issue.id)) {
-        pinned.push(issue);
+  const selectedItem =
+    selectedItemFromList ??
+    (selectedItemFallback?.id === selectedItemId ? selectedItemFallback : null);
+
+  const sortedItems = useMemo(() => {
+    if (pinnedItemIds.size === 0) return items;
+    const pinned: TrackerItem[] = [];
+    const unpinned: TrackerItem[] = [];
+    for (const item of items) {
+      if (pinnedItemIds.has(item.id)) {
+        pinned.push(item);
       } else {
-        unpinned.push(issue);
+        unpinned.push(item);
       }
     }
     return [...pinned, ...unpinned];
-  }, [issues, pinnedIssueIds]);
+  }, [items, pinnedItemIds]);
+  sortedItemsRef.current = sortedItems;
 
   const {
     runs,
     loading: runsLoading,
     createRun,
     updateRun,
-  } = useLinearRuns(selectedIssue?.id, projectId ?? null);
+  } = useTrackerRuns(trackerType, selectedItem?.id ?? null, projectId ?? null);
   const {
     scripts: runScripts,
     activeScriptId,
@@ -616,60 +782,63 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
     setActiveScriptId,
     saveScript,
     deleteScript,
-  } = useLinearRunScripts(projectSlug);
+  } = useTrackerRunScripts(trackerType, projectSlug);
 
   const selectedRun = selectedRunId
     ? runs.find((run) => run.id === selectedRunId) ?? null
     : null;
+  const storedRunId = selectedItemId && !selectedRunId ? loadLastRunForIssue(selectedItemId) : null;
+  const isAwaitingRestore = !!storedRunId && lastRestoredItemRef.current !== selectedItemId;
   const assigneeOptions = useMemo<FilterOption[]>(
     () => assignees.map((assignee) => ({ value: assignee.id, label: assignee.name })),
     [assignees]
   );
   const statusOptions = useMemo<FilterOption[]>(
-    () => statuses.map((status) => ({ value: status, label: status })),
-    [statuses]
+    () => statusCategories.map((s) => ({ value: s.value, label: s.label })),
+    [statusCategories]
   );
-  const issueStatusOptions = useMemo<FilterOption[]>(
-    () =>
-      Array.from(
-        new Set(
-          [selectedIssue?.status ?? "", ...statuses]
-            .map((status) => status.trim())
-            .filter(Boolean)
-        )
-      ).map((status) => ({ value: status, label: status })),
-    [selectedIssue?.status, statuses]
+  const itemStatusOptions = useMemo<FilterOption[]>(
+    () => {
+      const opts = statusCategories.map((s) => ({ value: s.label, label: s.label }));
+      const existing = new Set(opts.map((o) => o.value));
+      const current = selectedItem?.status?.trim();
+      if (current && !existing.has(current)) {
+        opts.unshift({ value: current, label: current });
+      }
+      return opts;
+    },
+    [selectedItem?.status, statusCategories]
   );
   const workspaceOptions = useMemo<FilterOption[]>(
     () => [{ value: "", label: "Workspace" }, ...workspaces.map((workspace) => ({ value: workspace.id, label: workspace.name }))],
     [workspaces]
   );
-  const cycleOptions = useMemo<FilterOption[]>(
+  const groupOptions = useMemo<FilterOption[]>(
     () => [
-      { value: "", label: "Cycle" },
-      ...cycles.map((cycle) => ({
-        value: cycle.id,
-        label: cycle.name || `Cycle ${cycle.number}`,
+      { value: "", label: "Group" },
+      ...groups.map((group) => ({
+        value: group.id,
+        label: group.name,
       })),
     ],
-    [cycles]
+    [groups]
   );
   const showStatusFilter = statusOptions.length > 0;
-  const showCycleFilter = cycleOptions.length > 1;
+  const showGroupFilter = groupOptions.length > 1;
   const showWorkspaceFilter = workspaceOptions.length > 2;
   const activeSessionScriptLabel = activeScript?.name ?? "AGX default";
 
-  const handleIssueStatusChange = useCallback(
-    async (issue: LinearIssue, status: string) => {
+  const handleItemStatusChange = useCallback(
+    async (item: TrackerItem, status: string) => {
       const nextStatus = status.trim();
-      if (!nextStatus || nextStatus === issue.status) {
+      if (!nextStatus || nextStatus === item.status || !projectId) {
         return;
       }
 
-      setUpdatingIssueId(issue.id);
+      setUpdatingItemId(item.id);
       try {
         const response = await fetch(
-          `/api/linear/issues/${encodeURIComponent(issue.id)}?projectId=${encodeURIComponent(projectId ?? "")}`,
+          `/api/trackers/${trackerType}/items/${encodeURIComponent(item.id)}?projectId=${encodeURIComponent(projectId ?? "")}`,
           {
             method: "PATCH",
             headers: { "Content-Type": "application/json" },
@@ -678,40 +847,40 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
         );
         const payload = (await response.json().catch(() => ({}))) as {
           error?: string;
-          issue?: LinearIssue;
+          item?: TrackerItem;
         };
 
-        if (!response.ok || !payload.issue) {
+        if (!response.ok || !payload.item) {
           throw new Error(payload.error || "Failed to update ticket status");
         }
 
-        const updatedIssue = payload.issue;
-        updateIssue(updatedIssue);
-        if (selectedIssueId === updatedIssue.id) {
-          setSelectedIssueFallback(updatedIssue);
+        const updatedItem = payload.item;
+        updateItem(updatedItem);
+        if (selectedItemId === updatedItem.id) {
+          setSelectedItemFallback(updatedItem);
         }
-        await refreshIssues();
+        await refreshItems();
       } catch (error) {
         if (error instanceof Error) {
           window.alert(error.message);
         }
       } finally {
-        setUpdatingIssueId((current) => (current === issue.id ? null : current));
+        setUpdatingItemId((current) => (current === item.id ? null : current));
       }
     },
-    [refreshIssues, selectedIssueId, updateIssue]
+    [refreshItems, selectedItemId, updateItem, trackerType, projectId]
   );
 
   useEffect(() => {
-    if (!selectedIssueId) {
-      setSelectedIssueFallback(null);
+    if (!selectedItemId || !projectId) {
+      setSelectedItemFallback(null);
       return;
     }
 
-    if (selectedIssueFromList) {
-      setSelectedIssueFallback((current) => {
-        if (current?.id === selectedIssueId) {
-          return selectedIssueFromList;
+    if (selectedItemFromList) {
+      setSelectedItemFallback((current: TrackerItem | null) => {
+        if (current?.id === selectedItemId) {
+          return selectedItemFromList;
         }
         return null;
       });
@@ -722,7 +891,7 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
 
     void (async () => {
       try {
-        const response = await fetch(`/api/linear/issues/${encodeURIComponent(selectedIssueId)}`);
+        const response = await fetch(`/api/trackers/${trackerType}/items/${encodeURIComponent(selectedItemId)}?projectId=${encodeURIComponent(projectId ?? "")}`);
         if (cancelled) return;
 
         if (response.status === 404) {
@@ -731,19 +900,19 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
         }
 
         if (!response.ok) {
-          throw new Error(`Failed to fetch selected Linear ticket: ${response.status}`);
+          throw new Error(`Failed to fetch selected tracker ticket: ${response.status}`);
         }
 
-        const payload = (await response.json().catch(() => ({}))) as { issue?: LinearIssue };
-        if (!payload.issue?.id) {
+        const payload = (await response.json().catch(() => ({}))) as { item?: TrackerItem };
+        if (!payload.item?.id) {
           replaceSelection({ issue: null, run: null });
           return;
         }
 
-        setSelectedIssueFallback(payload.issue);
+        setSelectedItemFallback(payload.item);
       } catch (error) {
         if (!cancelled) {
-          console.error("Failed to hydrate selected Linear issue", error);
+          console.error("Failed to hydrate selected tracker item", error);
         }
       }
     })();
@@ -751,33 +920,47 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
     return () => {
       cancelled = true;
     };
-  }, [replaceSelection, selectedIssueFromList, selectedIssueId]);
+  }, [replaceSelection, selectedItemFromList, selectedItemId, trackerType, projectId]);
 
   useEffect(() => {
-    if (!selectedIssueId) {
+    if (!selectedItemId) {
       if (selectedRunId) {
         replaceSelection({ run: null });
       }
       return;
     }
-  }, [replaceSelection, selectedIssueId, selectedRunId]);
+  }, [replaceSelection, selectedItemId, selectedRunId]);
 
   useEffect(() => {
-    if (!selectedIssue || !selectedRunId || runsLoading) {
+    if (!selectedItem || !selectedRunId || runsLoading) {
       return;
     }
 
     if (!runs.some((run) => run.id === selectedRunId)) {
       replaceSelection({ run: null });
     }
-  }, [replaceSelection, runs, runsLoading, selectedIssue, selectedRunId]);
+  }, [replaceSelection, runs, runsLoading, selectedItem, selectedRunId]);
+
+  useEffect(() => {
+    if (selectedItemId && selectedRunId) {
+      persistLastRunForIssue(selectedItemId, selectedRunId);
+    }
+  }, [selectedItemId, selectedRunId]);
+
+  useEffect(() => {
+    if (!isAwaitingRestore || runsLoading || runs.length === 0) return;
+    lastRestoredItemRef.current = selectedItemId;
+    if (storedRunId && runs.some((r) => r.id === storedRunId)) {
+      replaceSelection({ run: storedRunId });
+    }
+  }, [isAwaitingRestore, storedRunId, selectedItemId, runs, runsLoading, replaceSelection]);
 
   useEffect(() => {
     if (!isTouchLayout) {
       return;
     }
 
-    if (!selectedIssue) {
+    if (!selectedItem) {
       setTouchPanelTab("runs");
       return;
     }
@@ -788,7 +971,7 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
     }
 
     setTouchPanelTab("runs");
-  }, [isTouchLayout, runs.length, selectedIssue, selectedRun]);
+  }, [isTouchLayout, runs.length, selectedItem, selectedRun]);
 
   useEffect(() => {
     if (!showRunScripts) {
@@ -821,22 +1004,22 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
   }, [showRunScripts]);
 
   const executeWithAgent = useCallback(
-    async (issue: LinearIssue, agent: Participant) => {
-      setPickerIssue(null);
+    async (item: TrackerItem, agent: Participant) => {
+      setPickerItem(null);
       setPickerAnchor(null);
 
       try {
-        const response = await fetch("/api/linear/runs/scripted", {
+        const response = await fetch(`/api/trackers/${trackerType}/runs/scripted`, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify({
             projectId: projectId ?? undefined,
             projectSlug: projectSlug ?? undefined,
-            issueId: issue.id,
-            issueIdentifier: issue.identifier,
-            issueTitle: issue.title,
-            issueStatus: issue.status,
-            issueAssignee: issue.assignee,
+            issueId: item.id,
+            issueIdentifier: item.identifier,
+            issueTitle: item.title,
+            issueStatus: item.status,
+            issueAssignee: item.assignee?.name ?? null,
             agentId: agent.id,
             scriptName: activeScript?.name,
             scriptPrompt: activeScript?.prompt,
@@ -845,7 +1028,7 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
 
         const payload = (await response.json().catch(() => ({}))) as {
           error?: string;
-          run?: LinearRun;
+          run?: TrackerRunRecord;
           chatRunId?: string;
           userMessageId?: string;
         };
@@ -854,33 +1037,33 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
           throw new Error(payload.error || "Failed to start scripted session");
         }
         pushSelection({
-          issue: issue.id,
+          issue: item.id,
           run: payload.run.id,
         });
       } catch (error) {
-        console.error("Failed to start scripted Linear session:", error);
+        console.error("Failed to start scripted tracker session:", error);
         if (error instanceof Error) {
           window.alert(error.message);
         }
       }
     },
-    [activeScript, projectId, projectSlug, pushSelection]
+    [activeScript, projectId, projectSlug, pushSelection, trackerType]
   );
 
   const handleStartScriptedSession = useCallback(
-    (issue: LinearIssue, event?: React.MouseEvent) => {
+    (item: TrackerItem, event?: React.MouseEvent) => {
       setShowRunScripts(false);
       if (participants.length === 0) {
         window.alert("Add at least one agent to this project before starting a scripted session.");
         return;
       }
       if (participants.length === 1) {
-        void executeWithAgent(issue, participants[0]);
+        void executeWithAgent(item, participants[0]);
         return;
       }
       // Multiple agents — show picker
       const rect = (event?.currentTarget as HTMLElement)?.getBoundingClientRect();
-      setPickerIssue(issue);
+      setPickerItem(item);
       setPickerAnchor(rect ? { top: rect.bottom + 4, left: rect.left } : { top: 200, left: 200 });
     },
     [executeWithAgent, participants],
@@ -903,28 +1086,14 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
     return () => observer.disconnect();
   }, [hasMore, loadMore]);
 
-  if (connectionLoading) {
-    return (
-      <div className="flex h-full items-center justify-center text-xs text-[var(--muted-foreground)]">
-        Loading...
-      </div>
-    );
-  }
-
-  const needsMcpSetup = connected && !setupDismissed && !Object.values(mcpConfigured).some(Boolean);
-
-  if (!connected || needsMcpSetup) {
+  if (!connected) {
     return (
       <LinearSetup
+        trackerType={trackerType}
+        projectId={projectId ?? ""}
         connected={connected}
-        user={user}
-        clis={clis}
-        mcpConfigured={mcpConfigured}
         onConnect={connect}
         onConnectWithKey={connectWithKey}
-        onDisconnect={disconnect}
-        onConfigureMcp={configureMcp}
-        onContinue={() => setSetupDismissed(true)}
       />
     );
   }
@@ -949,12 +1118,12 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
                 <button
                   type="button"
                   className="shrink-0 rounded p-2 text-[var(--muted-foreground)] transition-colors hover:bg-[var(--card-bg)] hover:text-[var(--foreground)] disabled:cursor-not-allowed disabled:opacity-50"
-                  onClick={() => void refreshIssues()}
+                  onClick={() => void refreshItems()}
                   title="Refresh tickets"
                   aria-label="Refresh tickets"
-                  disabled={issuesLoading}
+                  disabled={itemsLoading}
                 >
-                  <RefreshCw size={16} className={issuesLoading ? "animate-spin" : undefined} />
+                  <RefreshCw size={16} className={itemsLoading ? "animate-spin" : undefined} />
                 </button>
                 <button
                   type="button"
@@ -963,7 +1132,7 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
                     setShowRunScripts(false);
                     setShowSettings(true);
                   }}
-                  title="Linear settings"
+                  title="Tracker settings"
                 >
                   <Settings size={16} />
                 </button>
@@ -972,10 +1141,10 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
                 {showStatusFilter ? (
                   <MultiFilterPopdown
                     label="Status"
-                    values={selectedStatuses}
+                    values={selectedStatusCategories}
                     options={statusOptions}
                     activeClasses="border-amber-500/30 bg-amber-500/10 text-amber-300"
-                    onChange={setSelectedStatuses}
+                    onChange={setSelectedStatusCategories}
                     emptyLabel="All statuses"
                   />
                 ) : null}
@@ -996,13 +1165,13 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
                     onChange={setSelectedWorkspaceId}
                   />
                 ) : null}
-                {showCycleFilter ? (
+                {showGroupFilter ? (
                   <FilterSelect
-                    label="Cycle"
-                    value={selectedCycleId}
-                    options={cycleOptions}
+                    label="Group"
+                    value={selectedGroupId}
+                    options={groupOptions}
                     activeClasses="border-purple-500/30 bg-purple-500/10 text-purple-400"
-                    onChange={setSelectedCycleId}
+                    onChange={setSelectedGroupId}
                   />
                 ) : null}
                 <FilterSelect
@@ -1040,37 +1209,38 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
             </div>
 
             <div className="flex-1 overflow-y-auto">
-              {issuesLoading && issues.length === 0 ? (
+              {itemsLoading && items.length === 0 ? (
                 <div className="px-3 py-4 text-xs text-[var(--muted-foreground)]">
                   Loading tickets...
                 </div>
-              ) : issues.length === 0 ? (
+              ) : items.length === 0 ? (
                 <div className="px-3 py-4 text-xs text-[var(--muted-foreground)]">
                   No tickets found.
                 </div>
               ) : (
                 <>
-                  {sortedIssues.map((issue, idx) => (
-                    <React.Fragment key={issue.id}>
-                      {pinnedIssueIds.size > 0 &&
-                        !pinnedIssueIds.has(issue.id) &&
-                        (idx === 0 || pinnedIssueIds.has(sortedIssues[idx - 1].id)) && (
+                  {sortedItems.map((item, idx) => (
+                    <React.Fragment key={item.id}>
+                      {pinnedItemIds.size > 0 &&
+                        !pinnedItemIds.has(item.id) &&
+                        (idx === 0 || pinnedItemIds.has(sortedItems[idx - 1].id)) && (
                           <div className="mx-4 border-t border-amber-500/20" />
                         )}
                       <TicketRow
-                        issue={issue}
-                        selected={selectedIssue?.id === issue.id}
-                        pinned={pinnedIssueIds.has(issue.id)}
-                        activeAgents={issueActiveAgents.get(issue.id)}
+                        item={item}
+                        selected={selectedItem?.id === item.id}
+                        pinned={pinnedItemIds.has(item.id)}
+                        activeAgents={issueActiveAgents.get(item.id)}
                         participants={participants}
+                        projectSlug={projectSlug}
                         onSelect={() => {
                           setTouchPanelTab("runs");
                           pushSelection({
-                            issue: issue.id,
+                            issue: item.id,
                             run: null,
                           });
                         }}
-                        onTogglePin={() => togglePin(issue.id)}
+                        onTogglePin={() => togglePin(item.id)}
                       />
                     </React.Fragment>
                   ))}
@@ -1079,7 +1249,7 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
                       ref={sentinelRef}
                       className="py-2 text-center text-xs text-[var(--muted-foreground)]"
                     >
-                      {issuesLoading ? "Loading..." : "Load more"}
+                      {itemsLoading ? "Loading..." : "Load more"}
                     </div>
                   ) : null}
                 </>
@@ -1087,15 +1257,15 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
             </div>
           </div>
 
-          {selectedIssue ? (
+          {selectedItem ? (
             <div className="absolute inset-0 z-20 flex flex-col bg-[var(--background)]">
               <div className="flex items-center justify-between gap-3 border-b border-[var(--card-border)] px-4 py-3">
                 <div className="min-w-0">
                   <div className="text-[10px] font-semibold uppercase tracking-[0.14em] text-[var(--muted-foreground)]">
-                    {selectedIssue.identifier}
+                    {selectedItem.identifier}
                   </div>
                   <div className="truncate text-sm font-semibold text-[var(--foreground)]">
-                    {selectedIssue.title}
+                    {selectedItem.title}
                   </div>
                 </div>
                 <button
@@ -1149,7 +1319,7 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
                         }}
                         title="Open a fresh chat for this ticket. You can choose or edit the session script in the ticket tab."
                         aria-label="New session"
-                        disabled={!selectedIssue}
+                        disabled={!selectedItem}
                       >
                         <Plus size={12} />
                         New session
@@ -1157,7 +1327,7 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
                     </div>
 
                     <div className="flex-1 overflow-y-auto">
-                      {runsLoading && runs.length === 0 ? (
+                      {(runsLoading && runs.length === 0) || isAwaitingRestore ? (
                         <div className="px-3 py-4 text-xs text-[var(--muted-foreground)]">
                           Loading sessions...
                         </div>
@@ -1212,40 +1382,46 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
                   </div>
                 ) : selectedRun ? (
                   <ThreadMessageList
-                    issue={selectedIssue ?? {
+                    item={selectedItem ?? {
                       id: selectedRun.issueId,
                       identifier: selectedRun.issueIdentifier,
                       title: selectedRun.issueTitle,
-                      url: null,
                       status: selectedRun.issueStatus,
-                      assignee: selectedRun.issueAssignee,
+                      statusCategory: "todo",
+                      labels: [],
+                      trackerId: "",
+                      trackerType,
+                      assignee: selectedRun.issueAssignee ? { id: "", name: selectedRun.issueAssignee } : undefined,
                       updatedAt: selectedRun.updatedAt,
+                      createdAt: selectedRun.updatedAt,
+                      url: "",
                     }}
                     run={selectedRun}
                     participants={participants}
-                    issueStatusOptions={issueStatusOptions}
-                    issueStatusUpdating={updatingIssueId === selectedRun.issueId}
-                    onIssueStatusChange={handleIssueStatusChange}
+                    itemStatusOptions={itemStatusOptions}
+                    itemStatusUpdating={updatingItemId === selectedRun.issueId}
+                    onItemStatusChange={handleItemStatusChange}
                     onBack={() => replaceSelection({ run: null })}
                   />
-                ) : participants.length === 0 ? (
+                ) : isAwaitingRestore ? null : participants.length === 0 ? (
                   <div className="flex h-full items-center justify-center text-xs text-[var(--muted-foreground)]">
                     Add at least one agent to this project to start a session.
                   </div>
                 ) : (
                   <TicketPanel
-                    key={selectedIssue.id}
-                    issue={selectedIssue}
+                    key={selectedItem.id}
+                    item={selectedItem}
+                    trackerType={trackerType}
                     runs={runs}
                     participants={participants}
                     projectId={projectId}
                     projectSlug={projectSlug}
-                    issueStatusOptions={issueStatusOptions}
-                    issueStatusUpdating={updatingIssueId === selectedIssue.id}
-                    onIssueStatusChange={handleIssueStatusChange}
+                    itemStatusOptions={itemStatusOptions}
+                    itemStatusUpdating={updatingItemId === selectedItem.id}
+                    onItemStatusChange={handleItemStatusChange}
                     activeSessionScriptLabel={activeSessionScriptLabel}
                     onOpenSessionScripts={() => setShowRunScripts(true)}
-                    onStartScriptedSession={(event) => handleStartScriptedSession(selectedIssue, event)}
+                    onStartScriptedSession={(event) => handleStartScriptedSession(selectedItem, event)}
                     createRun={createRun}
                     updateRun={updateRun}
                     onRunCreated={(runId) => pushSelection({ run: runId })}
@@ -1274,12 +1450,12 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
             <button
               type="button"
               className="shrink-0 rounded p-1.5 text-[var(--muted-foreground)] transition-colors hover:bg-[var(--card-bg)] hover:text-[var(--foreground)] disabled:cursor-not-allowed disabled:opacity-50"
-              onClick={() => void refreshIssues()}
+              onClick={() => void refreshItems()}
               title="Refresh tickets"
               aria-label="Refresh tickets"
-              disabled={issuesLoading}
+              disabled={itemsLoading}
             >
-              <RefreshCw size={16} className={issuesLoading ? "animate-spin" : undefined} />
+              <RefreshCw size={16} className={itemsLoading ? "animate-spin" : undefined} />
             </button>
             <button
               type="button"
@@ -1288,7 +1464,7 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
                 setShowRunScripts(false);
                 setShowSettings(true);
               }}
-              title="Linear settings"
+              title="Tracker settings"
             >
               <Settings size={16} />
             </button>
@@ -1297,10 +1473,10 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
             {showStatusFilter ? (
               <MultiFilterPopdown
                 label="Status"
-                values={selectedStatuses}
+                values={selectedStatusCategories}
                 options={statusOptions}
                 activeClasses="border-amber-500/30 bg-amber-500/10 text-amber-300"
-                onChange={setSelectedStatuses}
+                onChange={setSelectedStatusCategories}
                 emptyLabel="All statuses"
               />
             ) : null}
@@ -1321,13 +1497,13 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
                 onChange={setSelectedWorkspaceId}
               />
             ) : null}
-            {showCycleFilter ? (
+            {showGroupFilter ? (
               <FilterSelect
-                label="Cycle"
-                value={selectedCycleId}
-                options={cycleOptions}
+                label="Group"
+                value={selectedGroupId}
+                options={groupOptions}
                 activeClasses="border-purple-500/30 bg-purple-500/10 text-purple-400"
-                onChange={setSelectedCycleId}
+                onChange={setSelectedGroupId}
               />
             ) : null}
             <FilterSelect
@@ -1364,51 +1540,201 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
           </div>
         </div>
 
-        <div className="flex-1 overflow-y-auto">
-          {issuesLoading && issues.length === 0 ? (
+        <DndContext
+          sensors={dndSensors}
+          collisionDetection={closestCenter}
+          onDragStart={handleDragStart}
+          onDragEnd={handleDragEnd}
+        >
+        <div className="relative flex-1 overflow-y-auto">
+          {itemsLoading && items.length === 0 ? (
             <div className="px-3 py-4 text-xs text-[var(--muted-foreground)]">
               Loading tickets...
             </div>
-          ) : issues.length === 0 ? (
+          ) : items.length === 0 ? (
             <div className="px-3 py-4 text-xs text-[var(--muted-foreground)]">
               No tickets found.
             </div>
           ) : (
             <>
-              {sortedIssues.map((issue, idx) => (
-                <React.Fragment key={issue.id}>
-                  {pinnedIssueIds.size > 0 &&
-                    !pinnedIssueIds.has(issue.id) &&
-                    (idx === 0 || pinnedIssueIds.has(sortedIssues[idx - 1].id)) && (
-                      <div className="mx-4 border-t border-amber-500/20" />
-                    )}
-                  <TicketRow
-                    issue={issue}
-                    selected={selectedIssue?.id === issue.id}
-                    pinned={pinnedIssueIds.has(issue.id)}
-                    activeAgents={issueActiveAgents.get(issue.id)}
-                    participants={participants}
-                    onSelect={() =>
-                      pushSelection({
-                        issue: issue.id,
-                        run: null,
-                      })
+              {/* Unified list: groups rendered inline at first-member position */}
+              {(() => {
+                const pendingSet = showGroupNamePrompt ? new Set(pendingGroupTaskIds) : null;
+
+                // Build a map: itemId → group (for the first member of each group)
+                const firstMemberToGroup = new Map<string, typeof taskGroups[number]>();
+                for (const group of taskGroups) {
+                  const firstInSort = sortedItems.find((i) => group.task_ids.includes(i.id));
+                  if (firstInSort) firstMemberToGroup.set(firstInSort.id, group);
+                }
+
+                // Pending group prompt: find insert position
+                const pendingTickets = showGroupNamePrompt
+                  ? pendingGroupTaskIds
+                      .map((id) => sortedItems.find((i) => i.id === id))
+                      .filter(Boolean)
+                      .map((i) => ({ id: i!.id, identifier: i!.identifier, title: i!.title, status: STATUS_LABELS[i!.status] ?? i!.status }))
+                  : [];
+
+                // Track which groups we've rendered
+                const renderedGroups = new Set<string>();
+                let looseIdx = 0;
+
+                return sortedItems.map((item) => {
+                  // Skip pending tickets
+                  if (pendingSet?.has(item.id)) {
+                    // Render prompt at target position
+                    if (item.id === pendingGroupTargetId && showGroupNamePrompt) {
+                      return (
+                        <GroupNamePrompt
+                          key="__pending-group__"
+                          tickets={pendingTickets}
+                          onConfirm={handleCreateGroup}
+                          onCancel={() => {
+                            setShowGroupNamePrompt(false);
+                            setPendingGroupTaskIds([]);
+                            setPendingGroupTargetId(null);
+                          }}
+                        />
+                      );
                     }
-                    onTogglePin={() => togglePin(issue.id)}
-                  />
-                </React.Fragment>
-              ))}
+                    return null;
+                  }
+
+                  // If this item is the first member of a group, render the group here
+                  const group = firstMemberToGroup.get(item.id);
+                  if (group && !renderedGroups.has(group.id)) {
+                    renderedGroups.add(group.id);
+                    const groupItems = group.task_ids
+                      .map((id) => sortedItems.find((i) => i.id === id))
+                      .filter(Boolean) as TrackerItem[];
+                    return (
+                      <React.Fragment key={`group-${group.id}`}>
+                        <FolderRow
+                          groupId={group.id}
+                          name={group.name}
+                          count={groupItems.length}
+                          collapsed={!!group.collapsed}
+                          selected={selectedGroupTaskGroupId === group.id}
+                          projectSlug={projectSlug}
+                          onToggleCollapse={() =>
+                            updateGroup(group.id, { collapsed: !group.collapsed })
+                          }
+                          onSelect={() =>
+                            pushSelection({ group: group.id, issue: null, run: null })
+                          }
+                          onUngroup={() => {
+                            void deleteGroup(group.id);
+                            if (selectedGroupTaskGroupId === group.id) {
+                              replaceSelection({ group: null });
+                            }
+                          }}
+                        />
+                        {!group.collapsed &&
+                          groupItems.map((gi, giIdx) => (
+                            <TicketRow
+                              key={gi.id}
+                              item={gi}
+                              selected={selectedItem?.id === gi.id}
+                              pinned={pinnedItemIds.has(gi.id)}
+                              activeAgents={issueActiveAgents.get(gi.id)}
+                              participants={participants}
+                              draggable
+                              multiSelected={multiSelectedItemIds.has(gi.id)}
+                              treeConnector={giIdx === groupItems.length - 1 ? "last" : "mid"}
+                              projectSlug={projectSlug}
+                              onSelect={(event) => {
+                                if (event && (event.metaKey || event.ctrlKey)) {
+                                  toggleItemMultiSelect(gi.id);
+                                } else {
+                                  pushSelection({
+                                    issue: gi.id,
+                                    run: null,
+                                    group: null,
+                                  });
+                                }
+                              }}
+                              onTogglePin={() => togglePin(gi.id)}
+                            />
+                          ))}
+                      </React.Fragment>
+                    );
+                  }
+
+                  // Skip grouped items (already rendered with their group)
+                  if (groupedItemIds.has(item.id)) return null;
+
+                  // Loose ticket
+                  const currentLooseIdx = looseIdx++;
+                  const prevLoose = currentLooseIdx > 0
+                    ? sortedItems.filter((i) => !groupedItemIds.has(i.id) && (!pendingSet || !pendingSet.has(i.id)))[currentLooseIdx - 1]
+                    : null;
+                  return (
+                    <React.Fragment key={item.id}>
+                      {pinnedItemIds.size > 0 &&
+                        !pinnedItemIds.has(item.id) &&
+                        (currentLooseIdx === 0 || (prevLoose && pinnedItemIds.has(prevLoose.id))) && (
+                          <div className="mx-4 border-t border-amber-500/20" />
+                        )}
+                      <TicketRow
+                        item={item}
+                        selected={selectedItem?.id === item.id}
+                        pinned={pinnedItemIds.has(item.id)}
+                        activeAgents={issueActiveAgents.get(item.id)}
+                        participants={participants}
+                        draggable
+                        multiSelected={multiSelectedItemIds.has(item.id)}
+                        projectSlug={projectSlug}
+                        onSelect={(event) => {
+                          if (event && (event.metaKey || event.ctrlKey)) {
+                            toggleItemMultiSelect(item.id);
+                          } else {
+                            pushSelection({
+                              issue: item.id,
+                              run: null,
+                              group: null,
+                            });
+                          }
+                        }}
+                        onTogglePin={() => togglePin(item.id)}
+                      />
+                    </React.Fragment>
+                  );
+                });
+              })()}
               {hasMore ? (
                 <div
                   ref={sentinelRef}
                   className="py-2 text-center text-xs text-[var(--muted-foreground)]"
                 >
-                  {issuesLoading ? "Loading..." : "Load more"}
+                  {itemsLoading ? "Loading..." : "Load more"}
                 </div>
               ) : null}
             </>
           )}
+          <SelectionBar
+            count={multiSelectedItemIds.size}
+            onGroup={handleMultiSelectGroup}
+            onClear={() => setMultiSelectedItemIds(new Set())}
+          />
         </div>
+        <DragOverlay dropAnimation={null}>
+          {dragActiveId && (() => {
+            const dragItem = sortedItems.find((i) => i.id === dragActiveId);
+            if (!dragItem) return null;
+            return (
+              <div className="flex items-center gap-3 rounded-lg border border-[var(--primary)]/30 bg-[var(--card-bg)] px-4 py-2.5 text-sm shadow-xl backdrop-blur-sm">
+                <span className="w-24 shrink-0 whitespace-nowrap font-mono text-xs text-[var(--muted-foreground)]">
+                  {dragItem.identifier}
+                </span>
+                <span className="min-w-0 flex-1 truncate text-xs font-medium text-[var(--foreground)]">
+                  {dragItem.title}
+                </span>
+              </div>
+            );
+          })()}
+        </DragOverlay>
+        </DndContext>
       </div>
 
       <ResizeHandle onResize={(delta) => setTicketPanelWidth((w) => { const next = Math.max(180, Math.min(600, w + delta)); persistLinearTicketPanelWidth(next); return next; })} />
@@ -1433,44 +1759,69 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
       <div className="flex min-w-0 flex-1 flex-col overflow-hidden">
         {selectedRun ? (
           <ThreadMessageList
-            issue={selectedIssue ?? {
+            item={selectedItem ?? {
               id: selectedRun.issueId,
               identifier: selectedRun.issueIdentifier,
               title: selectedRun.issueTitle,
-              url: null,
               status: selectedRun.issueStatus,
-              assignee: selectedRun.issueAssignee,
+              statusCategory: "todo",
+              labels: [],
+              trackerId: "",
+              trackerType,
+              assignee: selectedRun.issueAssignee ? { id: "", name: selectedRun.issueAssignee } : undefined,
               updatedAt: selectedRun.updatedAt,
+              createdAt: selectedRun.updatedAt,
+              url: "",
             }}
             run={selectedRun}
             participants={participants}
-            issueStatusOptions={issueStatusOptions}
-            issueStatusUpdating={updatingIssueId === selectedRun.issueId}
-            onIssueStatusChange={handleIssueStatusChange}
+            itemStatusOptions={itemStatusOptions}
+            itemStatusUpdating={updatingItemId === selectedRun.issueId}
+            onItemStatusChange={handleItemStatusChange}
             onBack={() => replaceSelection({ run: null })}
           />
-        ) : !selectedIssue ? (
+        ) : selectedGroup && !selectedItem ? (
+          <GroupPanel
+            group={selectedGroup}
+            items={items}
+            trackerType={trackerType}
+            participants={participants}
+            projectId={projectId}
+            projectSlug={projectSlug}
+            onUpdateName={(name) => updateGroup(selectedGroup.id, { name })}
+            onDelete={async () => {
+              await deleteGroup(selectedGroup.id);
+              replaceSelection({ group: null });
+            }}
+            onSelectItem={(itemId) =>
+              pushSelection({ issue: itemId, group: null, run: null })
+            }
+            onRunCreated={(runId) => pushSelection({ run: runId })}
+            onSelectRun={(runId) => pushSelection({ run: runId })}
+          />
+        ) : !selectedItem ? (
           <div className="flex h-full items-center justify-center text-xs text-[var(--muted-foreground)]">
             Select a ticket from the list.
           </div>
-        ) : participants.length === 0 ? (
+        ) : isAwaitingRestore ? null : participants.length === 0 ? (
           <div className="flex h-full items-center justify-center text-xs text-[var(--muted-foreground)]">
             Add at least one agent to this project to start a session.
           </div>
         ) : (
           <TicketPanel
-            key={selectedIssue.id}
-            issue={selectedIssue}
+            key={selectedItem.id}
+            item={selectedItem}
+            trackerType={trackerType}
             runs={runs}
             participants={participants}
             projectId={projectId}
             projectSlug={projectSlug}
-            issueStatusOptions={issueStatusOptions}
-            issueStatusUpdating={updatingIssueId === selectedIssue.id}
-            onIssueStatusChange={handleIssueStatusChange}
+            itemStatusOptions={itemStatusOptions}
+            itemStatusUpdating={updatingItemId === selectedItem.id}
+            onItemStatusChange={handleItemStatusChange}
             activeSessionScriptLabel={activeSessionScriptLabel}
             onOpenSessionScripts={() => setShowRunScripts(true)}
-            onStartScriptedSession={(event) => handleStartScriptedSession(selectedIssue, event)}
+            onStartScriptedSession={(event) => handleStartScriptedSession(selectedItem, event)}
             createRun={createRun}
             updateRun={updateRun}
             onRunCreated={(runId) => pushSelection({ run: runId })}
@@ -1483,7 +1834,8 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
 
       {/* Settings overlay */}
       {showSettings && (
-        <LinearSettingsModal
+        <TrackerSettingsModal
+          trackerType={trackerType}
           connected={connected}
           user={user}
           clis={clis}
@@ -1516,12 +1868,12 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
       ) : null}
 
       {/* Agent picker popover */}
-      {pickerIssue && pickerAnchor && (
+      {pickerItem && pickerAnchor && (
         <>
           <div
             className="fixed inset-0 z-40"
             onClick={() => {
-              setPickerIssue(null);
+              setPickerItem(null);
               setPickerAnchor(null);
             }}
           />
@@ -1537,7 +1889,7 @@ export default function LinearBoard({ projectId, projectSlug, initialShowSetting
                 key={agent.id}
                 type="button"
                 className="flex w-full items-center gap-2 px-3 py-1.5 text-left text-xs transition-colors hover:bg-[var(--card-bg)]"
-                onClick={() => void executeWithAgent(pickerIssue, agent)}
+                onClick={() => void executeWithAgent(pickerItem, agent)}
               >
                 <img
                   src={agentAvatarUrl(agent.id, agent.color, 20)}