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
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
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>
);
}