feat: add durable agent task subworkspaces

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

Author: ThomasK33

src/browser/components/ProjectSidebar.tsx

@@ -224,6 +224,16 @@ const ProjectSidebarInner: React.FC<ProjectSidebarProps> = ({
   );
 
   // Wrapper to close sidebar on mobile after adding workspace
+
+  const workspaceMetadataById = (() => {
+    const map = new Map<string, FrontendWorkspaceMetadata>();
+    for (const list of sortedWorkspacesByProject.values()) {
+      for (const metadata of list) {
+        map.set(metadata.id, metadata);
+      }
+    }
+    return map;
+  })();
   const handleAddWorkspace = useCallback(
     (projectPath: string) => {
       onAddWorkspace(projectPath);
@@ -613,20 +623,39 @@ const ProjectSidebarInner: React.FC<ProjectSidebarProps> = ({
                                 workspaceRecency
                               );
 
-                              const renderWorkspace = (metadata: FrontendWorkspaceMetadata) => (
-                                <WorkspaceListItem
-                                  key={metadata.id}
-                                  metadata={metadata}
-                                  projectPath={projectPath}
-                                  projectName={projectName}
-                                  isSelected={selectedWorkspace?.workspaceId === metadata.id}
-                                  isDeleting={deletingWorkspaceIds.has(metadata.id)}
-                                  lastReadTimestamp={lastReadTimestamps[metadata.id] ?? 0}
-                                  onSelectWorkspace={handleSelectWorkspace}
-                                  onRemoveWorkspace={handleRemoveWorkspace}
-                                  onToggleUnread={_onToggleUnread}
-                                />
-                              );
+                              const renderWorkspace = (metadata: FrontendWorkspaceMetadata) => {
+                                let indentLevel = 0;
+                                let current: FrontendWorkspaceMetadata | undefined = metadata;
+                                const seen = new Set<string>([metadata.id]);
+
+                                while (current?.parentWorkspaceId) {
+                                  const parentMetadata = workspaceMetadataById.get(
+                                    current.parentWorkspaceId
+                                  );
+                                  if (!parentMetadata || seen.has(parentMetadata.id)) {
+                                    break;
+                                  }
+                                  indentLevel += 1;
+                                  seen.add(parentMetadata.id);
+                                  current = parentMetadata;
+                                }
+
+                                return (
+                                  <WorkspaceListItem
+                                    key={metadata.id}
+                                    metadata={metadata}
+                                    projectPath={projectPath}
+                                    projectName={projectName}
+                                    isSelected={selectedWorkspace?.workspaceId === metadata.id}
+                                    indentLevel={indentLevel}
+                                    isDeleting={deletingWorkspaceIds.has(metadata.id)}
+                                    lastReadTimestamp={lastReadTimestamps[metadata.id] ?? 0}
+                                    onSelectWorkspace={handleSelectWorkspace}
+                                    onRemoveWorkspace={handleRemoveWorkspace}
+                                    onToggleUnread={_onToggleUnread}
+                                  />
+                                );
+                              };
 
                               // Find the next tier with workspaces (skip empty tiers)
                               const findNextNonEmptyTier = (startIndex: number): number => {

src/browser/components/Settings/SettingsModal.tsx

@@ -1,9 +1,10 @@
 import React from "react";
-import { Settings, Key, Cpu, X, Briefcase, FlaskConical } from "lucide-react";
+import { Settings, Key, Cpu, X, Briefcase, FlaskConical, ListTodo } from "lucide-react";
 import { useSettings } from "@/browser/contexts/SettingsContext";
 import { Dialog, DialogContent, DialogTitle, VisuallyHidden } from "@/browser/components/ui/dialog";
 import { GeneralSection } from "./sections/GeneralSection";
 import { ProvidersSection } from "./sections/ProvidersSection";
+import { TasksSection } from "./sections/TasksSection";
 import { ModelsSection } from "./sections/ModelsSection";
 import { Button } from "@/browser/components/ui/button";
 import { ProjectSettingsSection } from "./sections/ProjectSettingsSection";
@@ -35,6 +36,12 @@ const SECTIONS: SettingsSection[] = [
     icon: <Cpu className="h-4 w-4" />,
     component: ModelsSection,
   },
+  {
+    id: "tasks",
+    label: "Tasks",
+    icon: <ListTodo className="h-4 w-4" />,
+    component: TasksSection,
+  },
   {
     id: "experiments",
     label: "Experiments",

src/browser/components/Settings/sections/TasksSection.tsx

@@ -0,0 +1,105 @@
+import React from "react";
+import { useAPI } from "@/browser/contexts/API";
+import { Button } from "@/browser/components/ui/button";
+import { Input } from "@/browser/components/ui/input";
+
+export function TasksSection() {
+  const { api } = useAPI();
+
+  const [maxParallelAgentTasks, setMaxParallelAgentTasks] = React.useState<number>(3);
+  const [maxTaskNestingDepth, setMaxTaskNestingDepth] = React.useState<number>(3);
+  const [isSaving, setIsSaving] = React.useState(false);
+  const [isLoading, setIsLoading] = React.useState(true);
+
+  React.useEffect(() => {
+    let cancelled = false;
+
+    if (!api) {
+      setIsLoading(false);
+      return () => {
+        cancelled = true;
+      };
+    }
+
+    void (async () => {
+      try {
+        const settings = await api.tasks.getTaskSettings();
+        if (cancelled) {
+          return;
+        }
+
+        setMaxParallelAgentTasks(settings.maxParallelAgentTasks);
+        setMaxTaskNestingDepth(settings.maxTaskNestingDepth);
+      } finally {
+        if (!cancelled) {
+          setIsLoading(false);
+        }
+      }
+    })();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [api]);
+
+  const onSave = React.useCallback(async () => {
+    if (!api) {
+      return;
+    }
+
+    setIsSaving(true);
+    try {
+      await api.tasks.setTaskSettings({
+        maxParallelAgentTasks,
+        maxTaskNestingDepth,
+      });
+    } finally {
+      setIsSaving(false);
+    }
+  }, [api, maxParallelAgentTasks, maxTaskNestingDepth]);
+
+  return (
+    <div className="space-y-4">
+      <div className="space-y-2">
+        <h3 className="text-sm font-medium">Agent task limits</h3>
+        <p className="text-muted-foreground text-sm">
+          Control how many subagent workspaces can run at once and how deep nesting is allowed.
+        </p>
+      </div>
+
+      <div className="space-y-3">
+        <div className="flex items-center gap-3">
+          <div className="flex-1">
+            <label className="text-sm">Max parallel subagents</label>
+            <Input
+              type="number"
+              min={1}
+              max={10}
+              value={maxParallelAgentTasks}
+              disabled={isLoading}
+              onChange={(e) => setMaxParallelAgentTasks(Number(e.target.value))}
+            />
+          </div>
+        </div>
+
+        <div className="flex items-center gap-3">
+          <div className="flex-1">
+            <label className="text-sm">Max nesting depth</label>
+            <Input
+              type="number"
+              min={1}
+              max={5}
+              value={maxTaskNestingDepth}
+              disabled={isLoading}
+              onChange={(e) => setMaxTaskNestingDepth(Number(e.target.value))}
+            />
+          </div>
+        </div>
+
+        <Button onClick={() => void onSave()} disabled={isLoading || isSaving}>
+          {isSaving ? "Saving..." : "Save"}
+        </Button>
+      </div>
+    </div>
+  );
+}

src/browser/components/WorkspaceListItem.tsx

@@ -21,6 +21,7 @@ export interface WorkspaceListItemProps {
   metadata: FrontendWorkspaceMetadata;
   projectPath: string;
   projectName: string;
+  indentLevel?: number;
   isSelected: boolean;
   isDeleting?: boolean;
   /** @deprecated No longer used since status dot was removed, kept for API compatibility */
@@ -36,6 +37,7 @@ const WorkspaceListItemInner: React.FC<WorkspaceListItemProps> = ({
   metadata,
   projectPath,
   projectName,
+  indentLevel = 0,
   isSelected,
   isDeleting,
   lastReadTimestamp: _lastReadTimestamp,
@@ -46,6 +48,7 @@ const WorkspaceListItemInner: React.FC<WorkspaceListItemProps> = ({
   // Destructure metadata for convenience
   const { id: workspaceId, namedWorkspacePath, status } = metadata;
   const isCreating = status === "creating";
+  const paddingLeft = 9 + indentLevel * 16;
   const isDisabled = isCreating || isDeleting;
   const gitStatus = useGitStatus(workspaceId);
 
@@ -106,13 +109,14 @@ const WorkspaceListItemInner: React.FC<WorkspaceListItemProps> = ({
     <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"
         )}
+        style={{ paddingLeft }}
         onClick={() => {
           if (isDisabled) return;
           onSelectWorkspace({

src/browser/utils/ui/workspaceFiltering.test.ts

@@ -163,6 +163,26 @@ describe("partitionWorkspacesByAge", () => {
     expect(buckets[2]).toHaveLength(1);
     expect(buckets[2][0].id).toBe("bucket2");
   });
+
+  it("uses the parent workspace's recency for child workspaces", () => {
+    const parent = createWorkspace("parent");
+    const child: FrontendWorkspaceMetadata = {
+      ...createWorkspace("child"),
+      parentWorkspaceId: "parent",
+    };
+
+    const workspaces = [parent, child];
+
+    const workspaceRecency = {
+      parent: now - 1 * ONE_DAY_MS, // recent
+      child: now - 60 * ONE_DAY_MS, // old (but should inherit parent's)
+    };
+
+    const { recent, buckets } = partitionWorkspacesByAge(workspaces, workspaceRecency);
+
+    expect(recent.map((w) => w.id)).toEqual(["parent", "child"]);
+    expect(getAllOld(buckets)).toHaveLength(0);
+  });
 });
 
 describe("formatDaysThreshold", () => {
@@ -272,10 +292,45 @@ describe("buildSortedWorkspacesByProject", () => {
     };
 
     const result = buildSortedWorkspacesByProject(projects, metadata, recency);
-
     expect(result.get("/project/a")?.map((w) => w.id)).toEqual(["ws2", "ws3", "ws1"]);
   });
 
+  it("nests child workspaces directly under their parent", () => {
+    const now = Date.now();
+    const projects = new Map<string, ProjectConfig>([
+      [
+        "/project/a",
+        {
+          workspaces: [
+            { path: "/a/parent", id: "parent" },
+            { path: "/a/child", id: "child" },
+          ],
+        },
+      ],
+    ]);
+
+    const parent = createWorkspace("parent", "/project/a");
+    const child: FrontendWorkspaceMetadata = {
+      ...createWorkspace("child", "/project/a"),
+      parentWorkspaceId: "parent",
+    };
+
+    const metadata = new Map<string, FrontendWorkspaceMetadata>([
+      ["parent", parent],
+      ["child", child],
+    ]);
+
+    // Child is more recent, but should still render under its parent.
+    const recency = {
+      parent: now - 2 * 60 * 60 * 1000,
+      child: now - 1 * 60 * 60 * 1000,
+    };
+
+    const result = buildSortedWorkspacesByProject(projects, metadata, recency);
+
+    expect(result.get("/project/a")?.map((w) => w.id)).toEqual(["parent", "child"]);
+  });
+
   it("should not duplicate workspaces that exist in both config and have creating status", () => {
     // Edge case: workspace was saved to config but still has status: "creating"
     // (this shouldn't happen in practice but tests defensive coding)