🤖 feat: implement sub-workspaces/subagents system

Add comprehensive infrastructure for spawning child agent tasks from parent
workspaces. This enables parallel agent workflows with dedicated presets
(Research, Explore), tool policies, and automatic lifecycle management.

Core additions:
- TaskService: orchestrates task creation, execution, and cleanup
- Task/agent_report tools: spawn subagents and receive reports
- Agent presets: Research (web search) and Explore (codebase navigation)
- Nested sidebar: visual hierarchy for parent/child workspaces

Config extensions:
- taskSettings: global limits (maxParallelAgentTasks, maxTaskNestingDepth)
- taskState: per-workspace state tracking with parent chain
- getWorkspaceNestingDepth(), countRunningAgentTasks() helpers

UI changes:
- WorkspaceListItem: indented display with purple accent for agent tasks
- sortWithNesting(): depth-first traversal preserving parent→child ordering

Files added:
- src/common/constants/agentPresets.ts
- src/common/orpc/schemas/task.ts
- src/common/types/task.ts
- src/node/services/taskService.ts
- src/node/services/tools/task.ts
- src/node/services/tools/agent_report.ts

Change-Id: I9331e8235fb79c7efe104c8a60564682a1641e56
Signed-off-by: Thomas Kosiewski <tk@coder.com>

Author: ThomasK33

src/browser/components/LeftSidebar.tsx

@@ -1,6 +1,6 @@
 import React from "react";
 import { cn } from "@/common/lib/utils";
-import type { FrontendWorkspaceMetadata } from "@/common/types/workspace";
+import type { WorkspaceWithNesting } from "@/browser/utils/ui/workspaceFiltering";
 import ProjectSidebar from "./ProjectSidebar";
 import { TitleBar } from "./TitleBar";
 
@@ -9,7 +9,7 @@ interface LeftSidebarProps {
   onToggleUnread: (workspaceId: string) => void;
   collapsed: boolean;
   onToggleCollapsed: () => void;
-  sortedWorkspacesByProject: Map<string, FrontendWorkspaceMetadata[]>;
+  sortedWorkspacesByProject: Map<string, WorkspaceWithNesting[]>;
   workspaceRecency: Record<string, number>;
 }
 

src/browser/components/ProjectSidebar.tsx

@@ -1,6 +1,6 @@
 import React, { useState, useEffect, useCallback } from "react";
 import { cn } from "@/common/lib/utils";
-import type { FrontendWorkspaceMetadata } from "@/common/types/workspace";
+import type { WorkspaceWithNesting } from "@/browser/utils/ui/workspaceFiltering";
 import { usePersistedState } from "@/browser/hooks/usePersistedState";
 import { EXPANDED_PROJECTS_KEY } from "@/common/constants/storage";
 import { DndProvider } from "react-dnd";
@@ -179,7 +179,7 @@ interface ProjectSidebarProps {
   onToggleUnread: (workspaceId: string) => void;
   collapsed: boolean;
   onToggleCollapsed: () => void;
-  sortedWorkspacesByProject: Map<string, FrontendWorkspaceMetadata[]>;
+  sortedWorkspacesByProject: Map<string, WorkspaceWithNesting[]>;
   workspaceRecency: Record<string, number>;
 }
 
@@ -613,7 +613,7 @@ const ProjectSidebarInner: React.FC<ProjectSidebarProps> = ({
                                 workspaceRecency
                               );
 
-                              const renderWorkspace = (metadata: FrontendWorkspaceMetadata) => (
+                              const renderWorkspace = (metadata: WorkspaceWithNesting) => (
                                 <WorkspaceListItem
                                   key={metadata.id}
                                   metadata={metadata}
@@ -622,6 +622,7 @@ const ProjectSidebarInner: React.FC<ProjectSidebarProps> = ({
                                   isSelected={selectedWorkspace?.workspaceId === metadata.id}
                                   isDeleting={deletingWorkspaceIds.has(metadata.id)}
                                   lastReadTimestamp={lastReadTimestamps[metadata.id] ?? 0}
+                                  nestingDepth={metadata.nestingDepth}
                                   onSelectWorkspace={handleSelectWorkspace}
                                   onRemoveWorkspace={handleRemoveWorkspace}
                                   onToggleUnread={_onToggleUnread}

src/browser/components/WorkspaceListItem.tsx

@@ -25,6 +25,8 @@ export interface WorkspaceListItemProps {
   isDeleting?: boolean;
   /** @deprecated No longer used since status dot was removed, kept for API compatibility */
   lastReadTimestamp?: number;
+  /** Nesting depth for agent task workspaces (0 = top-level, 1+ = nested) */
+  nestingDepth?: number;
   // Event handlers
   onSelectWorkspace: (selection: WorkspaceSelection) => void;
   onRemoveWorkspace: (workspaceId: string, button: HTMLElement) => Promise<void>;
@@ -39,6 +41,7 @@ const WorkspaceListItemInner: React.FC<WorkspaceListItemProps> = ({
   isSelected,
   isDeleting,
   lastReadTimestamp: _lastReadTimestamp,
+  nestingDepth = 0,
   onSelectWorkspace,
   onRemoveWorkspace,
   onToggleUnread: _onToggleUnread,
@@ -102,17 +105,24 @@ const WorkspaceListItemInner: React.FC<WorkspaceListItemProps> = ({
   const { canInterrupt, awaitingUserQuestion } = useWorkspaceSidebarState(workspaceId);
   const isWorking = canInterrupt && !awaitingUserQuestion;
 
+  // Calculate left padding based on nesting depth (base 9px + 16px per level)
+  const leftPadding = 9 + nestingDepth * 16;
+  const isAgentTask = Boolean(metadata.parentWorkspaceId);
+
   return (
     <React.Fragment>
       <div
         className={cn(
-          "py-1.5 pl-[9px] pr-2 border-l-[3px] border-transparent transition-all duration-150 text-[13px] relative flex gap-2",
+          "py-1.5 pr-2 border-l-[3px] border-transparent transition-all duration-150 text-[13px] relative flex gap-2",
           isDisabled
             ? "cursor-default opacity-70"
             : "cursor-pointer hover:bg-hover [&:hover_button]:opacity-100",
           isSelected && !isDisabled && "bg-hover border-l-blue-400",
-          isDeleting && "pointer-events-none"
+          isDeleting && "pointer-events-none",
+          // Nested agent tasks get a subtle visual indicator
+          isAgentTask && "border-l-purple-400/30"
         )}
+        style={{ paddingLeft: `${leftPadding}px` }}
         onClick={() => {
           if (isDisabled) return;
           onSelectWorkspace({

src/browser/hooks/useSortedWorkspacesByProject.ts

@@ -4,26 +4,82 @@ import type { FrontendWorkspaceMetadata } from "@/common/types/workspace";
 import { useWorkspaceRecency } from "@/browser/stores/WorkspaceStore";
 import { useStableReference, compareMaps } from "@/browser/hooks/useStableReference";
 
+/** Workspace metadata extended with computed nesting depth */
+export interface WorkspaceWithNesting extends FrontendWorkspaceMetadata {
+  /** Nesting depth (0 = top-level, 1 = direct child, etc.) */
+  nestingDepth: number;
+}
+
+/**
+ * Sort workspaces so children appear immediately after their parent.
+ * Maintains recency order within each level.
+ */
+function sortWithNesting(
+  metadataList: FrontendWorkspaceMetadata[],
+  workspaceRecency: Record<string, number>
+): WorkspaceWithNesting[] {
+  // Build parent→children map
+  const childrenByParent = new Map<string, FrontendWorkspaceMetadata[]>();
+  const topLevel: FrontendWorkspaceMetadata[] = [];
+
+  for (const ws of metadataList) {
+    const parentId = ws.parentWorkspaceId;
+    if (parentId) {
+      const siblings = childrenByParent.get(parentId) ?? [];
+      siblings.push(ws);
+      childrenByParent.set(parentId, siblings);
+    } else {
+      topLevel.push(ws);
+    }
+  }
+
+  // Sort by recency (most recent first)
+  const sortByRecency = (a: FrontendWorkspaceMetadata, b: FrontendWorkspaceMetadata) => {
+    const aTs = workspaceRecency[a.id] ?? 0;
+    const bTs = workspaceRecency[b.id] ?? 0;
+    return bTs - aTs;
+  };
+
+  topLevel.sort(sortByRecency);
+  for (const children of childrenByParent.values()) {
+    children.sort(sortByRecency);
+  }
+
+  // Flatten: parent, then children recursively
+  const result: WorkspaceWithNesting[] = [];
+
+  const visit = (ws: FrontendWorkspaceMetadata, depth: number) => {
+    result.push({ ...ws, nestingDepth: depth });
+    const children = childrenByParent.get(ws.id) ?? [];
+    for (const child of children) {
+      visit(child, depth + 1);
+    }
+  };
+
+  for (const ws of topLevel) {
+    visit(ws, 0);
+  }
+
+  return result;
+}
+
 export function useSortedWorkspacesByProject() {
   const { projects } = useProjectContext();
   const { workspaceMetadata } = useWorkspaceContext();
   const workspaceRecency = useWorkspaceRecency();
 
   return useStableReference(
     () => {
-      const result = new Map<string, FrontendWorkspaceMetadata[]>();
+      const result = new Map<string, WorkspaceWithNesting[]>();
       for (const [projectPath, config] of projects) {
         const metadataList = config.workspaces
           .map((ws) => (ws.id ? workspaceMetadata.get(ws.id) : undefined))
           .filter((meta): meta is FrontendWorkspaceMetadata => Boolean(meta));
 
-        metadataList.sort((a, b) => {
-          const aTimestamp = workspaceRecency[a.id] ?? 0;
-          const bTimestamp = workspaceRecency[b.id] ?? 0;
-          return bTimestamp - aTimestamp;
-        });
+        // Sort with nesting: parents first, children indented below
+        const sorted = sortWithNesting(metadataList, workspaceRecency);
 
-        result.set(projectPath, metadataList);
+        result.set(projectPath, sorted);
       }
       return result;
     },
@@ -37,7 +93,11 @@ export function useSortedWorkspacesByProject() {
           if (!other) {
             return false;
           }
-          return metadata.id === other.id && metadata.name === other.name;
+          return (
+            metadata.id === other.id &&
+            metadata.name === other.name &&
+            metadata.nestingDepth === other.nestingDepth
+          );
         });
       }),
     [projects, workspaceMetadata, workspaceRecency]

src/browser/utils/ui/workspaceFiltering.ts

@@ -10,22 +10,83 @@ export type AgeThresholdDays = (typeof AGE_THRESHOLDS_DAYS)[number];
 
 const DAY_MS = 24 * 60 * 60 * 1000;
 
+/** Workspace metadata extended with computed nesting depth */
+export interface WorkspaceWithNesting extends FrontendWorkspaceMetadata {
+  /** Nesting depth (0 = top-level, 1 = direct child, etc.) */
+  nestingDepth: number;
+}
+
+/**
+ * Sort workspaces so children appear immediately after their parent.
+ * Maintains recency order within each level.
+ */
+function sortWithNesting(
+  metadataList: FrontendWorkspaceMetadata[],
+  workspaceRecency: Record<string, number>
+): WorkspaceWithNesting[] {
+  // Build parent→children map
+  const childrenByParent = new Map<string, FrontendWorkspaceMetadata[]>();
+  const topLevel: FrontendWorkspaceMetadata[] = [];
+
+  for (const ws of metadataList) {
+    const parentId = ws.parentWorkspaceId;
+    if (parentId) {
+      const siblings = childrenByParent.get(parentId) ?? [];
+      siblings.push(ws);
+      childrenByParent.set(parentId, siblings);
+    } else {
+      topLevel.push(ws);
+    }
+  }
+
+  // Sort by recency (most recent first)
+  const sortByRecency = (a: FrontendWorkspaceMetadata, b: FrontendWorkspaceMetadata) => {
+    const aTs = workspaceRecency[a.id] ?? 0;
+    const bTs = workspaceRecency[b.id] ?? 0;
+    return bTs - aTs;
+  };
+
+  topLevel.sort(sortByRecency);
+  for (const children of childrenByParent.values()) {
+    children.sort(sortByRecency);
+  }
+
+  // Flatten: parent, then children recursively
+  const result: WorkspaceWithNesting[] = [];
+
+  const visit = (ws: FrontendWorkspaceMetadata, depth: number) => {
+    result.push({ ...ws, nestingDepth: depth });
+    const children = childrenByParent.get(ws.id) ?? [];
+    for (const child of children) {
+      visit(child, depth + 1);
+    }
+  };
+
+  for (const ws of topLevel) {
+    visit(ws, 0);
+  }
+
+  return result;
+}
+
 /**
  * Build a map of project paths to sorted workspace metadata lists.
  * Includes both persisted workspaces (from config) and pending workspaces
  * (status: "creating") that haven't been saved yet.
  *
- * Workspaces are sorted by recency (most recent first).
+ * Workspaces are sorted by recency (most recent first), with child workspaces
+ * (agent tasks) appearing directly below their parent with indentation.
  */
 export function buildSortedWorkspacesByProject(
   projects: Map<string, ProjectConfig>,
   workspaceMetadata: Map<string, FrontendWorkspaceMetadata>,
   workspaceRecency: Record<string, number>
-): Map<string, FrontendWorkspaceMetadata[]> {
-  const result = new Map<string, FrontendWorkspaceMetadata[]>();
+): Map<string, WorkspaceWithNesting[]> {
+  const result = new Map<string, WorkspaceWithNesting[]>();
   const includedIds = new Set<string>();
 
-  // First pass: include workspaces from persisted config
+  // First pass: collect workspaces from persisted config
+  const collectedByProject = new Map<string, FrontendWorkspaceMetadata[]>();
   for (const [projectPath, config] of projects) {
     const metadataList: FrontendWorkspaceMetadata[] = [];
     for (const ws of config.workspaces) {
@@ -36,25 +97,21 @@ export function buildSortedWorkspacesByProject(
         includedIds.add(ws.id);
       }
     }
-    result.set(projectPath, metadataList);
+    collectedByProject.set(projectPath, metadataList);
   }
 
   // Second pass: add pending workspaces (status: "creating") not yet in config
   for (const [id, metadata] of workspaceMetadata) {
     if (metadata.status === "creating" && !includedIds.has(id)) {
-      const projectWorkspaces = result.get(metadata.projectPath) ?? [];
+      const projectWorkspaces = collectedByProject.get(metadata.projectPath) ?? [];
       projectWorkspaces.push(metadata);
-      result.set(metadata.projectPath, projectWorkspaces);
+      collectedByProject.set(metadata.projectPath, projectWorkspaces);
     }
   }
 
-  // Sort each project's workspaces by recency (sort mutates in place)
-  for (const metadataList of result.values()) {
-    metadataList.sort((a, b) => {
-      const aTimestamp = workspaceRecency[a.id] ?? 0;
-      const bTimestamp = workspaceRecency[b.id] ?? 0;
-      return bTimestamp - aTimestamp;
-    });
+  // Sort with nesting for each project
+  for (const [projectPath, metadataList] of collectedByProject) {
+    result.set(projectPath, sortWithNesting(metadataList, workspaceRecency));
   }
 
   return result;
@@ -76,28 +133,28 @@ export function formatDaysThreshold(days: number): string {
  *   - buckets[1]: older than 7 days but newer than 30 days
  *   - buckets[2]: older than 30 days
  */
-export interface AgePartitionResult {
-  recent: FrontendWorkspaceMetadata[];
-  buckets: FrontendWorkspaceMetadata[][];
+export interface AgePartitionResult<T extends FrontendWorkspaceMetadata = WorkspaceWithNesting> {
+  recent: T[];
+  buckets: T[][];
 }
 
 /**
  * Partition workspaces into age-based buckets.
  * Always shows at least one workspace in the recent section (the most recent one).
  */
-export function partitionWorkspacesByAge(
-  workspaces: FrontendWorkspaceMetadata[],
+export function partitionWorkspacesByAge<T extends FrontendWorkspaceMetadata>(
+  workspaces: T[],
   workspaceRecency: Record<string, number>
-): AgePartitionResult {
+): AgePartitionResult<T> {
   if (workspaces.length === 0) {
     return { recent: [], buckets: AGE_THRESHOLDS_DAYS.map(() => []) };
   }
 
   const now = Date.now();
   const thresholdMs = AGE_THRESHOLDS_DAYS.map((d) => d * DAY_MS);
 
-  const recent: FrontendWorkspaceMetadata[] = [];
-  const buckets: FrontendWorkspaceMetadata[][] = AGE_THRESHOLDS_DAYS.map(() => []);
+  const recent: T[] = [];
+  const buckets: T[][] = AGE_THRESHOLDS_DAYS.map(() => []);
 
   for (const workspace of workspaces) {
     const recencyTimestamp = workspaceRecency[workspace.id] ?? 0;

src/browser/utils/workspace.ts

@@ -1,4 +1,5 @@
 import type { FrontendWorkspaceMetadata } from "@/common/types/workspace";
+import type { WorkspaceWithNesting } from "@/browser/utils/ui/workspaceFiltering";
 
 /**
  * Generate a comparison key for workspace sidebar display.
@@ -7,11 +8,16 @@ import type { FrontendWorkspaceMetadata } from "@/common/types/workspace";
  * IMPORTANT: If you add a field to WorkspaceMetadata that affects how
  * workspaces appear in the sidebar, add it here to ensure UI updates.
  */
-export function getWorkspaceSidebarKey(meta: FrontendWorkspaceMetadata): string {
+export function getWorkspaceSidebarKey(
+  meta: FrontendWorkspaceMetadata | WorkspaceWithNesting
+): string {
+  const nestingDepth = "nestingDepth" in meta ? meta.nestingDepth : 0;
   return [
     meta.id,
     meta.name,
     meta.title ?? "", // Display title (falls back to name in UI)
     meta.status ?? "", // Working/idle status indicator
+    meta.parentWorkspaceId ?? "", // Parent ID for agent task workspaces
+    String(nestingDepth), // Nesting depth for indentation
   ].join("|");
 }