Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

25.9 KB
Raw Blame
import { usePagedCollection } from '../../../hooks/usePagedCollection';
import InfiniteScrollFooter from '../../ui/InfiniteScrollFooter';
import { useState, useRef, useEffect, useCallback, useMemo } from 'react';
import { useSearchParams } from 'react-router';
import { ChevronDown, ChevronRight } from 'lucide-react';
import toast from '../../ui/Toast';
import {
  DndContext,
  closestCenter,
  KeyboardSensor,
  PointerSensor,
  useSensor,
  useSensors,
} from '@dnd-kit/core';
import {
  arrayMove,
  SortableContext,
  sortableKeyboardCoordinates,
  verticalListSortingStrategy,
} from '@dnd-kit/sortable';
import * as api from '../../../services/api';
import TaskItem, { taskRowId } from './TaskItem';
import SortableTaskItem from './SortableTaskItem';
import TaskAddForm from '../TaskAddForm';
import { MicroGlyph, SchematicLabel } from '../../micrographics';
import useAssignableInstances from '../../../hooks/useAssignableInstances';
import { formatCount } from '../../../utils/formatters';
import { runningAgentsByTaskId, isSpawningTask } from '../../../lib/cosSpawnWindow';
import BrailleSpinner from '../../BrailleSpinner';
import { isDeliveryCleanupHeld } from '../../../../../server/lib/taskRetryHold.js';
import { DeliveryRecoverySchedule } from '../DeliveryStatus';

// Maps a task-section status → micrographic glyph spec. Animation only on
// states where motion communicates real work happening (running tasks).
const SECTION_GLYPH = {
  pending:    { variant: 'pulse-dot',   state: 'warn',    animated: false },
  active:     { variant: 'scan',        state: 'accent',  animated: true  },
  blocked:    { variant: 'warning-tri', state: 'error',   animated: false },
  completed:  { variant: 'check-tick',  state: 'success', animated: false },
};

function SectionGlyph({ status }) {
  const spec = SECTION_GLYPH[status];
  if (!spec) return null;
  return <MicroGlyph variant={spec.variant} state={spec.state} animated={spec.animated} size={13} />;
}

export default function TasksTab({ completionRecovery, completedRevision = 0, tasks, agents = [], liveOutputs = {}, onRefresh, onTaskAdded, onTaskUnblocked, onTaskDeleted, providers, providersLoaded, apps }) {
  const [searchParams] = useSearchParams();
  const [userTasksLocal, setUserTasksLocal] = useState([]);
  const [durations, setDurations] = useState(null);
  const [showCompletedUserTasks, setShowCompletedUserTasks] = useState(false);
  const [showCompletedSystemTasks, setShowCompletedSystemTasks] = useState(false);
  const fetchUserHistory = useCallback(({ cursor, signal }) => api.getCosTasks({ view: 'completed', source: 'user', limit: 25, cursor, signal, silent: true }), []);
  const fetchSystemHistory = useCallback(({ cursor, signal }) => api.getCosTasks({ view: 'completed', source: 'internal', limit: 25, cursor, signal, silent: true }), []);
  const userHistory = usePagedCollection(fetchUserHistory, { enabled: showCompletedUserTasks && tasks.user?.completedCount != null });
  const systemHistory = usePagedCollection(fetchSystemHistory, { enabled: showCompletedSystemTasks && tasks.cos?.completedCount != null });
  const refreshHistory = () => { userHistory.reload(); systemHistory.reload(); onRefresh(); };

  const handleTaskDeleted = useCallback((taskId, taskSource) => {
    if (taskSource === 'user') {
      setUserTasksLocal(prev => prev.filter(t => t.id !== taskId));
      userHistory.setItems(prev => prev.filter(t => t.id !== taskId));
    } else if (taskSource === 'internal' || taskSource === 'cos') {
      systemHistory.setItems(prev => prev.filter(t => t.id !== taskId));
    } else {
      setUserTasksLocal(prev => prev.filter(t => t.id !== taskId));
      userHistory.setItems(prev => prev.filter(t => t.id !== taskId));
      systemHistory.setItems(prev => prev.filter(t => t.id !== taskId));
    }
    onTaskDeleted?.(taskId, taskSource);
  }, [onTaskDeleted, userHistory.setItems, systemHistory.setItems]);
  const historyVersion = useRef({ user: tasks.user?.completedCount, internal: tasks.cos?.completedCount, revision: completedRevision });
  useEffect(() => {
    const previous = historyVersion.current;
    const revisionChanged = previous.revision !== completedRevision;
    if (revisionChanged || previous.user !== tasks.user?.completedCount) userHistory.reload();
    if (revisionChanged || previous.internal !== tasks.cos?.completedCount) systemHistory.reload();
    historyVersion.current = { user: tasks.user?.completedCount, internal: tasks.cos?.completedCount, revision: completedRevision };
  }, [completedRevision, tasks.user?.completedCount, tasks.cos?.completedCount, userHistory.reload, systemHistory.reload]);

  // Fetched once for the whole list (#4520) — every row renders its instance pin
  // from this, so a long backlog never issues one request per task.
  const { instances: assignableInstances } = useAssignableInstances();

  // Fetch task duration estimates
  useEffect(() => {
    api.getCosLearningDurations()
      .then(setDurations)
      .catch(() => setDurations(null));
  }, []);

  // Memoize task arrays to prevent unnecessary re-renders
  const userTasks = useMemo(() => [...new Map([...userHistory.items, ...(tasks.user?.tasks || [])].map(task => [task.id, task])).values()], [tasks.user?.tasks, userHistory.items]);
  const cosTasks = useMemo(() => [...new Map([...systemHistory.items, ...(tasks.cos?.tasks || [])].map(task => [task.id, task])).values()], [tasks.cos?.tasks, systemHistory.items]);
  const selectedTaskId = searchParams.get('task');
  const requestedSource = searchParams.get('source');
  const selectedTaskSource = useMemo(() => {
    if (!selectedTaskId) return null;
    if (requestedSource === 'user' || requestedSource === 'internal') return requestedSource;
    if (userTasks.some((task) => task.id === selectedTaskId)) return 'user';
    if (cosTasks.some((task) => task.id === selectedTaskId)) return 'internal';
    return null;
  }, [cosTasks, requestedSource, selectedTaskId, userTasks]);
  const isTaskSelected = (task, source) => (
    task.id === selectedTaskId && source === selectedTaskSource
  );

  // The live agent working each task, keyed by task id — mid-spawn tasks are
  // active, not queued (lib/cosSpawnWindow.js). Settled client-side here rather
  // than trusting the route's `spawning` stamp because this tab also has the
  // socket agent feed, which lands ~400ms ahead of the next task refetch; the
  // map is what lets an Active row offer relaunch without its own agent fetch.
  const runningAgentByTaskId = useMemo(() => runningAgentsByTaskId(agents), [agents]);
  const agentById = useMemo(() => new Map(agents.map(agent => [agent.id, agent])), [agents]);

  const isSpawning = useCallback(
    (task) => isSpawningTask(task, runningAgentByTaskId),
    [runningAgentByTaskId]
  );
  const isFinalizing = useCallback(task => task.status === 'in_progress'
    && isDeliveryCleanupHeld(task.metadata) && !runningAgentByTaskId.has(task.id), [runningAgentByTaskId]);

  // Split tasks by status for system tasks
  const pendingSystemTasks = useMemo(() =>
    cosTasks.filter(t => t.status === 'pending' && !isSpawning(t)),
    [cosTasks, isSpawning]
  );
  const activeSystemTasks = useMemo(() =>
    cosTasks.filter(t => (t.status === 'in_progress' || isSpawning(t)) && !isFinalizing(t)),
    [cosTasks, isSpawning, isFinalizing]
  );
  const finalizingSystemTasks = useMemo(() => cosTasks.filter(isFinalizing), [cosTasks, isFinalizing]);
  const blockedSystemTasks = useMemo(() =>
    cosTasks.filter(t => t.status === 'blocked'),
    [cosTasks]
  );
  const completedSystemTasks = useMemo(() =>
    cosTasks.filter(t => t.status === 'completed'),
    [cosTasks]
  );

  // Split user tasks by status (only pending tasks are sortable)
  const pendingUserTasksLocal = useMemo(() =>
    userTasksLocal.filter(t => t.status === 'pending' && !isSpawning(t)),
    [userTasksLocal, isSpawning]
  );
  const activeUserTasksLocal = useMemo(() =>
    userTasksLocal.filter(t => (t.status === 'in_progress' || isSpawning(t)) && !isFinalizing(t)),
    [userTasksLocal, isSpawning, isFinalizing]
  );
  const finalizingUserTasksLocal = useMemo(() => userTasksLocal.filter(isFinalizing), [userTasksLocal, isFinalizing]);
  const blockedUserTasksLocal = useMemo(() =>
    userTasksLocal.filter(t => t.status === 'blocked'),
    [userTasksLocal]
  );
  const completedUserTasksLocal = useMemo(() =>
    userTasksLocal.filter(t => t.status === 'completed'),
    [userTasksLocal]
  );

  // Memoize sortable item IDs for DndContext (only pending tasks)
  const sortableIds = useMemo(() =>
    pendingUserTasksLocal.map(t => t.id),
    [pendingUserTasksLocal]
  );

  // Keep local state in sync with server state
  useEffect(() => {
    setUserTasksLocal(userTasks);
  }, [userTasks]);

  const focusedSelection = useRef(false);
  useEffect(() => {
    focusedSelection.current = false;
  }, [selectedTaskId, selectedTaskSource]);

  // Queue summary links identify one concrete task. Completed sections are
  // collapsed by default, so open the relevant one before attempting to focus
  // and center the row.
  useEffect(() => {
    if (!selectedTaskId || !selectedTaskSource || focusedSelection.current) return;
    const selected = (selectedTaskSource === 'user' ? userTasks : cosTasks)
      .find((task) => task.id === selectedTaskId);
    if (selected?.status !== 'completed') return;
    if (selectedTaskSource === 'user') setShowCompletedUserTasks(true);
    else setShowCompletedSystemTasks(true);
  }, [cosTasks, selectedTaskId, selectedTaskSource, userTasks]);

  useEffect(() => {
    if (!selectedTaskId || !selectedTaskSource || focusedSelection.current) return;
    const row = document.getElementById(taskRowId(selectedTaskId, selectedTaskSource));
    if (!row) return;
    row.scrollIntoView?.({ block: 'center' });
    row.focus({ preventScroll: true });
    focusedSelection.current = true;
  }, [
    cosTasks,
    selectedTaskId,
    selectedTaskSource,
    showCompletedSystemTasks,
    showCompletedUserTasks,
    userTasksLocal,
  ]);

  // Drag and drop sensors
  const sensors = useSensors(
    useSensor(PointerSensor, {
      activationConstraint: { distance: 8 },
    }),
    useSensor(KeyboardSensor, {
      coordinateGetter: sortableKeyboardCoordinates,
    })
  );

  const handleDragEnd = async (event) => {
    const { active, over } = event;
    if (!over || active.id === over.id) return;

    const oldIndex = userTasksLocal.findIndex(t => t.id === active.id);
    const newIndex = userTasksLocal.findIndex(t => t.id === over.id);

    // Optimistically update local state
    const newOrder = arrayMove(userTasksLocal, oldIndex, newIndex);
    setUserTasksLocal(newOrder);

    // Persist to server
    const taskIds = newOrder.map(t => t.id);
    const result = await api.reorderCosTasks(taskIds, { silent: true }).catch(err => {
      toast.error(err.message);
      setUserTasksLocal(userTasks); // Revert on error
      return null;
    });
    if (result?.success) {
      toast.success('Tasks reordered');
      onRefresh();
    }
  };

  const handleTaskAdded = useCallback((task, options) => {
    onTaskAdded?.(task, options);
    // Keep the established authoritative refresh for agent/status data. The
    // parent has already inserted the task above, so this can never make a
    // successful submission appear to disappear while the refresh is pending.
    onRefresh();
  }, [onRefresh, onTaskAdded]);

  const isUserLoading = tasks?.user == null;
  const isCosLoading = tasks?.cos == null;
  const isQueueLoading = isUserLoading || isCosLoading;
  const renderFinalizingTasks = (rows, source) => rows.length > 0 && (
    <section aria-label={`${source === 'internal' ? 'System' : 'User'} tasks finalizing delivery`} className="bg-port-card border border-port-border rounded-lg overflow-hidden">
      <h3 className="px-3 py-2 text-sm font-medium text-gray-400 border-b border-port-border">
        Finalizing delivery ({formatCount(rows.length)})
      </h3>
      <DeliveryRecoverySchedule recovery={completionRecovery} />
      <div className="p-2 space-y-1.5">
        {rows.map(task => (
          <TaskItem key={task.id} task={task} isSystem={source === 'internal'} selected={isTaskSelected(task, source)}
            agent={agentById.get(task.metadata.deliveryRecoveryAgentId)}
            onRefresh={onRefresh} onTaskUnblocked={onTaskUnblocked} onTaskDeleted={handleTaskDeleted}
            providers={providers} providersLoaded={providersLoaded} durations={durations} apps={apps} instances={assignableInstances} />
        ))}
      </div>
    </section>
  );

  return (
    <div className="space-y-6">
      {/* User Tasks */}
      <div>
        <div className="mb-3">
          <h2 className="text-lg font-semibold text-white">Task queue</h2>
        </div>

        <p className="mb-3 text-sm text-gray-400" aria-label="Queue status">
          {isQueueLoading ? (
            <BrailleSpinner text="Loading task queue…" />
          ) : (
            <>
              {formatCount(pendingUserTasksLocal.length + pendingSystemTasks.length)} pending
              {' · '}{formatCount(activeUserTasksLocal.length + activeSystemTasks.length)} active
              {' · '}{formatCount(finalizingUserTasksLocal.length + finalizingSystemTasks.length)} finalizing
              {' · '}{formatCount(blockedUserTasksLocal.length + blockedSystemTasks.length)} blocked
            </>
          )}
        </p>
        {/* Compact capture keeps the queue above detailed configuration. */}
        <TaskAddForm queueFirst providers={providers} providersLoaded={providersLoaded} apps={apps} onTaskAdded={handleTaskAdded} />

        {/* User Tasks Sections */}
        {isUserLoading ? (
          <div className="relative bg-port-card border border-port-border rounded-lg p-6 text-center text-gray-400">
            <BrailleSpinner text="Loading task queue…" />
          </div>
        ) : pendingUserTasksLocal.length === 0 && activeUserTasksLocal.length === 0 && finalizingUserTasksLocal.length === 0 && blockedUserTasksLocal.length === 0 && (tasks.user?.completedCount ?? completedUserTasksLocal.length) === 0 ? (
          <div className="relative bg-port-card border border-port-border rounded-lg p-6 text-center text-gray-500">
            <SchematicLabel module="USER" status="EMPTY" glyph="bracket-pair" state="idle" variant="tab" />
            No user tasks. Add one above.
          </div>
        ) : (
          <div className="space-y-3">
            {/* Pending Section */}
            {pendingUserTasksLocal.length > 0 && (
              <div className="bg-port-card border border-port-border rounded-lg overflow-hidden">
                <div className="px-3 py-2 bg-port-warning/10 border-b border-port-border flex items-center justify-between">
                  <span className="text-sm font-medium text-port-warning flex items-center gap-2">
                    <SectionGlyph status="pending" />
                    Pending ({pendingUserTasksLocal.length})
                  </span>
                </div>
                <div className="p-2">
                  <DndContext
                    sensors={sensors}
                    collisionDetection={closestCenter}
                    onDragEnd={handleDragEnd}
                  >
                    <SortableContext
                      items={sortableIds}
                      strategy={verticalListSortingStrategy}
                    >
                      <div className="space-y-1.5">
                        {pendingUserTasksLocal.map(task => (
                          <SortableTaskItem key={task.id} task={task} selected={isTaskSelected(task, 'user')} onRefresh={onRefresh} onTaskUnblocked={onTaskUnblocked} onTaskDeleted={handleTaskDeleted} providers={providers} providersLoaded={providersLoaded} durations={durations} apps={apps} instances={assignableInstances} />
                        ))}
                      </div>
                    </SortableContext>
                  </DndContext>
                </div>
              </div>
            )}

            {/* Active Section */}
            {activeUserTasksLocal.length > 0 && (
              <div className="bg-port-card border border-port-border rounded-lg overflow-hidden">
                <div className="px-3 py-2 bg-port-accent/10 border-b border-port-border flex items-center justify-between">
                  <span className="text-sm font-medium text-port-accent flex items-center gap-2">
                    <SectionGlyph status="active" />
                    Active ({activeUserTasksLocal.length})
                  </span>
                </div>
                <div className="p-2 space-y-1.5">
                  {activeUserTasksLocal.map(task => (
                    <TaskItem key={task.id} task={task} agent={runningAgentByTaskId.get(task.id)} liveOutput={liveOutputs[runningAgentByTaskId.get(task.id)?.id]} spawning={isSpawning(task)} selected={isTaskSelected(task, 'user')} onRefresh={onRefresh} onTaskUnblocked={onTaskUnblocked} onTaskDeleted={handleTaskDeleted} providers={providers} providersLoaded={providersLoaded} durations={durations} apps={apps} instances={assignableInstances} />
                  ))}
                </div>
              </div>
            )}

            {renderFinalizingTasks(finalizingUserTasksLocal, 'user')}

            {/* Blocked Section */}
            {blockedUserTasksLocal.length > 0 && (
              <div className="bg-port-card border border-port-border rounded-lg overflow-hidden">
                <div className="px-3 py-2 bg-port-error/10 border-b border-port-border flex items-center justify-between">
                  <span className="text-sm font-medium text-port-error flex items-center gap-2">
                    <SectionGlyph status="blocked" />
                    Blocked ({blockedUserTasksLocal.length})
                  </span>
                </div>
                <div className="p-2 space-y-1.5">
                  {blockedUserTasksLocal.map(task => (
                    <TaskItem key={task.id} task={task} selected={isTaskSelected(task, 'user')} onRefresh={onRefresh} onTaskUnblocked={onTaskUnblocked} onTaskDeleted={handleTaskDeleted} providers={providers} providersLoaded={providersLoaded} durations={durations} apps={apps} instances={assignableInstances} />
                  ))}
                </div>
              </div>
            )}

            {/* Completed Section - Collapsible */}
            {(tasks.user?.completedCount ?? completedUserTasksLocal.length) > 0 && (
              <div className="bg-port-card border border-port-border rounded-lg overflow-hidden">
                <button
                  onClick={() => setShowCompletedUserTasks(!showCompletedUserTasks)}
                  className="w-full px-3 py-2 bg-port-success/10 border-b border-port-border flex items-center justify-between hover:bg-port-success/20 transition-colors"
                  aria-expanded={showCompletedUserTasks}
                >
                  <span className="text-sm font-medium text-port-success flex items-center gap-2">
                    {showCompletedUserTasks ? <ChevronDown size={14} aria-hidden="true" /> : <ChevronRight size={14} aria-hidden="true" />}
                    <SectionGlyph status="completed" />
                    Completed ({tasks.user?.completedCount ?? completedUserTasksLocal.length})
                  </span>
                </button>
                {showCompletedUserTasks && (
                  <div className="p-2 space-y-1.5">
                    {completedUserTasksLocal.map(task => (
                      <TaskItem key={task.id} task={task} selected={isTaskSelected(task, 'user')} onRefresh={refreshHistory} onTaskUnblocked={onTaskUnblocked} onTaskDeleted={handleTaskDeleted} providers={providers} providersLoaded={providersLoaded} durations={durations} apps={apps} instances={assignableInstances} />
                    ))}
                    {tasks.user?.completedCount != null && <InfiniteScrollFooter hasMore={userHistory.hasMore} loading={userHistory.loading} error={userHistory.error} onLoadMore={userHistory.loadMore} />}
                  </div>
                )}
              </div>
            )}
          </div>
        )}
      </div>

      {/* System Tasks */}
      <div>
        <h3 className="text-lg font-semibold text-white mb-3">System Tasks</h3>

        {/* System Tasks Sections */}
        {isCosLoading ? (
          <div className="relative bg-port-card border border-port-border rounded-lg p-6 text-center text-gray-400">
            <BrailleSpinner text="Loading system tasks…" />
          </div>
        ) : pendingSystemTasks.length === 0 && activeSystemTasks.length === 0 && finalizingSystemTasks.length === 0 && blockedSystemTasks.length === 0 && (tasks.cos?.completedCount ?? completedSystemTasks.length) === 0 ? (
          <div className="relative bg-port-card border border-port-border rounded-lg p-6 text-center text-gray-500">
            <SchematicLabel module="COS" status="EMPTY" glyph="bracket-pair" state="idle" variant="tab" />
            No system tasks.
          </div>
        ) : (
          <div className="space-y-3">
            {/* Pending Section */}
            {pendingSystemTasks.length > 0 && (
              <div className="bg-port-card border border-port-border rounded-lg overflow-hidden">
                <div className="px-3 py-2 bg-port-warning/10 border-b border-port-border flex items-center justify-between">
                  <span className="text-sm font-medium text-port-warning flex items-center gap-2">
                    <SectionGlyph status="pending" />
                    Pending ({pendingSystemTasks.length})
                  </span>
                </div>
                <div className="p-2 space-y-1.5">
                  {pendingSystemTasks.map(task => (
                    <TaskItem key={task.id} task={task} isSystem selected={isTaskSelected(task, 'internal')} onRefresh={onRefresh} onTaskUnblocked={onTaskUnblocked} onTaskDeleted={handleTaskDeleted} providers={providers} providersLoaded={providersLoaded} durations={durations} apps={apps} instances={assignableInstances} />
                  ))}
                </div>
              </div>
            )}

            {/* Active Section */}
            {activeSystemTasks.length > 0 && (
              <div className="bg-port-card border border-port-border rounded-lg overflow-hidden">
                <div className="px-3 py-2 bg-port-accent/10 border-b border-port-border flex items-center justify-between">
                  <span className="text-sm font-medium text-port-accent flex items-center gap-2">
                    <SectionGlyph status="active" />
                    Active ({activeSystemTasks.length})
                  </span>
                </div>
                <div className="p-2 space-y-1.5">
                  {activeSystemTasks.map(task => (
                    <TaskItem key={task.id} task={task} isSystem agent={runningAgentByTaskId.get(task.id)} liveOutput={liveOutputs[runningAgentByTaskId.get(task.id)?.id]} spawning={isSpawning(task)} selected={isTaskSelected(task, 'internal')} onRefresh={onRefresh} onTaskUnblocked={onTaskUnblocked} onTaskDeleted={handleTaskDeleted} providers={providers} providersLoaded={providersLoaded} durations={durations} apps={apps} instances={assignableInstances} />
                  ))}
                </div>
              </div>
            )}

            {renderFinalizingTasks(finalizingSystemTasks, 'internal')}

            {/* Blocked Section */}
            {blockedSystemTasks.length > 0 && (
              <div className="bg-port-card border border-port-border rounded-lg overflow-hidden">
                <div className="px-3 py-2 bg-port-error/10 border-b border-port-border flex items-center justify-between">
                  <span className="text-sm font-medium text-port-error flex items-center gap-2">
                    <SectionGlyph status="blocked" />
                    Blocked ({blockedSystemTasks.length})
                  </span>
                </div>
                <div className="p-2 space-y-1.5">
                  {blockedSystemTasks.map(task => (
                    <TaskItem key={task.id} task={task} isSystem selected={isTaskSelected(task, 'internal')} onRefresh={onRefresh} onTaskUnblocked={onTaskUnblocked} onTaskDeleted={handleTaskDeleted} providers={providers} providersLoaded={providersLoaded} durations={durations} apps={apps} instances={assignableInstances} />
                  ))}
                </div>
              </div>
            )}

            {/* Completed Section - Collapsible */}
            {(tasks.cos?.completedCount ?? completedSystemTasks.length) > 0 && (
              <div className="bg-port-card border border-port-border rounded-lg overflow-hidden">
                <button
                  onClick={() => setShowCompletedSystemTasks(!showCompletedSystemTasks)}
                  className="w-full px-3 py-2 bg-port-success/10 border-b border-port-border flex items-center justify-between hover:bg-port-success/20 transition-colors"
                  aria-expanded={showCompletedSystemTasks}
                >
                  <span className="text-sm font-medium text-port-success flex items-center gap-2">
                    {showCompletedSystemTasks ? <ChevronDown size={14} aria-hidden="true" /> : <ChevronRight size={14} aria-hidden="true" />}
                    <SectionGlyph status="completed" />
                    Completed ({tasks.cos?.completedCount ?? completedSystemTasks.length})
                  </span>
                </button>
                {showCompletedSystemTasks && (
                  <div className="p-2 space-y-1.5">
                    {completedSystemTasks.map(task => (
                      <TaskItem key={task.id} task={task} isSystem selected={isTaskSelected(task, 'internal')} onRefresh={refreshHistory} onTaskUnblocked={onTaskUnblocked} onTaskDeleted={handleTaskDeleted} providers={providers} providersLoaded={providersLoaded} durations={durations} apps={apps} instances={assignableInstances} />
                    ))}
                    {tasks.cos?.completedCount != null && <InfiniteScrollFooter hasMore={systemHistory.hasMore} loading={systemHistory.loading} error={systemHistory.error} onLoadMore={systemHistory.loadMore} />}
                  </div>
                )}
              </div>
            )}
          </div>
        )}
      </div>

    </div>
  );
}