@parhelia/core 0.1.12241 → 0.1.12259

package/dist/task-board/TaskBoardWorkspace.js

@@ -2,8 +2,8 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { toast } from "sonner";
 import { Splitter } from "../editor/ui/Splitter";
-import { deleteProject, getProjects, getTasks, getDependencies, getWizardGuidance, runOrchestrator, triggerPlanning, updateProject, updateTask, } from "./services/taskService";
-import { getActiveAgents, getAgent, startAgent, } from "../editor/services/agentService";
+import { deleteProject, getProjects, getTasks, getDependencies, runOrchestrator, triggerPlanning, updateProject, updateTask, } from "./services/taskService";
+import { getActiveAgents, getAgent, } from "../editor/services/agentService";
 import { loadAiProfiles } from "../editor/services/aiService";
 import { useEditContext } from "../editor/client/editContext";
 import { KanbanView } from "./views/KanbanView";
@@ -20,11 +20,13 @@ import { ProjectSettingsDialog } from "./components/ProjectSettingsDialog";
 import { EditorSlotContextProvider } from "../editor/views/editorSlotContext";
 import { SingleEditView } from "../editor/views/SingleEditView";
 import { Select } from "../components/ui/select";
-import { Dialog, DialogContent, DialogHeader, DialogTitle, } from "../components/ui/dialog";
 import { getLinkedAgentId } from "./taskAgentLink";
 import { setTaskBoardNavState, resetTaskBoardNavState, } from "./taskBoardNavStore";
 import { flattenProjectsHierarchy } from "./utils/projectHierarchy";
 import { normalizeTaskStatus } from "./taskStatus";
+import { getTaskExecutionDisplay, } from "./taskExecutionStatus";
+import { WizardCommunicationCenter } from "./components/WizardCommunicationCenter";
+import { Loader2 } from "lucide-react";
 const TASKBOARD_PROJECT_QUERY_KEY = "tbProjectId";
 const TASKBOARD_TASK_QUERY_KEY = "tbTaskId";
 const TASKBOARD_VIEW_QUERY_KEY = "tbView";
@@ -43,13 +45,25 @@ function getInitialWizardMode() {
     const value = getInitialQueryValue(TASKBOARD_WIZARD_QUERY_KEY)?.toLowerCase();
     return value === "true" || value === "1";
 }
+function getTaskBoardStateFromUrl() {
+    const projectId = getInitialQueryValue(TASKBOARD_PROJECT_QUERY_KEY);
+    return {
+        projectId,
+        taskId: projectId ? getInitialQueryValue(TASKBOARD_TASK_QUERY_KEY) : null,
+        activeTab: getInitialViewTabIndex(),
+        isWizardMode: getInitialWizardMode(),
+    };
+}
 function normalizeAgentStatus(status) {
     if (status === undefined || status === null)
         return undefined;
     if (typeof status === "number") {
         return status;
     }
-    const normalized = String(status).trim().replace(/[^a-z0-9]/gi, "").toLowerCase();
+    const normalized = String(status)
+        .trim()
+        .replace(/[^a-z0-9]/gi, "")
+        .toLowerCase();
     switch (normalized) {
         case "running":
             return "running";
@@ -97,12 +111,71 @@ function normalizeAgentStatus(status) {
             return status;
     }
 }
+function isClosedAgentStatus(status) {
+    if (status === undefined || status === null)
+        return false;
+    if (typeof status === "number")
+        return status === 5;
+    return (String(status)
+        .replace(/[^a-z0-9]/gi, "")
+        .toLowerCase() === "closed");
+}
+function getAgentStatusById(agentStatusesById, agentId) {
+    if (!agentId)
+        return undefined;
+    return agentStatusesById[agentId] ?? agentStatusesById[agentId.toLowerCase()];
+}
+function getTaskAgentStatus(task, agentStatusesById) {
+    const linkedAgentId = getLinkedAgentId(task ?? null);
+    const liveStatus = getAgentStatusById(agentStatusesById, linkedAgentId);
+    if (liveStatus !== undefined) {
+        return liveStatus;
+    }
+    return normalizeAgentStatus(task?.agentStatus);
+}
+function addAgentDisplayNames(taskList, agentProfileTitlesById) {
+    return taskList.map((task) => {
+        if (task.assigneeType !== "Agent" ||
+            !task.assigneeId ||
+            task.assigneeDisplayName) {
+            return task;
+        }
+        const profileTitle = agentProfileTitlesById[task.assigneeId.toLowerCase()];
+        if (!profileTitle)
+            return task;
+        return {
+            ...task,
+            assigneeDisplayName: profileTitle,
+        };
+    });
+}
+function buildTaskCounts(taskList) {
+    const counts = {
+        total: taskList.length,
+        todo: 0,
+        inProgress: 0,
+        review: 0,
+        done: 0,
+    };
+    for (const task of taskList) {
+        const normalizedStatus = normalizeTaskStatus(task.status, task.executionStatus);
+        if (normalizedStatus === "Todo")
+            counts.todo += 1;
+        else if (normalizedStatus === "InProgress")
+            counts.inProgress += 1;
+        else if (normalizedStatus === "Review")
+            counts.review += 1;
+        else if (normalizedStatus === "Done")
+            counts.done += 1;
+    }
+    return counts;
+}
 // ── component ────────────────────────────────────────────────────────
 export function TaskBoardWorkspace() {
     const editContext = useEditContext();
     const isAdministrator = editContext?.user?.isAdministrator === true;
     const isMobile = editContext?.isMobile ?? false;
-    const showEditorPanel = editContext?.showAgentsWorkspaceEditor ?? true;
+    const showEditorPanel = editContext?.showAgentsWorkspaceEditor ?? false;
     useEffect(() => {
         if (editContext?.isMobile && !showEditorPanel) {
             editContext?.setShowAgentsWorkspaceEditor(true);
@@ -113,6 +186,7 @@ export function TaskBoardWorkspace() {
     const [mobileActiveTab, setMobileActiveTab] = useState(0);
     const [selectedProjectId, setSelectedProjectId] = useState(() => getInitialQueryValue(TASKBOARD_PROJECT_QUERY_KEY));
     const [tasks, setTasks] = useState([]);
+    const [isTasksLoading, setIsTasksLoading] = useState(false);
     const [dependencies, setDependencies] = useState([]);
     const [selectedTaskId, setSelectedTaskId] = useState(() => getInitialQueryValue(TASKBOARD_TASK_QUERY_KEY));
     const [activeTab, setActiveTab] = useState(() => getInitialViewTabIndex());
@@ -125,25 +199,28 @@ export function TaskBoardWorkspace() {
     const [runningOrchestrator, setRunningOrchestrator] = useState(false);
     const [showAllProjects, setShowAllProjects] = useState(false);
     const [isProjectsLoading, setIsProjectsLoading] = useState(false);
+    const [projectViewLoadingId, setProjectViewLoadingId] = useState(null);
     const [agentStatusesById, setAgentStatusesById] = useState({});
     const [agentProfileTitlesById, setAgentProfileTitlesById] = useState({});
     const [subprojectTaskCounts, setSubprojectTaskCounts] = useState({});
+    const [subprojectTasksByProjectId, setSubprojectTasksByProjectId] = useState({});
     const [subprojectCountsLoading, setSubprojectCountsLoading] = useState(false);
     const [previewItemName, setPreviewItemName] = useState("");
     const [previewItemPath, setPreviewItemPath] = useState("");
     const [agentContextItems, setAgentContextItems] = useState([]);
     const [contextItemNamesByKey, setContextItemNamesByKey] = useState({});
     const [contextItemPathsByKey, setContextItemPathsByKey] = useState({});
-    const [wizardGuidance, setWizardGuidance] = useState(null);
-    const [wizardGuidanceLoading, setWizardGuidanceLoading] = useState(false);
-    const [wizardActionInFlightId, setWizardActionInFlightId] = useState(null);
-    const [wizardAgentDialogOpen, setWizardAgentDialogOpen] = useState(false);
+    const [wizardPinnedTaskId, setWizardPinnedTaskId] = useState(null);
+    const [wizardForceOverview, setWizardForceOverview] = useState(false);
     const wsRefreshTimeoutRef = useRef(null);
     const wsSubprojectRefreshTimeoutRef = useRef(null);
     const wsProjectRefreshTimeoutRef = useRef(null);
-    const wizardGuidanceTimeoutRef = useRef(null);
-    const wizardGuidanceRequestSeqRef = useRef(0);
+    const wizardCloseTransitionTimeoutRef = useRef(null);
     const projectsRequestCountRef = useRef(0);
+    const tasksRequestCountRef = useRef(0);
+    const latestTasksProjectIdRef = useRef(null);
+    const latestDependenciesProjectIdRef = useRef(null);
+    const latestSubprojectCountsProjectIdRef = useRef(null);
     const refreshProjectsRef = useRef(null);
     const refreshTasksRef = useRef(null);
     const refreshDependenciesRef = useRef(null);
@@ -155,6 +232,14 @@ export function TaskBoardWorkspace() {
     const autoSelectedProjectIdsRef = useRef(new Set());
     const taskBoardSubscribedAgentIdsRef = useRef(new Set());
     const taskBoardSocketVersionRef = useRef(null);
+    const syncTaskBoardStateFromUrl = useCallback(() => {
+        const nextState = getTaskBoardStateFromUrl();
+        setSelectedProjectId(nextState.projectId);
+        setSelectedTaskId(nextState.taskId);
+        setActiveTab(nextState.activeTab);
+        setIsWizardMode(nextState.isWizardMode);
+        setWizardForceOverview(false);
+    }, []);
     useEffect(() => {
         let cancelled = false;
         loadAiProfiles()
@@ -177,50 +262,35 @@ export function TaskBoardWorkspace() {
             cancelled = true;
         };
     }, []);
-    const tasksWithDisplayAssignees = useMemo(() => {
-        return tasks.map((task) => {
-            if (task.assigneeType !== "Agent" ||
-                !task.assigneeId ||
-                task.assigneeDisplayName) {
-                return task;
-            }
-            const profileTitle = agentProfileTitlesById[task.assigneeId.toLowerCase()];
-            if (!profileTitle)
-                return task;
-            return {
-                ...task,
-                assigneeDisplayName: profileTitle,
-            };
-        });
-    }, [tasks, agentProfileTitlesById]);
+    const tasksWithDisplayAssignees = useMemo(() => addAgentDisplayNames(tasks, agentProfileTitlesById), [tasks, agentProfileTitlesById]);
     const selectedProject = useMemo(() => projects.find((p) => p.project.projectId === selectedProjectId) ?? null, [projects, selectedProjectId]);
     const settingsProject = useMemo(() => projects.find((p) => p.project.projectId === settingsProjectId) ?? null, [projects, settingsProjectId]);
-    const selectedProjectTaskCounts = useMemo(() => {
-        const counts = {
-            total: tasks.length,
-            todo: 0,
-            inProgress: 0,
-            review: 0,
-            done: 0,
-        };
-        for (const task of tasks) {
-            const normalizedStatus = normalizeTaskStatus(task.status, task.executionStatus);
-            if (normalizedStatus === "Todo")
-                counts.todo += 1;
-            else if (normalizedStatus === "InProgress")
-                counts.inProgress += 1;
-            else if (normalizedStatus === "Review")
-                counts.review += 1;
-            else if (normalizedStatus === "Done")
-                counts.done += 1;
-        }
-        return counts;
-    }, [tasks]);
+    const selectedProjectTaskCounts = useMemo(() => buildTaskCounts(tasks), [tasks]);
     const directSubprojects = useMemo(() => selectedProjectId
         ? projects
             .filter((project) => project.project.parentProjectId === selectedProjectId)
             .sort((a, b) => a.project.title.localeCompare(b.project.title))
         : [], [projects, selectedProjectId]);
+    const subprojectTasksWithDisplayAssignees = useMemo(() => {
+        const nextTasks = {};
+        for (const [projectId, taskList] of Object.entries(subprojectTasksByProjectId)) {
+            nextTasks[projectId] = addAgentDisplayNames(taskList, agentProfileTitlesById);
+        }
+        return nextTasks;
+    }, [subprojectTasksByProjectId, agentProfileTitlesById]);
+    const wizardSubprojectTaskLists = useMemo(() => directSubprojects.map((subproject) => ({
+        projectId: subproject.project.projectId,
+        title: subproject.project.title,
+        tasks: subprojectTasksWithDisplayAssignees[subproject.project.projectId] ||
+            [],
+    })), [directSubprojects, subprojectTasksWithDisplayAssignees]);
+    const wizardTasksWithDisplayAssignees = useMemo(() => [
+        ...tasksWithDisplayAssignees,
+        ...wizardSubprojectTaskLists.flatMap((subproject) => subproject.tasks),
+    ], [tasksWithDisplayAssignees, wizardSubprojectTaskLists]);
+    const taskSelectionUniverse = useMemo(() => isWizardMode
+        ? wizardTasksWithDisplayAssignees
+        : tasksWithDisplayAssignees, [isWizardMode, wizardTasksWithDisplayAssignees, tasksWithDisplayAssignees]);
     const selectedProjectCumulativeCostUsed = useMemo(() => {
         if (!selectedProjectId)
             return 0;
@@ -308,14 +378,28 @@ export function TaskBoardWorkspace() {
         setSelectedProjectId((previousProjectId) => {
             if (previousProjectId !== projectId) {
                 setSelectedTaskId(null);
+                setWizardForceOverview(false);
             }
             return projectId;
         });
     }, []);
+    const clearSelectedProjectData = useCallback(() => {
+        setTasks([]);
+        setDependencies([]);
+        setSubprojectTaskCounts({});
+        setSubprojectTasksByProjectId({});
+        setAgentStatusesById({});
+    }, []);
     const isPlanning = selectedProject?.project.status === "Planning";
-    const selectedProjectIsActive = selectedProject?.project.status === "Active";
-    const selectedTask = useMemo(() => tasksWithDisplayAssignees.find((t) => t.taskId === selectedTaskId) ??
-        null, [tasksWithDisplayAssignees, selectedTaskId]);
+    const selectedTask = useMemo(() => taskSelectionUniverse.find((t) => t.taskId === selectedTaskId) ?? null, [taskSelectionUniverse, selectedTaskId]);
+    const wizardPinnedTask = useMemo(() => wizardPinnedTaskId
+        ? (taskSelectionUniverse.find((task) => task.taskId === wizardPinnedTaskId) ?? null)
+        : null, [taskSelectionUniverse, wizardPinnedTaskId]);
+    const selectedTaskProject = useMemo(() => {
+        if (!selectedTask)
+            return selectedProject;
+        return (projects.find((project) => project.project.projectId === selectedTask.projectId) ?? selectedProject);
+    }, [projects, selectedProject, selectedTask]);
     const planningTask = useMemo(() => tasksWithDisplayAssignees.find((t) => String(t.taskType ?? "").toLowerCase() === "plan") ??
         tasksWithDisplayAssignees.find((t) => t.title === "Project Plan") ??
         null, [tasksWithDisplayAssignees]);
@@ -326,6 +410,8 @@ export function TaskBoardWorkspace() {
     const selectedTaskIsBlocked = useMemo(() => {
         if (!selectedTask)
             return false;
+        if (selectedTask.projectId !== selectedProjectId)
+            return false;
         const blockerIds = dependencies
             .filter((dependency) => dependency.taskId === selectedTask.taskId &&
             dependency.dependencyType === "BlockedBy")
@@ -337,38 +423,80 @@ export function TaskBoardWorkspace() {
             const blockerTask = taskById.get(blockerId);
             return !blockerTask || blockerTask.status !== "Done";
         });
-    }, [selectedTask, dependencies, tasksWithDisplayAssignees]);
+    }, [
+        selectedTask,
+        selectedProjectId,
+        dependencies,
+        tasksWithDisplayAssignees,
+    ]);
     const selectedTaskHasAssignedAgentProfile = useMemo(() => {
         if (!selectedTask)
             return false;
         return selectedTask.assigneeType === "Agent" && !!selectedTask.assigneeId;
     }, [selectedTask]);
     const canRunAssignedAgent = useMemo(() => {
-        return !selectedTaskIsBlocked && selectedProjectIsActive;
-    }, [selectedTaskIsBlocked, selectedProjectIsActive]);
+        return !selectedTaskIsBlocked;
+    }, [selectedTaskIsBlocked]);
     const runAssignedAgentDisabledReason = useMemo(() => {
         if (selectedTaskIsBlocked) {
             return "This task is blocked by unfinished dependencies.";
         }
-        if (!selectedProjectIsActive) {
-            return "Project is not active. Set the project status to Active to run agents.";
-        }
         return undefined;
-    }, [selectedTaskIsBlocked, selectedProjectIsActive]);
+    }, [selectedTaskIsBlocked]);
     // ── current agent ID and panel mode for the right panel ──
     const currentAgentId = useMemo(() => {
         return getLinkedAgentId(selectedTask);
     }, [selectedTask]);
+    const selectedTaskStatus = useMemo(() => {
+        if (!selectedTask)
+            return null;
+        return normalizeTaskStatus(selectedTask.status, selectedTask.executionStatus);
+    }, [selectedTask]);
+    const selectedTaskHasResultData = useMemo(() => {
+        return !!selectedTask?.resultData?.trim();
+    }, [selectedTask?.resultData]);
+    const shouldHideAgentPanelForSelectedTask = useMemo(() => {
+        return (!!selectedTask &&
+            selectedTaskIsPlan &&
+            selectedTaskStatus === "Done" &&
+            selectedTaskHasResultData);
+    }, [
+        selectedTask,
+        selectedTaskIsPlan,
+        selectedTaskStatus,
+        selectedTaskHasResultData,
+    ]);
+    const currentAgentStatus = useMemo(() => {
+        return getTaskAgentStatus(selectedTask, agentStatusesById);
+    }, [selectedTask, agentStatusesById]);
+    const displayAgentId = useMemo(() => {
+        if (!currentAgentId)
+            return null;
+        if (isClosedAgentStatus(currentAgentStatus) &&
+            selectedTaskStatus !== "Done") {
+            return null;
+        }
+        return currentAgentId;
+    }, [currentAgentId, currentAgentStatus, selectedTaskStatus]);
     useEffect(() => {
         if (isMobile && selectedTaskId) {
             setMobileActiveTab(1); // Task tab
         }
     }, [selectedTaskId, isMobile]);
     useEffect(() => {
-        if (isMobile && currentAgentId) {
+        if (isMobile && displayAgentId && !shouldHideAgentPanelForSelectedTask) {
             setMobileActiveTab(2); // Agent tab
         }
-    }, [currentAgentId, isMobile]);
+    }, [displayAgentId, isMobile, shouldHideAgentPanelForSelectedTask]);
+    useEffect(() => {
+        if (!isMobile)
+            return;
+        if (!shouldHideAgentPanelForSelectedTask)
+            return;
+        if (mobileActiveTab !== 2)
+            return;
+        setMobileActiveTab(1);
+    }, [isMobile, mobileActiveTab, shouldHideAgentPanelForSelectedTask]);
     useEffect(() => {
         if (!showEditorPanel && mobileActiveTab === 3) {
             setMobileActiveTab(0);
@@ -382,10 +510,165 @@ export function TaskBoardWorkspace() {
     const agentPanelMode = useMemo(() => {
         if (!selectedTask)
             return "no-task-selected";
-        if (currentAgentId)
+        if (displayAgentId)
             return "agent";
         return "no-agent";
-    }, [selectedTask, currentAgentId]);
+    }, [selectedTask, displayAgentId]);
+    const wizardAttentionState = useMemo(() => {
+        const sortedTasks = [...wizardTasksWithDisplayAssignees].sort((a, b) => {
+            if (a.sortOrder !== b.sortOrder)
+                return a.sortOrder - b.sortOrder;
+            return a.createdAt.localeCompare(b.createdAt);
+        });
+        const taskById = new Map(sortedTasks.map((task) => [task.taskId, task]));
+        const blockersByTaskId = new Map();
+        for (const dependency of dependencies) {
+            if (dependency.dependencyType !== "BlockedBy")
+                continue;
+            const blockerIds = blockersByTaskId.get(dependency.taskId) || [];
+            blockerIds.push(dependency.dependsOnTaskId);
+            blockersByTaskId.set(dependency.taskId, blockerIds);
+        }
+        const openTasks = sortedTasks.filter((task) => normalizeTaskStatus(task.status, task.executionStatus) !== "Done");
+        const blockedTaskIds = new Set();
+        for (const task of openTasks) {
+            const blockerIds = blockersByTaskId.get(task.taskId) || [];
+            const isBlocked = blockerIds.some((blockerId) => {
+                const blockerTask = taskById.get(blockerId);
+                if (!blockerTask)
+                    return true;
+                return (normalizeTaskStatus(blockerTask.status, blockerTask.executionStatus) !== "Done");
+            });
+            if (isBlocked)
+                blockedTaskIds.add(task.taskId);
+        }
+        let runningCount = 0;
+        let approvalCount = 0;
+        let attentionTask = null;
+        let attentionAgentId = null;
+        let attentionAgentStatus;
+        let attentionExecutionDisplay = null;
+        for (const task of openTasks) {
+            const normalizedTaskStatus = normalizeTaskStatus(task.status, task.executionStatus);
+            const agentId = getLinkedAgentId(task);
+            const agentStatus = getTaskAgentStatus(task, agentStatusesById);
+            const executionDisplay = getTaskExecutionDisplay(task.executionStatus, agentStatus, task.status);
+            const isBlocked = blockedTaskIds.has(task.taskId);
+            const normalizedAgentStatus = normalizeAgentStatus(agentStatus);
+            const isRunning = !isBlocked &&
+                (task.executionStatus === "Running" ||
+                    task.executionStatus === "Queued" ||
+                    normalizedAgentStatus === "running");
+            if (isRunning) {
+                runningCount += 1;
+            }
+            if (normalizedTaskStatus === "Review") {
+                approvalCount += 1;
+            }
+            if (!attentionTask && !isBlocked && executionDisplay?.needsAttention) {
+                attentionTask = task;
+                attentionAgentId = agentId;
+                attentionAgentStatus = agentStatus;
+                attentionExecutionDisplay = executionDisplay;
+            }
+        }
+        let summaryState = "idle";
+        if (openTasks.length === 0) {
+            summaryState = "complete";
+        }
+        else if (runningCount > 0) {
+            summaryState = "working";
+        }
+        else if (blockedTaskIds.size === openTasks.length) {
+            summaryState = "blocked";
+        }
+        return {
+            task: attentionTask,
+            agentId: attentionAgentId,
+            agentStatus: attentionAgentStatus,
+            executionDisplay: attentionExecutionDisplay,
+            summaryState,
+            stats: {
+                totalCount: sortedTasks.length,
+                completedCount: sortedTasks.length - openTasks.length,
+                approvalCount,
+                blockedCount: blockedTaskIds.size,
+                runningCount,
+            },
+        };
+    }, [wizardTasksWithDisplayAssignees, dependencies, agentStatusesById]);
+    const wizardDisplayedTask = wizardForceOverview
+        ? null
+        : selectedTask ?? wizardPinnedTask ?? wizardAttentionState.task;
+    const wizardDisplayedAgentId = wizardDisplayedTask
+        ? getLinkedAgentId(wizardDisplayedTask)
+        : null;
+    const wizardDisplayedAgentStatus = getAgentStatusById(agentStatusesById, wizardDisplayedAgentId);
+    const wizardDisplayedExecutionDisplay = wizardDisplayedTask
+        ? getTaskExecutionDisplay(wizardDisplayedTask.executionStatus, wizardDisplayedAgentStatus, wizardDisplayedTask.status)
+        : null;
+    const clearWizardCloseTransitionTimeout = useCallback(() => {
+        if (wizardCloseTransitionTimeoutRef.current !== null) {
+            window.clearTimeout(wizardCloseTransitionTimeoutRef.current);
+            wizardCloseTransitionTimeoutRef.current = null;
+        }
+    }, []);
+    useEffect(() => {
+        if (!isWizardMode) {
+            clearWizardCloseTransitionTimeout();
+        }
+    }, [isWizardMode, clearWizardCloseTransitionTimeout]);
+    useEffect(() => {
+        clearWizardCloseTransitionTimeout();
+    }, [selectedProjectId, clearWizardCloseTransitionTimeout]);
+    const findNextAttentionTaskId = useCallback((excludedTaskId) => {
+        const sortedTasks = [...wizardTasksWithDisplayAssignees].sort((a, b) => {
+            if (a.sortOrder !== b.sortOrder)
+                return a.sortOrder - b.sortOrder;
+            return a.createdAt.localeCompare(b.createdAt);
+        });
+        const taskById = new Map(sortedTasks.map((task) => [task.taskId, task]));
+        const blockersByTaskId = new Map();
+        for (const dependency of dependencies) {
+            if (dependency.dependencyType !== "BlockedBy")
+                continue;
+            const blockerIds = blockersByTaskId.get(dependency.taskId) || [];
+            blockerIds.push(dependency.dependsOnTaskId);
+            blockersByTaskId.set(dependency.taskId, blockerIds);
+        }
+        const openTasks = sortedTasks.filter((task) => {
+            if (excludedTaskId && task.taskId === excludedTaskId)
+                return false;
+            return (normalizeTaskStatus(task.status, task.executionStatus) !== "Done");
+        });
+        const blockedTaskIds = new Set();
+        for (const task of openTasks) {
+            const blockerIds = blockersByTaskId.get(task.taskId) || [];
+            const isBlocked = blockerIds.some((blockerId) => {
+                const blockerTask = taskById.get(blockerId);
+                if (!blockerTask)
+                    return true;
+                return (normalizeTaskStatus(blockerTask.status, blockerTask.executionStatus) !== "Done");
+            });
+            if (isBlocked)
+                blockedTaskIds.add(task.taskId);
+        }
+        for (const task of openTasks) {
+            const isBlocked = blockedTaskIds.has(task.taskId);
+            const agentId = getLinkedAgentId(task);
+            const agentStatus = getTaskAgentStatus(task, agentStatusesById);
+            const executionDisplay = getTaskExecutionDisplay(task.executionStatus, agentStatus, task.status);
+            const normalizedAgentStatus = normalizeAgentStatus(agentStatus);
+            const isRunning = !isBlocked &&
+                (task.executionStatus === "Running" ||
+                    task.executionStatus === "Queued" ||
+                    normalizedAgentStatus === "running");
+            if (!isBlocked && executionDisplay?.needsAttention) {
+                return task.taskId;
+            }
+        }
+        return null;
+    }, [wizardTasksWithDisplayAssignees, dependencies, agentStatusesById]);
     // ── data fetching ──
     const refreshProjects = useCallback(async (options) => {
         projectsRequestCountRef.current += 1;
@@ -454,17 +737,44 @@ export function TaskBoardWorkspace() {
             window.history.replaceState(null, "", newUrl);
         }
     }, [selectedProjectId, selectedTaskId, activeTab, isWizardMode]);
+    useEffect(() => {
+        const handlePopState = () => {
+            syncTaskBoardStateFromUrl();
+        };
+        window.addEventListener("popstate", handlePopState);
+        return () => window.removeEventListener("popstate", handlePopState);
+    }, [syncTaskBoardStateFromUrl]);
     const refreshTasks = useCallback(async (projectId) => {
-        const result = await getTasks(projectId);
-        if (result.type !== "success") {
-            toast.error(result.summary || "Failed to load tasks");
-            return;
+        tasksRequestCountRef.current += 1;
+        latestTasksProjectIdRef.current = projectId;
+        const requestProjectId = projectId;
+        setIsTasksLoading(true);
+        try {
+            const result = await getTasks(projectId);
+            if (latestTasksProjectIdRef.current !== requestProjectId) {
+                return;
+            }
+            if (result.type !== "success") {
+                toast.error(result.summary || "Failed to load tasks");
+                return;
+            }
+            setTasks(result.data || []);
+        }
+        finally {
+            tasksRequestCountRef.current = Math.max(0, tasksRequestCountRef.current - 1);
+            if (tasksRequestCountRef.current === 0) {
+                setIsTasksLoading(false);
+            }
         }
-        setTasks(result.data || []);
     }, []);
     const refreshSubprojectTaskCounts = useCallback(async () => {
+        const requestProjectId = selectedProjectId;
+        latestSubprojectCountsProjectIdRef.current = requestProjectId;
         if (directSubprojects.length === 0) {
-            setSubprojectTaskCounts({});
+            if (latestSubprojectCountsProjectIdRef.current === requestProjectId) {
+                setSubprojectTaskCounts({});
+                setSubprojectTasksByProjectId({});
+            }
             return;
         }
         setSubprojectCountsLoading(true);
@@ -473,40 +783,33 @@ export function TaskBoardWorkspace() {
                 const projectId = subproject.project.projectId;
                 const response = await getTasks(projectId);
                 if (response.type !== "success") {
-                    return [projectId, null];
+                    return [projectId, null, null];
                 }
                 const tasksForProject = response.data || [];
-                const counts = {
-                    total: tasksForProject.length,
-                    todo: 0,
-                    inProgress: 0,
-                    review: 0,
-                    done: 0,
-                };
-                for (const task of tasksForProject) {
-                    const normalizedStatus = normalizeTaskStatus(task.status, task.executionStatus);
-                    if (normalizedStatus === "Todo")
-                        counts.todo += 1;
-                    else if (normalizedStatus === "InProgress")
-                        counts.inProgress += 1;
-                    else if (normalizedStatus === "Review")
-                        counts.review += 1;
-                    else if (normalizedStatus === "Done")
-                        counts.done += 1;
-                }
-                return [projectId, counts];
+                return [
+                    projectId,
+                    buildTaskCounts(tasksForProject),
+                    tasksForProject,
+                ];
             }));
+            if (latestSubprojectCountsProjectIdRef.current !== requestProjectId) {
+                return;
+            }
             const nextCounts = {};
-            for (const [projectId, counts] of results) {
+            const nextTasksByProjectId = {};
+            for (const [projectId, counts, taskList] of results) {
                 if (counts)
                     nextCounts[projectId] = counts;
+                if (taskList)
+                    nextTasksByProjectId[projectId] = taskList;
             }
             setSubprojectTaskCounts(nextCounts);
+            setSubprojectTasksByProjectId(isWizardMode ? nextTasksByProjectId : {});
         }
         finally {
             setSubprojectCountsLoading(false);
         }
-    }, [directSubprojects]);
+    }, [directSubprojects, isWizardMode, selectedProjectId]);
     // If a project only has a single task, auto-select it once when loading.
     // Do not auto-reselect after the user explicitly closes task details.
     useEffect(() => {
@@ -524,47 +827,89 @@ export function TaskBoardWorkspace() {
         autoSelectedProjectIdsRef.current.add(selectedProjectId);
         setSelectedTaskId(firstTask.taskId);
     }, [selectedProjectId, selectedTaskId, tasks]);
-    const refreshDependencies = useCallback(async (projectId) => {
-        const result = await getDependencies(projectId);
-        if (result.type !== "success") {
-            toast.error(result.summary || "Failed to load dependencies");
+    useEffect(() => {
+        if (!wizardPinnedTaskId)
+            return;
+        if (taskSelectionUniverse.some((task) => task.taskId === wizardPinnedTaskId)) {
             return;
         }
-        setDependencies(result.data || []);
-    }, []);
-    const refreshWizardGuidance = useCallback(async (projectId, taskId) => {
-        const requestSeq = ++wizardGuidanceRequestSeqRef.current;
-        setWizardGuidanceLoading(true);
-        const result = await getWizardGuidance(projectId, taskId || undefined);
-        if (requestSeq !== wizardGuidanceRequestSeqRef.current) {
+        setWizardPinnedTaskId(null);
+    }, [taskSelectionUniverse, wizardPinnedTaskId]);
+    useEffect(() => {
+        if (!isWizardMode)
+            return;
+        if (wizardForceOverview)
+            return;
+        if (selectedTaskId || wizardPinnedTaskId)
+            return;
+        const attentionTaskId = wizardAttentionState.task?.taskId;
+        if (!attentionTaskId)
+            return;
+        setWizardPinnedTaskId(attentionTaskId);
+    }, [
+        isWizardMode,
+        selectedTaskId,
+        wizardPinnedTaskId,
+        wizardForceOverview,
+        wizardAttentionState.task?.taskId,
+    ]);
+    useEffect(() => {
+        if (isWizardMode)
+            return;
+        if (!wizardPinnedTaskId)
             return;
+        setWizardPinnedTaskId(null);
+    }, [isWizardMode, wizardPinnedTaskId]);
+    useEffect(() => {
+        if (!isWizardMode && wizardForceOverview) {
+            setWizardForceOverview(false);
         }
-        if (result.type !== "success") {
-            setWizardGuidance({
-                status: "unavailable",
-                generatedAt: new Date().toISOString(),
-                error: result.summary || "Failed to load wizard guidance",
-                guidance: null,
-            });
-            setWizardGuidanceLoading(false);
+    }, [isWizardMode, wizardForceOverview]);
+    useEffect(() => {
+        setWizardPinnedTaskId(null);
+        setWizardForceOverview(false);
+    }, [selectedProjectId]);
+    const refreshDependencies = useCallback(async (projectId) => {
+        latestDependenciesProjectIdRef.current = projectId;
+        const requestProjectId = projectId;
+        const visibleProjectIds = Array.from(new Set([
+            projectId,
+            ...directSubprojects.map((subproject) => subproject.project.projectId),
+        ]));
+        const results = await Promise.all(visibleProjectIds.map(async (visibleProjectId) => {
+            const result = await getDependencies(visibleProjectId);
+            return [visibleProjectId, result];
+        }));
+        const primaryResult = results.find(([visibleProjectId]) => visibleProjectId === projectId)?.[1] ?? null;
+        if (latestDependenciesProjectIdRef.current !== requestProjectId) {
             return;
         }
-        setWizardGuidance(result.data || {
-            status: "unavailable",
-            generatedAt: new Date().toISOString(),
-            error: "Wizard guidance is unavailable",
-            guidance: null,
-        });
-        setWizardGuidanceLoading(false);
-    }, []);
-    const scheduleWizardGuidanceRefresh = useCallback((projectId, taskId) => {
-        if (wizardGuidanceTimeoutRef.current !== null) {
-            window.clearTimeout(wizardGuidanceTimeoutRef.current);
-        }
-        wizardGuidanceTimeoutRef.current = window.setTimeout(() => {
-            void refreshWizardGuidance(projectId, taskId);
-        }, 450);
-    }, [refreshWizardGuidance]);
+        if (!primaryResult || primaryResult.type !== "success") {
+            toast.error(primaryResult?.summary || "Failed to load dependencies");
+            return;
+        }
+        const mergedDependencies = new Map();
+        for (const [, result] of results) {
+            if (result.type !== "success")
+                continue;
+            for (const dependency of result.data || []) {
+                mergedDependencies.set(dependency.dependencyId, dependency);
+            }
+        }
+        setDependencies(Array.from(mergedDependencies.values()));
+    }, [directSubprojects]);
+    const refreshVisibleTaskData = useCallback(async () => {
+        if (!selectedProjectId)
+            return;
+        await refreshTasks(selectedProjectId);
+        await refreshDependencies(selectedProjectId);
+        await refreshSubprojectTaskCounts();
+    }, [
+        selectedProjectId,
+        refreshTasks,
+        refreshDependencies,
+        refreshSubprojectTaskCounts,
+    ]);
     const refreshAgentStatuses = useCallback(async (taskList) => {
         const agentIds = Array.from(new Set(taskList
             .map((task) => getLinkedAgentId(task))
@@ -585,10 +930,33 @@ export function TaskBoardWorkspace() {
             for (const agent of response.agents || []) {
                 const normalizedAgentId = agent.id.toLowerCase();
                 if (wanted.has(normalizedAgentId)) {
-                    apiStatuses[normalizedAgentId] = normalizeAgentStatus(agent.status) ?? agent.status;
+                    apiStatuses[normalizedAgentId] =
+                        normalizeAgentStatus(agent.status) ?? agent.status;
                 }
             }
-            setAgentStatusesById((prev) => ({ ...prev, ...apiStatuses }));
+            setAgentStatusesById((prev) => {
+                const merged = { ...prev };
+                for (const [id, apiStatus] of Object.entries(apiStatuses)) {
+                    const existing = merged[id];
+                    const existingNormalized = existing !== undefined ? normalizeAgentStatus(existing) : undefined;
+                    if (existingNormalized === "waitingForInput" ||
+                        existingNormalized === "waitingForApproval" ||
+                        existingNormalized === "error" ||
+                        existingNormalized === "costLimitReached") {
+                        const apiNormalized = normalizeAgentStatus(apiStatus);
+                        if (apiNormalized !== "waitingForInput" &&
+                            apiNormalized !== "waitingForApproval" &&
+                            apiNormalized !== "error" &&
+                            apiNormalized !== "costLimitReached" &&
+                            apiNormalized !== "completed" &&
+                            apiNormalized !== "closed") {
+                            continue;
+                        }
+                    }
+                    merged[id] = apiStatus;
+                }
+                return merged;
+            });
         }
         catch {
             // best-effort only
@@ -602,7 +970,7 @@ export function TaskBoardWorkspace() {
         refreshSubprojectTaskCountsRef.current = refreshSubprojectTaskCounts;
         selectedProjectIdRef.current = selectedProjectId;
         directSubprojectIdsRef.current = new Set(directSubprojects.map((subproject) => subproject.project.projectId));
-        tasksRef.current = tasks;
+        tasksRef.current = taskSelectionUniverse;
     }, [
         refreshProjects,
         refreshTasks,
@@ -610,7 +978,7 @@ export function TaskBoardWorkspace() {
         refreshSubprojectTaskCounts,
         selectedProjectId,
         directSubprojects,
-        tasks,
+        taskSelectionUniverse,
     ]);
     // Ensure task-board receives live agent status updates (including WaitingForInput)
     // without requiring the terminal panel to be opened. Re-run on socket reconnect
@@ -623,7 +991,7 @@ export function TaskBoardWorkspace() {
         }
         if (!selectedProjectId)
             return;
-        const desiredAgentIds = new Set(tasks
+        const desiredAgentIds = new Set(taskSelectionUniverse
             .map((task) => getLinkedAgentId(task))
             .filter((id) => typeof id === "string" && id.length > 0)
             .map((id) => id.toLowerCase()));
@@ -646,27 +1014,10 @@ export function TaskBoardWorkspace() {
         return () => {
             window.clearTimeout(subscribeTimeout);
         };
-    }, [selectedProjectId, tasks, editContext?.socketConnectionVersion]);
-    useEffect(() => {
-        if (!selectedProjectId) {
-            setWizardGuidance(null);
-            setWizardGuidanceLoading(false);
-            return;
-        }
-        if (!isWizardMode) {
-            setWizardGuidanceLoading(false);
-            return;
-        }
-        // Recompute guidance when project/task state changes, but not on task selection alone.
-        // Selecting a recommended task should not immediately trigger another guidance run.
-        scheduleWizardGuidanceRefresh(selectedProjectId, selectedTaskId);
     }, [
         selectedProjectId,
-        isWizardMode,
-        tasks,
-        dependencies,
-        agentStatusesById,
-        scheduleWizardGuidanceRefresh,
+        taskSelectionUniverse,
+        editContext?.socketConnectionVersion,
     ]);
     const handleRunOrchestrator = useCallback(async (options) => {
         if (!selectedProjectId)
@@ -702,28 +1053,27 @@ export function TaskBoardWorkspace() {
                     }
                 }
             }
-            // Refresh tasks after orchestrator runs
-            await refreshTasks(selectedProjectId);
-            await refreshDependencies(selectedProjectId);
+            await refreshVisibleTaskData();
         }
         finally {
             setRunningOrchestrator(false);
         }
-    }, [selectedProjectId, refreshTasks, refreshDependencies]);
+    }, [selectedProjectId, refreshVisibleTaskData]);
     const handleRunSelectedTaskAgent = useCallback(async () => {
-        if (!selectedProjectId)
-            return;
         const task = tasksRef.current.find((t) => t.taskId === selectedTaskId &&
             t.assigneeType === "Agent" &&
             !!t.assigneeId);
         if (!task)
             return;
+        const taskProjectId = task.projectId || selectedProjectId;
+        if (!taskProjectId)
+            return;
         setRunningOrchestrator(true);
         try {
             if (task.executionStatus === "Idle") {
                 await updateTask({ taskId: task.taskId, executionStatus: "Queued" });
             }
-            const result = await runOrchestrator(selectedProjectId);
+            const result = await runOrchestrator(taskProjectId);
             if (result.type !== "success") {
                 toast.error(result.summary || "Failed to launch agent");
                 return;
@@ -741,13 +1091,80 @@ export function TaskBoardWorkspace() {
                     toast.info("Could not launch agent. The task may be blocked or already running.");
                 }
             }
-            await refreshTasks(selectedProjectId);
-            await refreshDependencies(selectedProjectId);
+            await refreshVisibleTaskData();
+        }
+        finally {
+            setRunningOrchestrator(false);
+        }
+    }, [selectedProjectId, selectedTaskId, refreshVisibleTaskData]);
+    const handleReopenSelectedTask = useCallback(async () => {
+        if (!selectedTask)
+            return;
+        const taskProjectId = selectedTask.projectId || selectedProjectId;
+        const reopenResult = await updateTask({
+            taskId: selectedTask.taskId,
+            status: "Todo",
+            executionStatus: "Idle",
+        });
+        if (reopenResult.type !== "success") {
+            toast.error(reopenResult.summary || "Failed to reopen task");
+            return;
+        }
+        if (selectedTaskIsPlan) {
+            toast.success("Task reopened");
+            await refreshVisibleTaskData();
+            return;
+        }
+        if (!selectedTaskHasAssignedAgentProfile ||
+            !canRunAssignedAgent ||
+            !taskProjectId) {
+            toast.success("Task reopened");
+            await refreshVisibleTaskData();
+            return;
+        }
+        setRunningOrchestrator(true);
+        try {
+            const queueResult = await updateTask({
+                taskId: selectedTask.taskId,
+                executionStatus: "Queued",
+            });
+            if (queueResult.type !== "success") {
+                toast.error(queueResult.summary || "Failed to queue agent");
+                await refreshVisibleTaskData();
+                return;
+            }
+            const result = await runOrchestrator(taskProjectId);
+            if (result.type !== "success") {
+                toast.error(result.summary || "Failed to launch agent");
+                await refreshVisibleTaskData();
+                return;
+            }
+            const data = result.data;
+            if (data?.errors?.length) {
+                toast.error(data.errors.join(", "));
+            }
+            else {
+                const launched = data?.tasksLaunched?.length || 0;
+                if (launched > 0) {
+                    toast.success("Task reopened and agent launched.");
+                }
+                else {
+                    toast.info("Task reopened, but the agent could not be launched. The task may be blocked or already running.");
+                }
+            }
+            await refreshVisibleTaskData();
         }
         finally {
             setRunningOrchestrator(false);
         }
-    }, [selectedProjectId, selectedTaskId, refreshTasks, refreshDependencies]);
+    }, [
+        selectedTask,
+        selectedProjectId,
+        selectedTaskIsPlan,
+        selectedTaskHasAssignedAgentProfile,
+        canRunAssignedAgent,
+        refreshVisibleTaskData,
+    ]);
     const handleStartPlanning = useCallback(async () => {
         if (!selectedProjectId)
             return;
@@ -770,130 +1187,6 @@ export function TaskBoardWorkspace() {
             toast.error("Failed to start planning");
         }
     }, [selectedProjectId, refreshTasks, refreshDependencies, tasks]);
-    const handleWizardAction = useCallback(async (action) => {
-        if (!action?.type)
-            return;
-        const actionType = String(action.type).trim().toLowerCase();
-        const resolvedTaskId = action.taskId || wizardGuidance?.guidance?.targetTaskId || null;
-        const resolvedTask = resolvedTaskId
-            ? tasks.find((task) => task.taskId === resolvedTaskId) || null
-            : null;
-        const resolvedTaskIsPlan = !!resolvedTask &&
-            String(resolvedTask.taskType || "").toLowerCase() === "plan";
-        const resolvedAgentId = action.agentId ||
-            wizardGuidance?.guidance?.targetAgentId ||
-            getLinkedAgentId(resolvedTask) ||
-            null;
-        const actionId = action.actionId ||
-            `${action.type}-${action.taskId || "none"}-${action.agentId || "none"}`;
-        if (resolvedTaskId) {
-            setSelectedTaskId(resolvedTaskId);
-        }
-        if (actionType === "open_task" ||
-            actionType === "open-task" ||
-            actionType === "open") {
-            setWizardAgentDialogOpen(true);
-            return;
-        }
-        if (actionType === "focus_agent" || actionType === "focus-agent") {
-            setWizardAgentDialogOpen(true);
-            return;
-        }
-        if (actionType === "copy_reply" || actionType === "copy-reply") {
-            const text = action.promptText || wizardGuidance?.guidance?.suggestedUserReply;
-            if (!text) {
-                toast.error("No suggested reply available to copy");
-                return;
-            }
-            try {
-                await navigator.clipboard.writeText(text);
-                toast.success("Suggested reply copied");
-            }
-            catch {
-                toast.error("Failed to copy suggested reply");
-            }
-            return;
-        }
-        if (actionType !== "send_prompt_to_agent" &&
-            actionType !== "send-prompt-to-agent") {
-            return;
-        }
-        if (!editContext?.sessionId) {
-            toast.error("Cannot send prompt: missing editor session");
-            return;
-        }
-        if (!resolvedAgentId && resolvedTaskIsPlan) {
-            await handleStartPlanning();
-            setWizardAgentDialogOpen(true);
-            return;
-        }
-        if (!resolvedAgentId) {
-            toast.error("Cannot send prompt: missing target agent");
-            return;
-        }
-        const promptText = (action.promptText || "").trim();
-        if (!promptText) {
-            toast.error("Cannot send prompt: prompt text is empty");
-            return;
-        }
-        setWizardActionInFlightId(actionId);
-        try {
-            let agent = null;
-            try {
-                agent = await getAgent(resolvedAgentId);
-            }
-            catch {
-                if (resolvedTaskIsPlan) {
-                    await handleStartPlanning();
-                    setWizardAgentDialogOpen(true);
-                    setWizardActionInFlightId(null);
-                    return;
-                }
-                throw new Error("Target agent was not found");
-            }
-            const profileId = agent?.profileId ||
-                (resolvedTaskId && selectedTask?.taskId === resolvedTaskId
-                    ? selectedTask?.assigneeId
-                    : undefined) ||
-                "";
-            if (!profileId) {
-                toast.error("Cannot send prompt: target agent profile is missing");
-                return;
-            }
-            await startAgent({
-                agentId: resolvedAgentId,
-                message: promptText,
-                sessionId: editContext.sessionId,
-                profileId,
-                mode: "autonomous",
-            });
-            toast.success("Prompt sent to task agent");
-            setWizardAgentDialogOpen(true);
-            if (selectedProjectId) {
-                await refreshTasks(selectedProjectId);
-                await refreshDependencies(selectedProjectId);
-                await refreshWizardGuidance(selectedProjectId, selectedTaskId);
-            }
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : "Failed to send prompt";
-            toast.error(message);
-        }
-        finally {
-            setWizardActionInFlightId(null);
-        }
-    }, [
-        editContext?.sessionId,
-        selectedTask,
-        tasks,
-        wizardGuidance,
-        handleStartPlanning,
-        selectedProjectId,
-        selectedTaskId,
-        refreshTasks,
-        refreshDependencies,
-        refreshWizardGuidance,
-    ]);
     const handleProjectStatusChange = useCallback(async (status) => {
         if (!selectedProject)
             return;
@@ -993,12 +1286,6 @@ export function TaskBoardWorkspace() {
             onToggleWizardMode: (enabled) => setIsWizardMode(enabled),
             onCreateTask: () => setCreateDialogOpen(true),
             onRunOrchestrator: handleRunOrchestrator,
-            onRefresh: () => {
-                if (selectedProjectId) {
-                    void refreshTasks(selectedProjectId);
-                    void refreshDependencies(selectedProjectId);
-                }
-            },
         });
     }, [
         selectedProject?.project.title,
@@ -1020,65 +1307,43 @@ export function TaskBoardWorkspace() {
         handleSelectMyTask,
         handleSelectProject,
         handleRunOrchestrator,
-        refreshTasks,
-        refreshDependencies,
     ]);
     useEffect(() => {
-        const currentUserName = editContext?.user?.name?.trim().toLowerCase();
-        if (!currentUserName || projects.length === 0) {
-            setTaskBoardNavState({ myTasks: [], myTasksLoading: false });
+        return () => {
+            resetTaskBoardNavState();
+        };
+    }, []);
+    useEffect(() => {
+        void refreshProjects();
+    }, [refreshProjects]);
+    useEffect(() => {
+        if (!selectedProjectId) {
+            setProjectViewLoadingId(null);
+            clearSelectedProjectData();
             return;
         }
+        clearSelectedProjectData();
+        setProjectViewLoadingId(selectedProjectId);
         let cancelled = false;
-        setTaskBoardNavState({ myTasksLoading: true });
-        (async () => {
-            const taskRequests = projects.map(async (project) => {
-                const result = await getTasks(project.project.projectId);
-                if (result.type !== "success")
-                    return [];
-                return (result.data ?? [])
-                    .filter((task) => task.assigneeType === "Human" &&
-                    (task.assigneeId ?? "").trim().toLowerCase() === currentUserName)
-                    .map((task) => ({
-                    taskId: task.taskId,
-                    projectId: project.project.projectId,
-                    title: task.title,
-                    projectTitle: project.project.title,
-                    status: normalizeTaskStatus(task.status, task.executionStatus),
-                    updatedAt: task.updatedAt,
-                }));
-            });
-            const list = (await Promise.all(taskRequests)).flat().sort((a, b) => {
-                const aTime = a.updatedAt ? new Date(a.updatedAt).getTime() : 0;
-                const bTime = b.updatedAt ? new Date(b.updatedAt).getTime() : 0;
-                return bTime - aTime;
-            });
+        const refreshTasksFn = refreshTasksRef.current;
+        const refreshDependenciesFn = refreshDependenciesRef.current;
+        void Promise.all([
+            refreshTasksFn?.(selectedProjectId),
+            refreshDependenciesFn?.(selectedProjectId),
+        ]).finally(() => {
             if (cancelled)
                 return;
-            setTaskBoardNavState({ myTasks: list, myTasksLoading: false });
-        })().catch(() => {
-            if (cancelled)
+            if (selectedProjectIdRef.current !== selectedProjectId)
                 return;
-            setTaskBoardNavState({ myTasks: [], myTasksLoading: false });
+            setProjectViewLoadingId(null);
         });
         return () => {
             cancelled = true;
         };
-    }, [editContext?.user?.name, projects]);
-    useEffect(() => {
-        return () => {
-            resetTaskBoardNavState();
-        };
-    }, []);
-    useEffect(() => {
-        void refreshProjects();
-    }, [refreshProjects]);
-    useEffect(() => {
-        if (!selectedProjectId)
-            return;
-        void refreshTasks(selectedProjectId);
-        void refreshDependencies(selectedProjectId);
-    }, [refreshTasks, refreshDependencies, selectedProjectId]);
+    }, [
+        clearSelectedProjectData,
+        selectedProjectId,
+    ]);
     useEffect(() => {
         void refreshSubprojectTaskCounts();
     }, [refreshSubprojectTaskCounts]);
@@ -1087,8 +1352,8 @@ export function TaskBoardWorkspace() {
             setAgentStatusesById({});
             return;
         }
-        void refreshAgentStatuses(tasks);
-    }, [selectedProjectId, tasks, refreshAgentStatuses]);
+        void refreshAgentStatuses(taskSelectionUniverse);
+    }, [selectedProjectId, taskSelectionUniverse, refreshAgentStatuses]);
     useEffect(() => {
         previousTaskStatusesRef.current = {};
     }, [selectedProjectId]);
@@ -1109,18 +1374,13 @@ export function TaskBoardWorkspace() {
             }
         }
         previousTaskStatusesRef.current = currentStatuses;
-        if (movedToDone &&
-            canCreate &&
-            selectedProjectIsActive &&
-            !isPlanning &&
-            !runningOrchestrator) {
+        if (movedToDone && canCreate && !isPlanning && !runningOrchestrator) {
             void handleRunOrchestrator({ silentWhenNothingToLaunch: true });
         }
     }, [
         selectedProjectId,
         tasks,
         canCreate,
-        selectedProjectIsActive,
         isPlanning,
         runningOrchestrator,
         handleRunOrchestrator,
@@ -1306,9 +1566,9 @@ export function TaskBoardWorkspace() {
                 window.clearTimeout(wsProjectRefreshTimeoutRef.current);
                 wsProjectRefreshTimeoutRef.current = null;
             }
-            if (wizardGuidanceTimeoutRef.current !== null) {
-                window.clearTimeout(wizardGuidanceTimeoutRef.current);
-                wizardGuidanceTimeoutRef.current = null;
+            if (wizardCloseTransitionTimeoutRef.current !== null) {
+                window.clearTimeout(wizardCloseTransitionTimeoutRef.current);
+                wizardCloseTransitionTimeoutRef.current = null;
             }
         };
     }, []);
@@ -1316,50 +1576,113 @@ export function TaskBoardWorkspace() {
     useEffect(() => {
         if (!selectedTaskId)
             return;
-        if (!tasks.some((t) => t.taskId === selectedTaskId))
+        if (!taskSelectionUniverse.some((t) => t.taskId === selectedTaskId)) {
             setSelectedTaskId(null);
-    }, [selectedTaskId, tasks]);
-    useEffect(() => {
-        if (!isWizardMode || !selectedProjectId) {
-            setWizardAgentDialogOpen(false);
         }
-    }, [isWizardMode, selectedProjectId]);
+    }, [selectedTaskId, taskSelectionUniverse]);
     // No special auto-selection by project status — the agent panel is driven by
     // whichever task the user selects.
     // The backend now creates the Plan task and triggers the planner agent
     // during project creation (TaskService.CreateProjectAsync), so we no longer
     // need to auto-trigger planning from the frontend.
+    const handleCloseWizardTask = useCallback(() => {
+        const closingProjectId = selectedProjectId;
+        const closedTaskId = wizardDisplayedTask?.taskId ?? selectedTaskId ?? wizardPinnedTaskId;
+        clearWizardCloseTransitionTimeout();
+        setSelectedTaskId(null);
+        setWizardPinnedTaskId(null);
+        setWizardForceOverview(true);
+        wizardCloseTransitionTimeoutRef.current = window.setTimeout(() => {
+            wizardCloseTransitionTimeoutRef.current = null;
+            if (!closingProjectId)
+                return;
+            if (selectedProjectIdRef.current !== closingProjectId)
+                return;
+            const nextAttentionTaskId = findNextAttentionTaskId(closedTaskId);
+            setWizardForceOverview(false);
+            if (nextAttentionTaskId) {
+                setWizardPinnedTaskId(nextAttentionTaskId);
+                setSelectedTaskId(nextAttentionTaskId);
+            }
+        }, 1000);
+    }, [
+        selectedProjectId,
+        wizardDisplayedTask?.taskId,
+        selectedTaskId,
+        wizardPinnedTaskId,
+        clearWizardCloseTransitionTimeout,
+        findNextAttentionTaskId,
+    ]);
+    const wizardCommunicationPanel = useMemo(() => (_jsx(WizardCommunicationCenter, { task: wizardDisplayedTask, agentId: wizardDisplayedAgentId, agentStatus: wizardDisplayedAgentStatus, executionDisplay: wizardDisplayedExecutionDisplay, summaryState: wizardAttentionState.summaryState, stats: wizardAttentionState.stats, projectTitle: selectedProject?.project.title ?? "Current project", projectDescription: selectedProject?.project.description, taskProjectTitle: wizardDisplayedTask &&
+            wizardDisplayedTask.projectId !== selectedProjectId
+            ? directSubprojects.find((subproject) => subproject.project.projectId ===
+                wizardDisplayedTask.projectId)?.project.title
+            : undefined, allTasks: wizardTasksWithDisplayAssignees, dependencies: dependencies, canEdit: canEditTasks, onTaskChanged: () => {
+            handleCloseWizardTask();
+            void refreshVisibleTaskData();
+        }, onInteractionSubmitted: () => {
+            if (wizardDisplayedAgentId) {
+                const normalizedId = wizardDisplayedAgentId.toLowerCase();
+                setAgentStatusesById((prev) => ({
+                    ...prev,
+                    [normalizedId]: "running",
+                }));
+            }
+            handleCloseWizardTask();
+        }, onCloseTask: handleCloseWizardTask, onSelectTask: (taskId) => {
+            clearWizardCloseTransitionTimeout();
+            setWizardForceOverview(false);
+            setWizardPinnedTaskId(taskId);
+            setSelectedTaskId(taskId);
+        } })), [
+        wizardAttentionState,
+        wizardDisplayedTask,
+        wizardDisplayedAgentId,
+        wizardDisplayedAgentStatus,
+        wizardDisplayedExecutionDisplay,
+        canEditTasks,
+        selectedProjectId,
+        directSubprojects,
+        refreshVisibleTaskData,
+        clearWizardCloseTransitionTimeout,
+        handleCloseWizardTask,
+        selectedProject?.project.title,
+        selectedProject?.project.description,
+    ]);
+    const isProjectViewLoading = !!selectedProjectId && projectViewLoadingId === selectedProjectId;
     const taskBoardContent = useMemo(() => {
+        if (isProjectViewLoading) {
+            return (_jsx("div", { className: "flex h-full min-h-[240px] items-center justify-center rounded-lg border border-dashed border-slate-200 bg-slate-50/70", "data-testid": "taskboard-project-loading-state", children: _jsxs("div", { className: "flex flex-col items-center gap-3 text-sm text-muted-foreground", children: [_jsx(Loader2, { className: "h-6 w-6 animate-spin" }), _jsx("div", { children: "Loading project..." })] }) }));
+        }
         if (!selectedProjectId) {
             return (_jsx("div", { className: "text-muted-foreground p-6 text-sm", children: "Select a project to view tasks." }));
         }
         if (isWizardMode) {
-            return (_jsx(WizardView, { projectId: selectedProjectId, tasks: tasksWithDisplayAssignees, dependencies: dependencies, selectedTaskId: selectedTaskId, onSelectTask: (id) => setSelectedTaskId(id), agentStatusesById: agentStatusesById, projectTitle: selectedProject?.project.title ?? "Current project", projectDescription: selectedProject?.project.description, canEditProperties: selectedProject?.permission === "Owner", guidance: wizardGuidance, guidanceLoading: wizardGuidanceLoading, actionInFlightId: wizardActionInFlightId, onRunGuidanceAction: handleWizardAction, onOpenAgentTerminal: () => setWizardAgentDialogOpen(true) }));
+            return (_jsx(WizardView, { projectId: selectedProjectId, tasks: tasksWithDisplayAssignees, projectTasksLoading: isTasksLoading, dependencies: dependencies, subprojectTaskLists: wizardSubprojectTaskLists, subprojectTasksLoading: subprojectCountsLoading, selectedTaskId: wizardDisplayedTask?.taskId ?? null, onSelectTask: (id) => {
+                    setWizardForceOverview(false);
+                    setWizardPinnedTaskId(id);
+                    setSelectedTaskId(id);
+                }, agentStatusesById: agentStatusesById, projectTitle: selectedProject?.project.title ?? "Current project", projectDescription: selectedProject?.project.description, canEditProperties: selectedProject?.permission === "Owner", communicationPanel: wizardCommunicationPanel }));
         }
         if (isListView) {
             return (_jsxs("div", { className: "grid gap-3", children: [_jsx(ProjectDashboard, { projectId: selectedProjectId, selectedProjectTitle: selectedProject?.project.title ?? "Current project", selectedProjectDescription: selectedProject?.project.description, selectedProjectStatus: selectedProject?.project.status, selectedProjectCostUsed: selectedProjectCumulativeCostUsed, selectedProjectCostLimit: selectedProject?.project.costLimit ?? null, canEditProjectStatus: selectedProject?.permission === "Owner", savingProjectStatus: savingProjectStatus, onStatusChange: handleProjectStatusChange, selectedProjectTaskCounts: selectedProjectTaskCounts, subprojects: directSubprojects, taskCountsByProjectId: subprojectTaskCounts, loading: subprojectCountsLoading, parentProjectId: parentProject?.project.projectId ?? null, parentProjectTitle: parentProject?.project.title ?? null, onSelectProject: handleSelectProject, canEditProperties: selectedProject?.permission === "Owner" }), _jsx(ListView, { tasks: tasksWithDisplayAssignees, onSelectTask: (id) => setSelectedTaskId(id), selectedTaskId: selectedTaskId, onTasksChanged: () => {
-                            if (selectedProjectId) {
-                                void refreshTasks(selectedProjectId);
-                                void refreshDependencies(selectedProjectId);
-                                void refreshSubprojectTaskCounts();
-                            }
+                            void refreshVisibleTaskData();
                         }, projectId: selectedProjectId, permission: selectedProject?.permission, agentStatusesById: agentStatusesById, activeTab: activeTab, onSetActiveTab: setActiveTab, canCreateTask: canEditTasks, onCreateTask: () => setCreateDialogOpen(true) })] }));
         }
         return (_jsxs("div", { className: "flex h-full min-h-0 flex-col gap-3", children: [_jsx(ProjectDashboard, { projectId: selectedProjectId, selectedProjectTitle: selectedProject?.project.title ?? "Current project", selectedProjectDescription: selectedProject?.project.description, selectedProjectStatus: selectedProject?.project.status, selectedProjectCostUsed: selectedProjectCumulativeCostUsed, selectedProjectCostLimit: selectedProject?.project.costLimit ?? null, canEditProjectStatus: selectedProject?.permission === "Owner", savingProjectStatus: savingProjectStatus, onStatusChange: handleProjectStatusChange, selectedProjectTaskCounts: selectedProjectTaskCounts, subprojects: directSubprojects, taskCountsByProjectId: subprojectTaskCounts, loading: subprojectCountsLoading, parentProjectId: parentProject?.project.projectId ?? null, parentProjectTitle: parentProject?.project.title ?? null, onSelectProject: handleSelectProject, canEditProperties: selectedProject?.permission === "Owner" }), _jsx(KanbanView, { tasks: tasksWithDisplayAssignees, dependencies: dependencies, onSelectTask: (id) => setSelectedTaskId(id), selectedTaskId: selectedTaskId, onTasksChanged: () => {
-                        if (selectedProjectId) {
-                            void refreshTasks(selectedProjectId);
-                            void refreshDependencies(selectedProjectId);
-                            void refreshSubprojectTaskCounts();
-                        }
+                        void refreshVisibleTaskData();
                     }, projectId: selectedProjectId, permission: selectedProject?.permission, agentStatusesById: agentStatusesById, activeTab: activeTab, onSetActiveTab: setActiveTab, canCreateTask: canEditTasks, onCreateTask: () => setCreateDialogOpen(true) })] }));
     }, [
+        isProjectViewLoading,
         selectedProjectId,
         isWizardMode,
         isListView,
+        isTasksLoading,
         tasksWithDisplayAssignees,
+        wizardSubprojectTaskLists,
         selectedTaskId,
-        refreshTasks,
-        refreshDependencies,
+        wizardDisplayedTask?.taskId,
+        refreshVisibleTaskData,
         selectedProject?.permission,
         selectedProject?.project.description,
         selectedProject?.project.status,
@@ -1374,7 +1697,7 @@ export function TaskBoardWorkspace() {
         selectedProjectTaskCounts,
         subprojectTaskCounts,
         subprojectCountsLoading,
-        refreshSubprojectTaskCounts,
+        wizardCommunicationPanel,
         savingProjectStatus,
         handleProjectStatusChange,
         activeTab,
@@ -1392,27 +1715,18 @@ export function TaskBoardWorkspace() {
         canEditTasks,
         selectedTask?.assigneeDisplayName,
         selectedTask?.assigneeId,
-        wizardGuidance,
-        wizardGuidanceLoading,
-        wizardActionInFlightId,
-        handleWizardAction,
     ]);
-    const taskDetailPanel = useMemo(() => (_jsx(TaskDetailPanel, { project: selectedProject, task: selectedTask, allTasks: tasksWithDisplayAssignees, dependencies: dependencies, agentStatusesById: agentStatusesById, onTaskChanged: () => {
-            if (selectedProjectId) {
-                void refreshTasks(selectedProjectId);
-                void refreshDependencies(selectedProjectId);
-            }
+    const taskDetailPanel = useMemo(() => (_jsx(TaskDetailPanel, { project: selectedTaskProject, task: selectedTask, allTasks: taskSelectionUniverse, dependencies: dependencies, agentStatusesById: agentStatusesById, onTaskChanged: () => {
+            void refreshVisibleTaskData();
         }, onSelectTask: (taskId) => setSelectedTaskId(taskId), onClose: () => setSelectedTaskId(null), variant: "panel" })), [
-        selectedProject,
+        selectedTaskProject,
         selectedTask,
-        tasksWithDisplayAssignees,
+        taskSelectionUniverse,
         dependencies,
         agentStatusesById,
-        selectedProjectId,
-        refreshTasks,
-        refreshDependencies,
+        refreshVisibleTaskData,
     ]);
-    const agentTerminalPanel = useMemo(() => (_jsx(TaskAgentPanel, { agentId: currentAgentId, mode: agentPanelMode, label: selectedTaskIsPlan ? "Planner" : "Task Agent", hasAssignedAgentProfile: !selectedTaskIsPlan && selectedTaskHasAssignedAgentProfile, assignedAgentProfileName: !selectedTaskIsPlan && selectedTaskHasAssignedAgentProfile
+    const agentTerminalPanel = useMemo(() => (_jsx(TaskAgentPanel, { agentId: displayAgentId, mode: agentPanelMode, label: selectedTaskIsPlan ? "Planner" : "Task Agent", hasAssignedAgentProfile: !selectedTaskIsPlan && selectedTaskHasAssignedAgentProfile, assignedAgentProfileName: !selectedTaskIsPlan && selectedTaskHasAssignedAgentProfile
             ? selectedTask?.assigneeDisplayName ||
                 selectedTask?.assigneeId ||
                 null
@@ -1427,16 +1741,10 @@ export function TaskBoardWorkspace() {
             agentPanelMode === "no-agent" &&
             !selectedTaskHasAssignedAgentProfile
             ? () => setAssignAgentDialogOpen(true)
-            : undefined, assignedAgentStatus: currentAgentId ? agentStatusesById[currentAgentId] : undefined, onReopenTask: selectedTask && canEditTasks
-            ? async () => {
-                await updateTask({
-                    taskId: selectedTask.taskId,
-                    status: "InProgress",
-                });
-                await refreshTasks(selectedTask.projectId);
-            }
+            : undefined, assignedAgentStatus: displayAgentId ? currentAgentStatus : undefined, onReopenTask: selectedTask && canEditTasks
+            ? () => void handleReopenSelectedTask()
             : undefined })), [
-        currentAgentId,
+        displayAgentId,
         agentPanelMode,
         selectedTaskIsPlan,
         selectedTaskHasAssignedAgentProfile,
@@ -1447,9 +1755,9 @@ export function TaskBoardWorkspace() {
         handleStartPlanning,
         selectedTaskIsBlocked,
         canEditTasks,
-        agentStatusesById,
+        currentAgentStatus,
         selectedTask,
-        refreshTasks,
+        handleReopenSelectedTask,
     ]);
     const slotContext = editContext?.getActiveSlotContext();
     const previewItemVersion = useMemo(() => {
@@ -1643,14 +1951,14 @@ export function TaskBoardWorkspace() {
             const wizardPanels = [
                 {
                     name: "wizard-view",
-                    defaultSize: "auto",
+                    defaultSize: 70,
                     content: (_jsx("div", { className: "h-full overflow-x-hidden overflow-y-auto bg-slate-50/50", children: taskBoardContent })),
                 },
             ];
             if (showEditorPanel) {
                 wizardPanels.push({
                     name: "editor-preview",
-                    defaultSize: 500,
+                    defaultSize: 30,
                     content: (_jsx("div", { className: "h-full overflow-hidden border-l border-gray-200 bg-gray-50", children: itemPreviewPanel })),
                 });
             }
@@ -1673,7 +1981,7 @@ export function TaskBoardWorkspace() {
                     name: "agent-terminal",
                     defaultSize: 560,
                     content: agentTerminalPanel,
-                    hidden: !selectedProjectId,
+                    hidden: !selectedProjectId || shouldHideAgentPanelForSelectedTask,
                 },
             ];
             if (showEditorPanel) {
@@ -1701,7 +2009,7 @@ export function TaskBoardWorkspace() {
                 name: "agent-terminal",
                 defaultSize: 560,
                 content: agentTerminalPanel,
-                hidden: !selectedProjectId,
+                hidden: !selectedProjectId || shouldHideAgentPanelForSelectedTask,
             },
         ];
         if (showEditorPanel) {
@@ -1721,6 +2029,7 @@ export function TaskBoardWorkspace() {
         selectedTask,
         showEditorPanel,
         itemPreviewPanel,
+        shouldHideAgentPanelForSelectedTask,
     ]);
     return (_jsxs("div", { className: "text-foreground flex h-full w-full flex-col bg-white select-text", children: [_jsx("div", { className: "min-h-0 flex-1", children: isMobile ? (_jsxs("div", { className: "flex h-full flex-col overflow-hidden", children: [_jsx("div", { className: "shrink-0 border-b border-gray-100 bg-white px-4 shadow-[0_1px_2px_rgba(0,0,0,0.03)]", children: _jsx(SimpleTabs, { tabs: [
                                     { id: "project", label: "Project", content: null },
@@ -1734,19 +2043,24 @@ export function TaskBoardWorkspace() {
                                         id: "agent",
                                         label: "Agent",
                                         content: null,
-                                        disabled: !currentAgentId,
+                                        disabled: !currentAgentId || shouldHideAgentPanelForSelectedTask,
                                     },
                                     ...(showEditorPanel
                                         ? [{ id: "editor", label: "Editor", content: null }]
                                         : []),
-                                ], activeTab: mobileActiveTab, setActiveTab: setMobileActiveTab, hideContent: true, variant: "elegant", className: "gap-6" }) }), _jsxs("div", { className: "min-h-0 flex-1 overflow-hidden", children: [mobileActiveTab === 0 && (_jsx("div", { className: "h-full overflow-y-auto bg-slate-50/50 p-2 pt-2 sm:p-4 sm:pt-3", children: taskBoardContent })), mobileActiveTab === 1 && (_jsx("div", { className: "h-full overflow-y-auto bg-white", children: taskDetailPanel })), mobileActiveTab === 2 && (_jsx("div", { className: "h-full overflow-hidden bg-white", children: agentTerminalPanel })), mobileActiveTab === 3 && showEditorPanel && (_jsx("div", { className: "h-full overflow-hidden bg-gray-50", children: itemPreviewPanel }))] })] })) : (_jsx(Splitter, { panels: panels, direction: "horizontal", localStorageKey: "task-board-main-splitter" })) }), _jsx(Dialog, { open: wizardAgentDialogOpen, onOpenChange: setWizardAgentDialogOpen, children: _jsxs(DialogContent, { className: "max-h-[88vh] max-w-6xl overflow-hidden p-0", children: [_jsx(DialogHeader, { className: "border-b border-slate-200 px-5 py-3", children: _jsx(DialogTitle, { children: selectedTask?.title ||
-                                    (selectedTaskIsPlan ? "Planner" : "Task Agent") }) }), _jsx("div", { className: "h-[70vh] overflow-hidden", children: agentTerminalPanel })] }) }), selectedProjectId && (_jsx(CreateTaskDialog, { open: createDialogOpen, onOpenChange: setCreateDialogOpen, projectId: selectedProjectId, onCreated: () => {
+                                ], activeTab: mobileActiveTab, setActiveTab: setMobileActiveTab, hideContent: true, variant: "elegant", className: "gap-6" }) }), _jsxs("div", { className: "min-h-0 flex-1 overflow-hidden", children: [mobileActiveTab === 0 && (_jsx("div", { className: "h-full overflow-y-auto bg-slate-50/50 p-2 pt-2 sm:p-4 sm:pt-3", children: taskBoardContent })), mobileActiveTab === 1 && (_jsx("div", { className: "h-full overflow-y-auto bg-white", children: taskDetailPanel })), mobileActiveTab === 2 && (_jsx("div", { className: "h-full overflow-hidden bg-white", children: shouldHideAgentPanelForSelectedTask ? taskDetailPanel : agentTerminalPanel })), mobileActiveTab === 3 && showEditorPanel && (_jsx("div", { className: "h-full overflow-hidden bg-gray-50", children: itemPreviewPanel }))] })] })) : (_jsx(Splitter, { panels: panels, direction: "horizontal", localStorageKey: isWizardMode
+                        ? "task-board-wizard-splitter-v2"
+                        : "task-board-main-splitter" })) }), selectedProjectId && (_jsx(CreateTaskDialog, { open: createDialogOpen, onOpenChange: setCreateDialogOpen, projectId: selectedProjectId, onCreated: () => {
                     void refreshTasks(selectedProjectId);
                     void refreshDependencies(selectedProjectId);
-                } })), _jsx(CreateProjectDialog, { open: createProjectOpen, onOpenChange: setCreateProjectOpen, projects: projects, onCreated: async (newProjectId) => {
-                    await refreshProjects();
+                } })), _jsx(CreateProjectDialog, { open: createProjectOpen, onOpenChange: setCreateProjectOpen, projects: projects, onCreated: async ({ projectId: newProjectId, openInWizardMode }) => {
+                    if (openInWizardMode) {
+                        setIsWizardMode(true);
+                        setWizardForceOverview(false);
+                    }
                     if (newProjectId)
                         handleSelectProject(newProjectId);
+                    await refreshProjects();
                 } }), _jsx(ProjectSettingsDialog, { open: !!settingsProjectId, onOpenChange: (open) => {
                     if (!open)
                         setSettingsProjectId(null);