From 9cf4d0de6401979c122065216c300a8f400fdf1c Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Fri, 12 Dec 2025 17:12:21 -0800
Subject: [PATCH 01/35] refactor: rename workspace to task in renderer

---
 src/renderer/App.tsx                          | 104 +++++++++---------
 src/renderer/components/ActiveRuns.tsx        |   6 +-
 src/renderer/components/ChatInterface.tsx     |  94 ++++++++--------
 .../components/CommandPaletteWrapper.tsx      |   6 +-
 src/renderer/components/LeftSidebar.tsx       |  48 ++++----
 ...iAgentWorkspace.tsx => MultiAgentTask.tsx} |  38 +++----
 src/renderer/components/ProjectMainView.tsx   |  52 ++++-----
 src/renderer/components/RightSidebar.tsx      |  28 ++---
 .../{WorkspaceChanges.tsx => TaskChanges.tsx} |   0
 ...eDeleteButton.tsx => TaskDeleteButton.tsx} |   0
 .../{WorkspaceItem.tsx => TaskItem.tsx}       |  42 +++----
 .../{WorkspaceList.tsx => TaskList.tsx}       |  50 ++++-----
 .../{WorkspaceModal.tsx => TaskModal.tsx}     |  40 +++----
 .../{WorkspacePorts.tsx => TaskPorts.tsx}     |   0
 ...erminalPanel.tsx => TaskTerminalPanel.tsx} |  18 +--
 .../components/kanban/KanbanBoard.tsx         |   8 +-
 src/renderer/components/kanban/KanbanCard.tsx |   6 +-
 ...Switch.ts => useAutoScrollOnTaskSwitch.ts} |  18 +--
 src/renderer/hooks/useCreatePR.tsx            |   2 +-
 .../{useWorkspaceBusy.ts => useTaskBusy.ts}   |   4 +-
 ...eWorkspaceChanges.ts => useTaskChanges.ts} |  24 ++--
 .../lib/{workspaceNames.ts => taskNames.ts}   |  44 ++++----
 .../lib/{workspaceStatus.ts => taskStatus.ts} |   0
 ...erminalsStore.ts => taskTerminalsStore.ts} |  52 ++++-----
 src/renderer/types/app.ts                     |  11 +-
 src/renderer/types/chat.ts                    |  14 +--
 src/renderer/types/index.ts                   |   2 +-
 27 files changed, 355 insertions(+), 356 deletions(-)
 rename src/renderer/components/{MultiAgentWorkspace.tsx => MultiAgentTask.tsx} (94%)
 rename src/renderer/components/{WorkspaceChanges.tsx => TaskChanges.tsx} (100%)
 rename src/renderer/components/{WorkspaceDeleteButton.tsx => TaskDeleteButton.tsx} (100%)
 rename src/renderer/components/{WorkspaceItem.tsx => TaskItem.tsx} (76%)
 rename src/renderer/components/{WorkspaceList.tsx => TaskList.tsx} (70%)
 rename src/renderer/components/{WorkspaceModal.tsx => TaskModal.tsx} (96%)
 rename src/renderer/components/{WorkspacePorts.tsx => TaskPorts.tsx} (100%)
 rename src/renderer/components/{WorkspaceTerminalPanel.tsx => TaskTerminalPanel.tsx} (94%)
 rename src/renderer/hooks/{useAutoScrollOnWorkspaceSwitch.ts => useAutoScrollOnTaskSwitch.ts} (78%)
 rename src/renderer/hooks/{useWorkspaceBusy.ts => useTaskBusy.ts} (53%)
 rename src/renderer/hooks/{useWorkspaceChanges.ts => useTaskChanges.ts} (80%)
 rename src/renderer/lib/{workspaceNames.ts => taskNames.ts} (63%)
 rename src/renderer/lib/{workspaceStatus.ts => taskStatus.ts} (100%)
 rename src/renderer/lib/{workspaceTerminalsStore.ts => taskTerminalsStore.ts} (84%)

diff --git a/src/renderer/App.tsx b/src/renderer/App.tsx
index a5a75be3..a53ad069 100644
--- a/src/renderer/App.tsx
+++ b/src/renderer/App.tsx
@@ -3,9 +3,9 @@ import { Button } from './components/ui/button';
 import { FolderOpen } from 'lucide-react';
 import LeftSidebar from './components/LeftSidebar';
 import ProjectMainView from './components/ProjectMainView';
-import WorkspaceModal from './components/WorkspaceModal';
+import TaskModal from './components/TaskModal';
 import ChatInterface from './components/ChatInterface';
-import MultiAgentWorkspace from './components/MultiAgentWorkspace';
+import MultiAgentTask from './components/MultiAgentTask';
 import { Toaster } from './components/ui/toaster';
 import useUpdateNotifier from './hooks/useUpdateNotifier';
 import RequirementsNotice from './components/RequirementsNotice';
@@ -30,8 +30,8 @@ import type { ImperativePanelHandle } from 'react-resizable-panels';
 import SettingsModal from './components/SettingsModal';
 import CommandPaletteWrapper from './components/CommandPaletteWrapper';
 import FirstLaunchModal from './components/FirstLaunchModal';
-import type { Project, Workspace } from './types/app';
-import type { WorkspaceMetadata as ChatWorkspaceMetadata } from './types/chat';
+import type { Project, Task } from './types/app';
+import type { TaskMetadata } from './types/chat';
 import AppKeyboardShortcuts from './components/AppKeyboardShortcuts';
 import { usePlanToasts } from './hooks/usePlanToasts';
 import { terminalSessionRegistry } from './terminal/SessionRegistry';
@@ -78,8 +78,6 @@ const RightSidebarBridge: React.FC<{
   return null;
 };
 
-// Shared types
-type WorkspaceMetadata = ChatWorkspaceMetadata;
 
 const TITLEBAR_HEIGHT = '36px';
 const PANEL_LAYOUT_STORAGE_KEY = 'emdash.layout.left-main-right.v2';
@@ -121,11 +119,11 @@ const AppContent: React.FC = () => {
   const [showDeviceFlowModal, setShowDeviceFlowModal] = useState(false);
   const [projects, setProjects] = useState<Project[]>([]);
   const [selectedProject, setSelectedProject] = useState<Project | null>(null);
-  const [showWorkspaceModal, setShowWorkspaceModal] = useState<boolean>(false);
+  const [showTaskModal, setShowTaskModal] = useState<boolean>(false);
   const [showHomeView, setShowHomeView] = useState<boolean>(true);
-  const [isCreatingWorkspace, setIsCreatingWorkspace] = useState<boolean>(false);
-  const [activeWorkspace, setActiveWorkspace] = useState<Workspace | null>(null);
-  const [activeWorkspaceProvider, setActiveWorkspaceProvider] = useState<Provider | null>(null);
+  const [isCreatingTask, setIsCreatingWorkspace] = useState<boolean>(false);
+  const [activeTask, setActiveWorkspace] = useState<Task | null>(null);
+  const [activeTaskProvider, setActiveWorkspaceProvider] = useState<Provider | null>(null);
   const [installedProviders, setInstalledProviders] = useState<Record<string, boolean>>({});
   const [showSettings, setShowSettings] = useState<boolean>(false);
   const [showCommandPalette, setShowCommandPalette] = useState<boolean>(false);
@@ -135,7 +133,7 @@ const AppContent: React.FC = () => {
   const showAgentRequirement =
     Object.keys(installedProviders).length > 0 &&
     Object.values(installedProviders).every((v) => v === false);
-  const deletingWorkspaceIdsRef = useRef<Set<string>>(new Set());
+  const deletingTaskIdsRef = useRef<Set<string>>(new Set());
 
   const normalizePathForComparison = useCallback(
     (input: string | null | undefined) => {
@@ -811,7 +809,7 @@ const AppContent: React.FC = () => {
         preparedPrompt = parts.join('\n');
       }
 
-      const workspaceMetadata: WorkspaceMetadata | null =
+      const workspaceMetadata: TaskMetadata | null =
         linkedLinearIssue || linkedJiraIssue || linkedGithubIssue || preparedPrompt || autoApprove
           ? {
               linearIssue: linkedLinearIssue ?? null,
@@ -827,7 +825,7 @@ const AppContent: React.FC = () => {
       const isMultiAgent = totalRuns > 1;
       const primaryProvider = providerRuns[0]?.provider || 'claude';
 
-      let newWorkspace: Workspace;
+      let newWorkspace: Task;
       if (isMultiAgent) {
         // Multi-agent workspace: create worktrees for each provider×runs combo
         const variants: Array<{
@@ -867,7 +865,7 @@ const AppContent: React.FC = () => {
           }
         }
 
-        const multiMeta: WorkspaceMetadata = {
+        const multiMeta: TaskMetadata = {
           ...(workspaceMetadata || {}),
           multiAgent: {
             enabled: true,
@@ -1154,7 +1152,7 @@ const AppContent: React.FC = () => {
     activateProjectView(project);
   };
 
-  const handleSelectWorkspace = (workspace: Workspace) => {
+  const handleSelectWorkspace = (workspace: Task) => {
     setActiveWorkspace(workspace);
     // Load provider from workspace.agentId if it exists, otherwise default to null
     // This ensures the selected provider persists across app restarts
@@ -1170,13 +1168,13 @@ const AppContent: React.FC = () => {
     (project: Project) => {
       const targetProject = projects.find((p) => p.id === project.id) || project;
       activateProjectView(targetProject);
-      setShowWorkspaceModal(true);
+      setShowTaskModal(true);
     },
     [activateProjectView, projects]
   );
 
   const removeWorkspaceFromState = (projectId: string, workspaceId: string, wasActive: boolean) => {
-    const filterWorkspaces = (list?: Workspace[]) =>
+    const filterWorkspaces = (list?: Task[]) =>
       (list || []).filter((w) => w.id !== workspaceId);
 
     setProjects((prev) =>
@@ -1201,10 +1199,10 @@ const AppContent: React.FC = () => {
 
   const handleDeleteWorkspace = async (
     targetProject: Project,
-    workspace: Workspace,
+    workspace: Task,
     options?: { silent?: boolean }
   ): Promise<boolean> => {
-    if (deletingWorkspaceIdsRef.current.has(workspace.id)) {
+    if (deletingTaskIdsRef.current.has(workspace.id)) {
       toast({
         title: 'Deletion in progress',
         description: `"${workspace.name}" is already being removed.`,
@@ -1212,9 +1210,9 @@ const AppContent: React.FC = () => {
       return false;
     }
 
-    const wasActive = activeWorkspace?.id === workspace.id;
+    const wasActive = activeTask?.id === workspace.id;
     const workspaceSnapshot = { ...workspace };
-    deletingWorkspaceIdsRef.current.add(workspace.id);
+    deletingTaskIdsRef.current.add(workspace.id);
     removeWorkspaceFromState(targetProject.id, workspace.id, wasActive);
 
     const runDeletion = async (): Promise<boolean> => {
@@ -1359,7 +1357,7 @@ const AppContent: React.FC = () => {
         }
         return false;
       } finally {
-        deletingWorkspaceIdsRef.current.delete(workspace.id);
+        deletingTaskIdsRef.current.delete(workspace.id);
       }
     };
 
@@ -1492,7 +1490,7 @@ const AppContent: React.FC = () => {
               handleSelectWorkspace(ws);
               setShowKanban(false);
             }}
-            onCreateWorkspace={() => setShowWorkspaceModal(true)}
+            onCreateWorkspace={() => setShowTaskModal(true)}
           />
         </div>
       );
@@ -1561,29 +1559,29 @@ const AppContent: React.FC = () => {
     if (selectedProject) {
       return (
         <div className="flex min-h-0 flex-1 flex-col overflow-hidden">
-          {activeWorkspace ? (
-            (activeWorkspace.metadata as any)?.multiAgent?.enabled ? (
-              <MultiAgentWorkspace
-                workspace={activeWorkspace}
+          {activeTask ? (
+            (activeTask.metadata as any)?.multiAgent?.enabled ? (
+              <MultiAgentTask
+                task={activeTask}
                 projectName={selectedProject.name}
                 projectId={selectedProject.id}
               />
             ) : (
               <ChatInterface
-                workspace={activeWorkspace}
+                task={activeTask}
                 projectName={selectedProject.name}
                 className="min-h-0 flex-1"
-                initialProvider={activeWorkspaceProvider || undefined}
+                initialProvider={activeTaskProvider || undefined}
               />
             )
           ) : (
             <ProjectMainView
               project={selectedProject}
-              onCreateWorkspace={() => setShowWorkspaceModal(true)}
-              activeWorkspace={activeWorkspace}
-              onSelectWorkspace={handleSelectWorkspace}
-              onDeleteWorkspace={handleDeleteWorkspace}
-              isCreatingWorkspace={isCreatingWorkspace}
+              onCreateTask={() => setShowTaskModal(true)}
+              activeTask={activeTask}
+              onSelectTask={handleSelectWorkspace}
+              onDeleteTask={handleDeleteWorkspace}
+              isCreatingTask={isCreatingTask}
               onDeleteProject={handleDeleteProject}
             />
           )}
@@ -1654,19 +1652,19 @@ const AppContent: React.FC = () => {
               onToggleSettings={handleToggleSettings}
               isSettingsOpen={showSettings}
               currentPath={
-                activeWorkspace?.metadata?.multiAgent?.enabled
+                activeTask?.metadata?.multiAgent?.enabled
                   ? null
-                  : activeWorkspace?.path || selectedProject?.path || null
+                  : activeTask?.path || selectedProject?.path || null
               }
               defaultPreviewUrl={
-                activeWorkspace?.id
-                  ? getContainerRunState(activeWorkspace.id)?.previewUrl || null
+                activeTask?.id
+                  ? getContainerRunState(activeTask.id)?.previewUrl || null
                   : null
               }
-              workspaceId={activeWorkspace?.id || null}
-              workspacePath={activeWorkspace?.path || null}
+              workspaceId={activeTask?.id || null}
+              workspacePath={activeTask?.path || null}
               projectPath={selectedProject?.path || null}
-              isWorkspaceMultiAgent={Boolean(activeWorkspace?.metadata?.multiAgent?.enabled)}
+              isWorkspaceMultiAgent={Boolean(activeTask?.metadata?.multiAgent?.enabled)}
               githubUser={user}
               onToggleKanban={handleToggleKanban}
               isKanbanOpen={Boolean(showKanban)}
@@ -1694,8 +1692,8 @@ const AppContent: React.FC = () => {
                     onSelectProject={handleSelectProject}
                     onGoHome={handleGoHome}
                     onOpenProject={handleOpenProject}
-                    onSelectWorkspace={handleSelectWorkspace}
-                    activeWorkspace={activeWorkspace || undefined}
+                    onSelectTask={handleSelectWorkspace}
+                    activeTask={activeTask || undefined}
                     onReorderProjects={handleReorderProjects}
                     onReorderProjectsFull={handleReorderProjectsFull}
                     githubInstalled={ghInstalled}
@@ -1705,9 +1703,9 @@ const AppContent: React.FC = () => {
                     githubLoading={githubLoading}
                     githubStatusMessage={githubStatusMessage}
                     onSidebarContextChange={handleSidebarContextChange}
-                    onCreateWorkspaceForProject={handleStartCreateWorkspaceFromSidebar}
-                    isCreatingWorkspace={isCreatingWorkspace}
-                    onDeleteWorkspace={handleDeleteWorkspace}
+                    onCreateTaskForProject={handleStartCreateWorkspaceFromSidebar}
+                    isCreatingTask={isCreatingTask}
+                    onDeleteTask={handleDeleteWorkspace}
                     onDeleteProject={handleDeleteProject}
                     isHomeView={showHomeView}
                   />
@@ -1740,7 +1738,7 @@ const AppContent: React.FC = () => {
                   collapsible
                   order={3}
                 >
-                  <RightSidebar workspace={activeWorkspace} className="lg:border-l-0" />
+                  <RightSidebar task={activeTask} className="lg:border-l-0" />
                 </ResizablePanel>
               </ResizablePanelGroup>
             </div>
@@ -1755,9 +1753,9 @@ const AppContent: React.FC = () => {
               handleOpenProject={handleOpenProject}
               handleOpenSettings={handleOpenSettings}
             />
-            <WorkspaceModal
-              isOpen={showWorkspaceModal}
-              onClose={() => setShowWorkspaceModal(false)}
+            <TaskModal
+              isOpen={showTaskModal}
+              onClose={() => setShowTaskModal(false)}
               onCreateWorkspace={handleCreateWorkspace}
               projectName={selectedProject?.name || ''}
               defaultBranch={selectedProject?.gitInfo.branch || 'main'}
@@ -1773,10 +1771,10 @@ const AppContent: React.FC = () => {
             />
             <Toaster />
             <BrowserPane
-              workspaceId={activeWorkspace?.id || null}
-              workspacePath={activeWorkspace?.path || null}
+              workspaceId={activeTask?.id || null}
+              workspacePath={activeTask?.path || null}
               overlayActive={
-                showSettings || showCommandPalette || showWorkspaceModal || showFirstLaunchModal
+                showSettings || showCommandPalette || showTaskModal || showFirstLaunchModal
               }
             />
           </RightSidebarProvider>
diff --git a/src/renderer/components/ActiveRuns.tsx b/src/renderer/components/ActiveRuns.tsx
index 9ce723bc..d51a69ab 100644
--- a/src/renderer/components/ActiveRuns.tsx
+++ b/src/renderer/components/ActiveRuns.tsx
@@ -17,10 +17,10 @@ import {
 interface Props {
   projects: any[];
   onSelectProject?: (project: any) => void;
-  onSelectWorkspace?: (workspace: any) => void;
+  onSelectTask?: (task: any) => void;
 }
 
-const ActiveRuns: React.FC<Props> = ({ projects, onSelectProject, onSelectWorkspace }) => {
+const ActiveRuns: React.FC<Props> = ({ projects, onSelectProject, onSelectTask }) => {
   const [activeRuns, setActiveRuns] = React.useState<ContainerRunState[]>(() =>
     (getAllRunStates() || []).filter((s) => ['building', 'starting', 'ready'].includes(s.status))
   );
@@ -71,7 +71,7 @@ const ActiveRuns: React.FC<Props> = ({ projects, onSelectProject, onSelectWorksp
             const onOpen = () => {
               if (project && ws) {
                 onSelectProject?.(project);
-                onSelectWorkspace?.(ws);
+                onSelectTask?.(ws);
               }
             };
             return (
diff --git a/src/renderer/components/ChatInterface.tsx b/src/renderer/components/ChatInterface.tsx
index 5e1099a8..e56f3898 100644
--- a/src/renderer/components/ChatInterface.tsx
+++ b/src/renderer/components/ChatInterface.tsx
@@ -14,16 +14,16 @@ import { usePlanActivationTerminal } from '@/hooks/usePlanActivation';
 import { log } from '@/lib/logger';
 import { logPlanEvent } from '@/lib/planLogs';
 import { type Provider } from '../types';
-import { Workspace } from '../types/chat';
+import { Task } from '../types/chat';
 import {
   getContainerRunState,
   subscribeToWorkspaceRunState,
   type ContainerRunState,
 } from '@/lib/containerRuns';
 import { useBrowser } from '@/providers/BrowserProvider';
-import { useWorkspaceTerminals } from '@/lib/workspaceTerminalsStore';
+import { useTaskTerminals } from '@/lib/taskTerminalsStore';
 import { getInstallCommandForProvider } from '@shared/providers/registry';
-import { useAutoScrollOnWorkspaceSwitch } from '@/hooks/useAutoScrollOnWorkspaceSwitch';
+import { useAutoScrollOnTaskSwitch } from '@/hooks/useAutoScrollOnTaskSwitch';
 
 declare const window: Window & {
   electronAPI: {
@@ -32,14 +32,14 @@ declare const window: Window & {
 };
 
 interface Props {
-  workspace: Workspace;
+  task: Task;
   projectName: string;
   className?: string;
   initialProvider?: Provider;
 }
 
 const ChatInterface: React.FC<Props> = ({
-  workspace,
+  task,
   projectName: _projectName,
   className,
   initialProvider,
@@ -55,33 +55,33 @@ const ChatInterface: React.FC<Props> = ({
   const browser = useBrowser();
   const [cliStartFailed, setCliStartFailed] = useState(false);
   const [containerState, setContainerState] = useState<ContainerRunState | undefined>(() =>
-    getContainerRunState(workspace.id)
+    getContainerRunState(task.id)
   );
   const reduceMotion = useReducedMotion();
-  const terminalId = useMemo(() => `${provider}-main-${workspace.id}`, [provider, workspace.id]);
+  const terminalId = useMemo(() => `${provider}-main-${task.id}`, [provider, task.id]);
   const [portsExpanded, setPortsExpanded] = useState(false);
-  const { activeTerminalId } = useWorkspaceTerminals(workspace.id, workspace.path);
+  const { activeTerminalId } = useTaskTerminals(task.id, task.path);
 
   // Auto-scroll to bottom when this workspace becomes active
-  useAutoScrollOnWorkspaceSwitch(true, workspace.id);
+  useAutoScrollOnTaskSwitch(true, task.id);
 
   // Unified Plan Mode (per workspace)
   const { enabled: planEnabled, setEnabled: setPlanEnabled } = usePlanMode(
-    workspace.id,
-    workspace.path
+    task.id,
+    task.path
   );
 
   // Log transitions for visibility
   useEffect(() => {
-    log.info('[plan] state changed', { workspaceId: workspace.id, enabled: planEnabled });
-  }, [planEnabled, workspace.id]);
+    log.info('[plan] state changed', { workspaceId: task.id, enabled: planEnabled });
+  }, [planEnabled, task.id]);
 
   // For terminal providers with native plan activation commands
   usePlanActivationTerminal({
     enabled: planEnabled,
     providerId: provider,
-    workspaceId: workspace.id,
-    workspacePath: workspace.path,
+    workspaceId: task.id,
+    workspacePath: task.path,
   });
 
   useEffect(() => {
@@ -126,8 +126,8 @@ const ChatInterface: React.FC<Props> = ({
   useEffect(() => {
     setCliStartFailed(false);
     setIsProviderInstalled(null);
-    setContainerState(getContainerRunState(workspace.id));
-  }, [workspace.id]);
+    setContainerState(getContainerRunState(task.id));
+  }, [task.id]);
 
   const runInstallCommand = useCallback(
     (cmd: string) => {
@@ -179,7 +179,7 @@ const ChatInterface: React.FC<Props> = ({
   // If a locked provider exists (including Droid), prefer locked.
   useEffect(() => {
     try {
-      const lastKey = `provider:last:${workspace.id}`;
+      const lastKey = `provider:last:${task.id}`;
       const last = window.localStorage.getItem(lastKey) as Provider | null;
 
       if (initialProvider) {
@@ -210,14 +210,14 @@ const ChatInterface: React.FC<Props> = ({
     } catch {
       setProvider(initialProvider || 'codex');
     }
-  }, [workspace.id, initialProvider]);
+  }, [task.id, initialProvider]);
 
   // Persist last-selected provider per workspace (including Droid)
   useEffect(() => {
     try {
-      window.localStorage.setItem(`provider:last:${workspace.id}`, provider);
+      window.localStorage.setItem(`provider:last:${task.id}`, provider);
     } catch {}
-  }, [provider, workspace.id]);
+  }, [provider, task.id]);
 
   // Track provider switching
   const prevProviderRef = React.useRef<Provider | null>(null);
@@ -303,7 +303,7 @@ const ChatInterface: React.FC<Props> = ({
       cancelled = true;
       off?.();
     };
-  }, [provider, workspace.id]);
+  }, [provider, task.id]);
 
   // If we don't even have a cached status entry for the current provider, pessimistically
   // show the install banner and kick off a background refresh to populate it.
@@ -349,13 +349,13 @@ const ChatInterface: React.FC<Props> = ({
       try {
       } catch {}
     })();
-  }, [provider, workspace.id]);
+  }, [provider, task.id]);
 
   const isTerminal = providerMeta[provider]?.terminalOnly === true;
 
   const initialInjection = useMemo(() => {
     if (!isTerminal) return null;
-    const md = workspace.metadata || null;
+    const md = task.metadata || null;
     const p = (md?.initialPrompt || '').trim();
     if (p) return p;
     const issue = md?.linearIssue;
@@ -442,12 +442,12 @@ const ChatInterface: React.FC<Props> = ({
       return lines.join('\n');
     }
     return null;
-  }, [isTerminal, workspace.metadata]);
+  }, [isTerminal, task.metadata]);
 
   // Only use keystroke injection for providers WITHOUT CLI flag support
   // Providers with initialPromptFlag use CLI arg injection via TerminalPane instead
   useInitialPromptInjection({
-    workspaceId: workspace.id,
+    workspaceId: task.id,
     providerId: provider,
     prompt: initialInjection,
     enabled: isTerminal && providerMeta[provider]?.initialPromptFlag === undefined,
@@ -456,18 +456,18 @@ const ChatInterface: React.FC<Props> = ({
   // Ensure a provider is stored for this workspace so fallbacks can subscribe immediately
   useEffect(() => {
     try {
-      localStorage.setItem(`workspaceProvider:${workspace.id}`, provider);
+      localStorage.setItem(`workspaceProvider:${task.id}`, provider);
     } catch {}
-  }, [provider, workspace.id]);
+  }, [provider, task.id]);
 
   useEffect(() => {
-    const off = subscribeToWorkspaceRunState(workspace.id, (state) => {
+    const off = subscribeToWorkspaceRunState(task.id, (state) => {
       setContainerState(state);
     });
     return () => {
       off?.();
     };
-  }, [workspace.id]);
+  }, [task.id]);
 
   const containerStatusNode = useMemo(() => {
     const state = containerState;
@@ -502,7 +502,7 @@ const ChatInterface: React.FC<Props> = ({
             const res = await api.resolveServiceIcon({
               service: name,
               allowNetwork: true,
-              workspacePath: workspace.path,
+              workspacePath: task.path,
             });
             if (!cancelled && res?.ok && typeof res.dataUrl === 'string') setSrc(res.dataUrl);
           } catch {}
@@ -518,7 +518,7 @@ const ChatInterface: React.FC<Props> = ({
       if (dbPorts.has(port)) return <Database className="h-3.5 w-3.5" aria-hidden="true" />;
       return <Server className="h-3.5 w-3.5" aria-hidden="true" />;
     };
-    const isMultiAgent = workspace.metadata?.multiAgent?.enabled === true;
+    const isMultiAgent = task.metadata?.multiAgent?.enabled === true;
     return (
       <div className="mt-4 px-6">
         <div className="mx-auto max-w-4xl rounded-md border border-border bg-muted/20 px-4 py-3 text-sm">
@@ -551,7 +551,7 @@ const ChatInterface: React.FC<Props> = ({
                   onClick={() => setPortsExpanded((v) => !v)}
                   className="inline-flex h-8 items-center justify-center gap-1.5 rounded-md border border-border/70 bg-background px-2.5 text-xs font-medium"
                   aria-expanded={portsExpanded}
-                  aria-controls={`chat-ports-${workspace.id}`}
+                  aria-controls={`chat-ports-${task.id}`}
                 >
                   <ChevronDown
                     className={[
@@ -592,7 +592,7 @@ const ChatInterface: React.FC<Props> = ({
           <AnimatePresence initial={false}>
             {portsExpanded && sorted.length ? (
               <motion.div
-                id={`chat-ports-${workspace.id}`}
+                id={`chat-ports-${task.id}`}
                 className="text-xs text-muted-foreground"
                 initial={reduceMotion ? false : { opacity: 0, height: 0, paddingTop: 0 }}
                 animate={{ opacity: 1, height: 'auto', paddingTop: 8 }}
@@ -646,7 +646,7 @@ const ChatInterface: React.FC<Props> = ({
         </div>
       </div>
     );
-  }, [containerState, portsExpanded, reduceMotion, workspace.id, workspace.path]);
+  }, [containerState, portsExpanded, reduceMotion, task.id, task.path]);
 
   if (!isTerminal) {
     return null;
@@ -700,20 +700,20 @@ const ChatInterface: React.FC<Props> = ({
           >
             <TerminalPane
               id={terminalId}
-              cwd={workspace.path}
+              cwd={task.path}
               shell={providerMeta[provider].cli}
               env={
                 planEnabled
                   ? {
                       EMDASH_PLAN_MODE: '1',
-                      EMDASH_PLAN_FILE: `${workspace.path}/.emdash/planning.md`,
+                      EMDASH_PLAN_FILE: `${task.path}/.emdash/planning.md`,
                     }
                   : undefined
               }
               keepAlive={true}
               onActivity={() => {
                 try {
-                  window.localStorage.setItem(`provider:locked:${workspace.id}`, provider);
+                  window.localStorage.setItem(`provider:locked:${task.id}`, provider);
                 } catch {}
               }}
               onStartError={() => {
@@ -722,11 +722,11 @@ const ChatInterface: React.FC<Props> = ({
               onStartSuccess={() => {
                 setCliStartFailed(false);
                 // Mark initial injection as sent so it won't re-run on restart
-                if (initialInjection && !workspace.metadata?.initialInjectionSent) {
+                if (initialInjection && !task.metadata?.initialInjectionSent) {
                   void window.electronAPI.saveWorkspace({
-                    ...workspace,
+                    ...task,
                     metadata: {
-                      ...workspace.metadata,
+                      ...task.metadata,
                       initialInjectionSent: true,
                     },
                   });
@@ -747,7 +747,7 @@ const ChatInterface: React.FC<Props> = ({
               }
               initialPrompt={
                 providerMeta[provider]?.initialPromptFlag !== undefined &&
-                !workspace.metadata?.initialInjectionSent
+                !task.metadata?.initialInjectionSent
                   ? (initialInjection ?? undefined)
                   : undefined
               }
@@ -759,15 +759,15 @@ const ChatInterface: React.FC<Props> = ({
 
       <ProviderBar
         provider={provider}
-        workspaceId={workspace.id}
-        linearIssue={workspace.metadata?.linearIssue || null}
-        githubIssue={workspace.metadata?.githubIssue || null}
-        jiraIssue={workspace.metadata?.jiraIssue || null}
+        workspaceId={task.id}
+        linearIssue={task.metadata?.linearIssue || null}
+        githubIssue={task.metadata?.githubIssue || null}
+        jiraIssue={task.metadata?.jiraIssue || null}
         planModeEnabled={planEnabled}
         onPlanModeChange={setPlanEnabled}
         onApprovePlan={async () => {
           try {
-            await logPlanEvent(workspace.path, 'Plan approved via UI; exiting Plan Mode');
+            await logPlanEvent(task.path, 'Plan approved via UI; exiting Plan Mode');
           } catch {}
           setPlanEnabled(false);
         }}
diff --git a/src/renderer/components/CommandPaletteWrapper.tsx b/src/renderer/components/CommandPaletteWrapper.tsx
index e20169e7..02401d74 100644
--- a/src/renderer/components/CommandPaletteWrapper.tsx
+++ b/src/renderer/components/CommandPaletteWrapper.tsx
@@ -3,14 +3,14 @@ import CommandPalette from '../components/CommandPalette';
 import { useSidebar } from '../components/ui/sidebar';
 import { useRightSidebar } from '../components/ui/right-sidebar';
 import { useTheme } from '../hooks/useTheme';
-import type { Project, Workspace } from '../types/app';
+import type { Project, Task } from '../types/app';
 
 export interface CommandPaletteWrapperProps {
   isOpen: boolean;
   onClose: () => void;
   projects: Project[];
   handleSelectProject: (project: Project) => void;
-  handleSelectWorkspace: (workspace: Workspace) => void;
+  handleSelectWorkspace: (workspace: Task) => void;
   handleGoHome: () => void;
   handleOpenProject: () => void;
   handleOpenSettings: () => void;
@@ -41,7 +41,7 @@ const CommandPaletteWrapper: React.FC<CommandPaletteWrapperProps> = ({
       }}
       onSelectWorkspace={(projectId, workspaceId) => {
         const project = projects.find((p) => p.id === projectId);
-        const workspace = project?.workspaces?.find((w: Workspace) => w.id === workspaceId);
+        const workspace = project?.workspaces?.find((w: Task) => w.id === workspaceId);
         if (project && workspace) {
           handleSelectProject(project);
           handleSelectWorkspace(workspace);
diff --git a/src/renderer/components/LeftSidebar.tsx b/src/renderer/components/LeftSidebar.tsx
index a3406fb3..b1aa6b1c 100644
--- a/src/renderer/components/LeftSidebar.tsx
+++ b/src/renderer/components/LeftSidebar.tsx
@@ -18,10 +18,10 @@ import { Home, ChevronDown, Plus, FolderOpen } from 'lucide-react';
 import ActiveRuns from './ActiveRuns';
 import SidebarEmptyState from './SidebarEmptyState';
 import GithubStatus from './GithubStatus';
-import { WorkspaceItem } from './WorkspaceItem';
+import { TaskItem } from './TaskItem';
 import ProjectDeleteButton from './ProjectDeleteButton';
 import type { Project } from '../types/app';
-import type { Workspace } from '../types/chat';
+import type { Task } from '../types/chat';
 
 interface LeftSidebarProps {
   projects: Project[];
@@ -29,8 +29,8 @@ interface LeftSidebarProps {
   onSelectProject: (project: Project) => void;
   onGoHome: () => void;
   onOpenProject?: () => void;
-  onSelectWorkspace?: (workspace: Workspace) => void;
-  activeWorkspace?: Workspace | null;
+  onSelectTask?: (task: Task) => void;
+  activeTask?: Task | null;
   onReorderProjects?: (sourceId: string, targetId: string) => void;
   onReorderProjectsFull?: (newOrder: Project[]) => void;
   githubInstalled?: boolean;
@@ -44,9 +44,9 @@ interface LeftSidebarProps {
     isMobile: boolean;
     setOpen: (next: boolean) => void;
   }) => void;
-  onCreateWorkspaceForProject?: (project: Project) => void;
-  isCreatingWorkspace?: boolean;
-  onDeleteWorkspace?: (project: Project, workspace: Workspace) => void | Promise<void | boolean>;
+  onCreateTaskForProject?: (project: Project) => void;
+  isCreatingTask?: boolean;
+  onDeleteTask?: (project: Project, task: Task) => void | Promise<void | boolean>;
   onDeleteProject?: (project: Project) => void | Promise<void>;
   isHomeView?: boolean;
 }
@@ -57,8 +57,8 @@ const LeftSidebar: React.FC<LeftSidebarProps> = ({
   onSelectProject,
   onGoHome,
   onOpenProject,
-  onSelectWorkspace,
-  activeWorkspace,
+  onSelectTask,
+  activeTask,
   onReorderProjects,
   onReorderProjectsFull,
   githubInstalled = true,
@@ -68,9 +68,9 @@ const LeftSidebar: React.FC<LeftSidebarProps> = ({
   githubLoading = false,
   githubStatusMessage,
   onSidebarContextChange,
-  onCreateWorkspaceForProject,
-  isCreatingWorkspace,
-  onDeleteWorkspace,
+  onCreateTaskForProject,
+  isCreatingTask,
+  onDeleteTask,
   onDeleteProject,
   isHomeView,
 }) => {
@@ -153,7 +153,7 @@ const LeftSidebar: React.FC<LeftSidebarProps> = ({
           <ActiveRuns
             projects={projects}
             onSelectProject={onSelectProject}
-            onSelectWorkspace={onSelectWorkspace}
+            onSelectTask={onSelectTask}
           />
 
           {projects.length === 0 && (
@@ -264,9 +264,9 @@ const LeftSidebar: React.FC<LeftSidebarProps> = ({
                                     } else if (!selectedProject) {
                                       onSelectProject?.(typedProject);
                                     }
-                                    onCreateWorkspaceForProject?.(typedProject);
+                                    onCreateTaskForProject?.(typedProject);
                                   }}
-                                  disabled={isCreatingWorkspace}
+                                  disabled={isCreatingTask}
                                   aria-label={`Add Task to ${typedProject.name}`}
                                 >
                                   <Plus
@@ -277,11 +277,11 @@ const LeftSidebar: React.FC<LeftSidebarProps> = ({
                                 </button>
                               </div>
                               <div className="hidden min-w-0 space-y-1 sm:block">
-                                {typedProject.workspaces?.map((workspace) => {
-                                  const isActive = activeWorkspace?.id === workspace.id;
+                                {typedProject.workspaces?.map((task) => {
+                                  const isActive = activeTask?.id === task.id;
                                   return (
                                     <div
-                                      key={workspace.id}
+                                      key={task.id}
                                       onClick={(e) => {
                                         e.stopPropagation();
                                         if (
@@ -290,19 +290,19 @@ const LeftSidebar: React.FC<LeftSidebarProps> = ({
                                         ) {
                                           onSelectProject(typedProject);
                                         }
-                                        onSelectWorkspace && onSelectWorkspace(workspace);
+                                        onSelectTask && onSelectTask(task);
                                       }}
                                       className={`group/workspace min-w-0 rounded-md px-2 py-1.5 hover:bg-black/5 dark:hover:bg-white/5 ${
                                         isActive ? 'bg-black/5 dark:bg-white/5' : ''
                                       }`}
-                                      title={workspace.name}
+                                      title={task.name}
                                     >
-                                      <WorkspaceItem
-                                        workspace={workspace}
+                                      <TaskItem
+                                        task={task}
                                         showDelete
                                         onDelete={
-                                          onDeleteWorkspace
-                                            ? () => onDeleteWorkspace(typedProject, workspace)
+                                          onDeleteTask
+                                            ? () => onDeleteTask(typedProject, task)
                                             : undefined
                                         }
                                       />
diff --git a/src/renderer/components/MultiAgentWorkspace.tsx b/src/renderer/components/MultiAgentTask.tsx
similarity index 94%
rename from src/renderer/components/MultiAgentWorkspace.tsx
rename to src/renderer/components/MultiAgentTask.tsx
index c00ce506..bb000240 100644
--- a/src/renderer/components/MultiAgentWorkspace.tsx
+++ b/src/renderer/components/MultiAgentTask.tsx
@@ -1,5 +1,5 @@
 import React, { useEffect, useMemo, useRef, useState } from 'react';
-import { type Workspace } from '../types/chat';
+import { type Task } from '../types/chat';
 import { type Provider } from '../types';
 import { Button } from './ui/button';
 import { Input } from './ui/input';
@@ -14,10 +14,10 @@ import { Spinner } from './ui/spinner';
 import { BUSY_HOLD_MS, CLEAR_BUSY_MS } from '@/lib/activityConstants';
 import { CornerDownLeft } from 'lucide-react';
 import { TooltipProvider, Tooltip, TooltipTrigger, TooltipContent } from './ui/tooltip';
-import { useAutoScrollOnWorkspaceSwitch } from '@/hooks/useAutoScrollOnWorkspaceSwitch';
+import { useAutoScrollOnTaskSwitch } from '@/hooks/useAutoScrollOnTaskSwitch';
 
 interface Props {
-  workspace: Workspace;
+  task: Task;
   projectName: string;
   projectId: string;
 }
@@ -31,16 +31,16 @@ type Variant = {
   worktreeId: string;
 };
 
-const MultiAgentWorkspace: React.FC<Props> = ({ workspace }) => {
+const MultiAgentTask: React.FC<Props> = ({ task }) => {
   const { effectiveTheme } = useTheme();
   const [prompt, setPrompt] = useState('');
   const [activeTabIndex, setActiveTabIndex] = useState(0);
   const [variantBusy, setVariantBusy] = useState<Record<string, boolean>>({});
-  const multi = workspace.metadata?.multiAgent;
+  const multi = task.metadata?.multiAgent;
   const variants = (multi?.variants || []) as Variant[];
 
-  // Auto-scroll to bottom when this workspace becomes active
-  const { scrollToBottom } = useAutoScrollOnWorkspaceSwitch(true, workspace.id);
+  // Auto-scroll to bottom when this task becomes active
+  const { scrollToBottom } = useAutoScrollOnTaskSwitch(true, task.id);
 
   // Helper to generate display label with instance number if needed
   const getVariantDisplayLabel = (variant: Variant): string => {
@@ -65,7 +65,7 @@ const MultiAgentWorkspace: React.FC<Props> = ({ workspace }) => {
 
   // Build initial issue context (feature parity with single-agent ChatInterface)
   const initialInjection: string | null = useMemo(() => {
-    const md: any = workspace.metadata || null;
+    const md: any = task.metadata || null;
     if (!md) return null;
     const p = (md.initialPrompt || '').trim();
     if (p) return p;
@@ -154,7 +154,7 @@ const MultiAgentWorkspace: React.FC<Props> = ({ workspace }) => {
       return lines.join('\n');
     }
     return null;
-  }, [workspace.metadata]);
+  }, [task.metadata]);
 
   // Robust prompt injection modeled after useInitialPromptInjection, without one-shot gating
   const injectPrompt = async (ptyId: string, provider: Provider, text: string) => {
@@ -345,8 +345,8 @@ const MultiAgentWorkspace: React.FC<Props> = ({ workspace }) => {
   // Sync variant busy state to activityStore for sidebar indicator
   useEffect(() => {
     const anyBusy = Object.values(variantBusy).some(Boolean);
-    activityStore.setWorkspaceBusy(workspace.id, anyBusy);
-  }, [variantBusy, workspace.id]);
+    activityStore.setWorkspaceBusy(task.id, anyBusy);
+  }, [variantBusy, task.id]);
 
   // Scroll to bottom when active tab changes
   useEffect(() => {
@@ -362,7 +362,7 @@ const MultiAgentWorkspace: React.FC<Props> = ({ workspace }) => {
   if (!multi?.enabled || variants.length === 0) {
     return (
       <div className="flex h-full items-center justify-center text-sm text-muted-foreground">
-        Multi-agent config missing for this workspace.
+        Multi-agent config missing for this task.
       </div>
     );
   }
@@ -443,10 +443,10 @@ const MultiAgentWorkspace: React.FC<Props> = ({ workspace }) => {
                     id={`${v.worktreeId}-main`}
                     cwd={v.path}
                     shell={providerMeta[v.provider].cli}
-                    autoApprove={workspace.metadata?.autoApprove ?? false}
+                    autoApprove={task.metadata?.autoApprove ?? false}
                     initialPrompt={
                       providerMeta[v.provider]?.initialPromptFlag !== undefined &&
-                      !workspace.metadata?.initialInjectionSent
+                      !task.metadata?.initialInjectionSent
                         ? (initialInjection ?? undefined)
                         : undefined
                     }
@@ -462,17 +462,17 @@ const MultiAgentWorkspace: React.FC<Props> = ({ workspace }) => {
                       // For providers WITHOUT CLI flag support, use keystroke injection
                       if (
                         initialInjection &&
-                        !workspace.metadata?.initialInjectionSent &&
+                        !task.metadata?.initialInjectionSent &&
                         providerMeta[v.provider]?.initialPromptFlag === undefined
                       ) {
                         void injectPrompt(`${v.worktreeId}-main`, v.provider, initialInjection);
                       }
                       // Mark initial injection as sent so it won't re-run on restart
-                      if (initialInjection && !workspace.metadata?.initialInjectionSent) {
+                      if (initialInjection && !task.metadata?.initialInjectionSent) {
                         void window.electronAPI.saveWorkspace({
-                          ...workspace,
+                          ...task,
                           metadata: {
-                            ...workspace.metadata,
+                            ...task.metadata,
                             initialInjectionSent: true,
                           },
                         });
@@ -523,4 +523,4 @@ const MultiAgentWorkspace: React.FC<Props> = ({ workspace }) => {
   );
 };
 
-export default MultiAgentWorkspace;
+export default MultiAgentTask;
diff --git a/src/renderer/components/ProjectMainView.tsx b/src/renderer/components/ProjectMainView.tsx
index b1be1f5a..0125103d 100644
--- a/src/renderer/components/ProjectMainView.tsx
+++ b/src/renderer/components/ProjectMainView.tsx
@@ -5,10 +5,10 @@ import { AnimatePresence, motion } from 'motion/react';
 import { Separator } from './ui/separator';
 import { Alert, AlertDescription, AlertTitle } from './ui/alert';
 import { usePrStatus } from '../hooks/usePrStatus';
-import { useWorkspaceChanges } from '../hooks/useWorkspaceChanges';
-import { ChangesBadge } from './WorkspaceChanges';
+import { useTaskChanges } from '../hooks/useTaskChanges';
+import { ChangesBadge } from './TaskChanges';
 import { Spinner } from './ui/spinner';
-import WorkspaceDeleteButton from './WorkspaceDeleteButton';
+import WorkspaceDeleteButton from './TaskDeleteButton';
 import ProjectDeleteButton from './ProjectDeleteButton';
 import {
   AlertDialog,
@@ -24,7 +24,7 @@ import { Checkbox } from './ui/checkbox';
 import BaseBranchControls, { RemoteBranchOption } from './BaseBranchControls';
 import { useToast } from '../hooks/use-toast';
 import ContainerStatusBadge from './ContainerStatusBadge';
-import WorkspacePorts from './WorkspacePorts';
+import WorkspacePorts from './TaskPorts';
 import { TooltipProvider, Tooltip, TooltipTrigger, TooltipContent } from './ui/tooltip';
 import dockerLogo from '../../assets/images/docker.png';
 import DeletePrNotice from './DeletePrNotice';
@@ -36,7 +36,7 @@ import {
 } from '@/lib/containerRuns';
 import { activityStore } from '../lib/activityStore';
 import PrPreviewTooltip from './PrPreviewTooltip';
-import type { Project, Workspace } from '../types/app';
+import type { Project, Task } from '../types/app';
 
 const normalizeBaseRef = (ref?: string | null): string | undefined => {
   if (!ref) return undefined;
@@ -53,7 +53,7 @@ function WorkspaceRow({
   isSelected,
   onToggleSelect,
 }: {
-  ws: Workspace;
+  ws: Task;
   active: boolean;
   onClick: () => void;
   onDelete: () => void | Promise<void | boolean>;
@@ -65,7 +65,7 @@ function WorkspaceRow({
   const [isRunning, setIsRunning] = useState(false);
   const [isDeleting, setIsDeleting] = useState(false);
   const { pr } = usePrStatus(ws.path);
-  const { totalAdditions, totalDeletions, isLoading } = useWorkspaceChanges(ws.path, ws.id);
+  const { totalAdditions, totalDeletions, isLoading } = useTaskChanges(ws.path, ws.id);
   const [containerState, setContainerState] = useState<ContainerRunState | undefined>(() =>
     getContainerRunState(ws.id)
   );
@@ -387,25 +387,25 @@ function WorkspaceRow({
 
 interface ProjectMainViewProps {
   project: Project;
-  onCreateWorkspace: () => void;
-  activeWorkspace: Workspace | null;
-  onSelectWorkspace: (workspace: Workspace) => void;
-  onDeleteWorkspace: (
+  onCreateTask: () => void;
+  activeTask: Task | null;
+  onSelectTask: (task: Task) => void;
+  onDeleteTask: (
     project: Project,
-    workspace: Workspace,
+    task: Task,
     options?: { silent?: boolean }
   ) => void | Promise<void | boolean>;
-  isCreatingWorkspace?: boolean;
+  isCreatingTask?: boolean;
   onDeleteProject?: (project: Project) => void | Promise<void>;
 }
 
 const ProjectMainView: React.FC<ProjectMainViewProps> = ({
   project,
-  onCreateWorkspace,
-  activeWorkspace,
-  onSelectWorkspace,
-  onDeleteWorkspace,
-  isCreatingWorkspace = false,
+  onCreateTask,
+  activeTask,
+  onSelectTask,
+  onDeleteTask,
+  isCreatingTask = false,
   onDeleteProject,
 }) => {
   const { toast } = useToast();
@@ -516,7 +516,7 @@ const ProjectMainView: React.FC<ProjectMainViewProps> = ({
     const deletedNames: string[] = [];
     for (const ws of toDelete) {
       try {
-        const result = await onDeleteWorkspace(project, ws, { silent: true });
+        const result = await onDeleteTask(project, ws, { silent: true });
         if (result !== false) {
           deletedNames.push(ws.name);
         }
@@ -795,11 +795,11 @@ const ProjectMainView: React.FC<ProjectMainViewProps> = ({
                       variant="default"
                       size="sm"
                       className="h-9 px-4 text-sm font-semibold shadow-sm"
-                      onClick={onCreateWorkspace}
-                      disabled={isCreatingWorkspace}
-                      aria-busy={isCreatingWorkspace}
+                      onClick={onCreateTask}
+                      disabled={isCreatingTask}
+                      aria-busy={isCreatingTask}
                     >
-                      {isCreatingWorkspace ? (
+                      {isCreatingTask ? (
                         <>
                           <Loader2 className="mr-2 size-4 animate-spin" />
                           Starting…
@@ -851,9 +851,9 @@ const ProjectMainView: React.FC<ProjectMainViewProps> = ({
                       isSelectMode={isSelectMode}
                       isSelected={selectedIds.has(ws.id)}
                       onToggleSelect={() => toggleSelect(ws.id)}
-                      active={activeWorkspace?.id === ws.id}
-                      onClick={() => onSelectWorkspace(ws)}
-                      onDelete={() => onDeleteWorkspace(project, ws)}
+                      active={activeTask?.id === ws.id}
+                      onClick={() => onSelectTask(ws)}
+                      onDelete={() => onDeleteTask(project, ws)}
                     />
                   ))}
                 </div>
diff --git a/src/renderer/components/RightSidebar.tsx b/src/renderer/components/RightSidebar.tsx
index a472eead..e2f4e5f3 100644
--- a/src/renderer/components/RightSidebar.tsx
+++ b/src/renderer/components/RightSidebar.tsx
@@ -2,13 +2,13 @@ import React from 'react';
 import { cn } from '@/lib/utils';
 import FileChangesPanel from './FileChangesPanel';
 import { useFileChanges } from '@/hooks/useFileChanges';
-import WorkspaceTerminalPanel from './WorkspaceTerminalPanel';
+import TaskTerminalPanel from './TaskTerminalPanel';
 import { useRightSidebar } from './ui/right-sidebar';
 import { providerAssets } from '@/providers/assets';
 import { providerMeta } from '@/providers/meta';
 import type { Provider } from '../types';
 
-export interface RightSidebarWorkspace {
+export interface RightSidebarTask {
   id: string;
   name: string;
   branch: string;
@@ -19,16 +19,16 @@ export interface RightSidebarWorkspace {
 }
 
 interface RightSidebarProps extends React.HTMLAttributes<HTMLElement> {
-  workspace: RightSidebarWorkspace | null;
+  task: RightSidebarTask | null;
 }
 
-const RightSidebar: React.FC<RightSidebarProps> = ({ workspace, className, ...rest }) => {
+const RightSidebar: React.FC<RightSidebarProps> = ({ task, className, ...rest }) => {
   const { collapsed } = useRightSidebar();
 
   // Detect multi-agent variants in workspace metadata
   const variants: Array<{ provider: Provider; name: string; path: string }> = (() => {
     try {
-      const v = workspace?.metadata?.multiAgent?.variants || [];
+      const v = task?.metadata?.multiAgent?.variants || [];
       if (Array.isArray(v))
         return v
           .map((x: any) => ({ provider: x?.provider as Provider, name: x?.name, path: x?.path }))
@@ -73,7 +73,7 @@ const RightSidebar: React.FC<RightSidebarProps> = ({ workspace, className, ...re
       {...rest}
     >
       <div className="flex h-full w-full min-w-0 flex-col">
-        {workspace ? (
+        {task ? (
           <div className="flex h-full flex-col">
             {variants.length > 1 ? (
               <div className="min-h-0 flex-1 overflow-y-auto">
@@ -117,9 +117,9 @@ const RightSidebar: React.FC<RightSidebarProps> = ({ workspace, className, ...re
               (() => {
                 const v = variants[0];
                 const derived = {
-                  ...workspace,
+                  ...task,
                   path: v.path,
-                  name: v.name || workspace.name,
+                  name: v.name || task.name,
                 } as any;
                 return (
                   <>
@@ -127,8 +127,8 @@ const RightSidebar: React.FC<RightSidebarProps> = ({ workspace, className, ...re
                       path={v.path}
                       className="min-h-0 flex-1 border-b border-border"
                     />
-                    <WorkspaceTerminalPanel
-                      workspace={derived}
+                    <TaskTerminalPanel
+                      task={derived}
                       provider={v.provider}
                       className="min-h-0 flex-1"
                     />
@@ -138,12 +138,12 @@ const RightSidebar: React.FC<RightSidebarProps> = ({ workspace, className, ...re
             ) : (
               <>
                 <FileChangesPanel
-                  workspaceId={workspace.path}
+                  workspaceId={task.path}
                   className="min-h-0 flex-1 border-b border-border"
                 />
-                <WorkspaceTerminalPanel
-                  workspace={workspace}
-                  provider={workspace.agentId as Provider}
+                <TaskTerminalPanel
+                  task={task}
+                  provider={task.agentId as Provider}
                   className="min-h-0 flex-1"
                 />
               </>
diff --git a/src/renderer/components/WorkspaceChanges.tsx b/src/renderer/components/TaskChanges.tsx
similarity index 100%
rename from src/renderer/components/WorkspaceChanges.tsx
rename to src/renderer/components/TaskChanges.tsx
diff --git a/src/renderer/components/WorkspaceDeleteButton.tsx b/src/renderer/components/TaskDeleteButton.tsx
similarity index 100%
rename from src/renderer/components/WorkspaceDeleteButton.tsx
rename to src/renderer/components/TaskDeleteButton.tsx
diff --git a/src/renderer/components/WorkspaceItem.tsx b/src/renderer/components/TaskItem.tsx
similarity index 76%
rename from src/renderer/components/WorkspaceItem.tsx
rename to src/renderer/components/TaskItem.tsx
index 92eed736..eeeb65cd 100644
--- a/src/renderer/components/WorkspaceItem.tsx
+++ b/src/renderer/components/TaskItem.tsx
@@ -1,14 +1,14 @@
 import React from 'react';
 import { GitBranch, ArrowUpRight } from 'lucide-react';
-import WorkspaceDeleteButton from './WorkspaceDeleteButton';
-import { useWorkspaceChanges } from '../hooks/useWorkspaceChanges';
-import { ChangesBadge } from './WorkspaceChanges';
+import TaskDeleteButton from './TaskDeleteButton';
+import { useTaskChanges } from '../hooks/useTaskChanges';
+import { ChangesBadge } from './TaskChanges';
 import { Spinner } from './ui/spinner';
 import { usePrStatus } from '../hooks/usePrStatus';
-import { useWorkspaceBusy } from '../hooks/useWorkspaceBusy';
+import { useTaskBusy } from '../hooks/useTaskBusy';
 import PrPreviewTooltip from './PrPreviewTooltip';
 
-interface Workspace {
+interface Task {
   id: string;
   name: string;
   branch: string;
@@ -17,42 +17,42 @@ interface Workspace {
   agentId?: string;
 }
 
-interface WorkspaceItemProps {
-  workspace: Workspace;
+interface TaskItemProps {
+  task: Task;
   onDelete?: () => void | Promise<void | boolean>;
   showDelete?: boolean;
 }
 
-export const WorkspaceItem: React.FC<WorkspaceItemProps> = ({
-  workspace,
+export const TaskItem: React.FC<TaskItemProps> = ({
+  task,
   onDelete,
   showDelete,
 }) => {
-  const { totalAdditions, totalDeletions, isLoading } = useWorkspaceChanges(
-    workspace.path,
-    workspace.id
+  const { totalAdditions, totalDeletions, isLoading } = useTaskChanges(
+    task.path,
+    task.id
   );
-  const { pr } = usePrStatus(workspace.path);
-  const isRunning = useWorkspaceBusy(workspace.id);
+  const { pr } = usePrStatus(task.path);
+  const isRunning = useTaskBusy(task.id);
 
   const [isDeleting, setIsDeleting] = React.useState(false);
 
   return (
     <div className="flex min-w-0 items-center justify-between">
       <div className="flex min-w-0 flex-1 items-center gap-2 py-1">
-        {isRunning || workspace.status === 'running' ? (
+        {isRunning || task.status === 'running' ? (
           <Spinner size="sm" className="h-3 w-3 flex-shrink-0 text-muted-foreground" />
         ) : (
           <GitBranch className="h-3 w-3 flex-shrink-0 text-muted-foreground" />
         )}
-        <span className="block truncate text-xs font-medium text-foreground">{workspace.name}</span>
+        <span className="block truncate text-xs font-medium text-foreground">{task.name}</span>
       </div>
       <div className="relative flex flex-shrink-0 items-center pl-6">
         {showDelete && onDelete ? (
-          <WorkspaceDeleteButton
-            workspaceName={workspace.name}
-            workspaceId={workspace.id}
-            workspacePath={workspace.path}
+          <TaskDeleteButton
+            workspaceName={task.name}
+            workspaceId={task.id}
+            workspacePath={task.path}
             onConfirm={async () => {
               try {
                 setIsDeleting(true);
@@ -62,7 +62,7 @@ export const WorkspaceItem: React.FC<WorkspaceItemProps> = ({
               }
             }}
             isDeleting={isDeleting}
-            aria-label={`Delete Task ${workspace.name}`}
+            aria-label={`Delete Task ${task.name}`}
             className={`absolute left-0 inline-flex h-5 w-5 items-center justify-center rounded p-0.5 text-muted-foreground transition-opacity duration-150 hover:bg-muted focus:opacity-100 focus-visible:opacity-100 ${
               isDeleting ? 'opacity-100' : 'opacity-0 group-hover/workspace:opacity-100'
             }`}
diff --git a/src/renderer/components/WorkspaceList.tsx b/src/renderer/components/TaskList.tsx
similarity index 70%
rename from src/renderer/components/WorkspaceList.tsx
rename to src/renderer/components/TaskList.tsx
index d7e39cc4..86f376c2 100644
--- a/src/renderer/components/WorkspaceList.tsx
+++ b/src/renderer/components/TaskList.tsx
@@ -4,7 +4,7 @@ import { Card, CardContent, CardDescription, CardHeader, CardTitle } from './ui/
 import { Spinner } from './ui/spinner';
 import { GitBranch, Bot, Play, Pause, Plus } from 'lucide-react';
 
-interface Workspace {
+interface Task {
   id: string;
   name: string;
   branch: string;
@@ -13,19 +13,19 @@ interface Workspace {
 }
 
 interface Props {
-  workspaces: Workspace[];
-  activeWorkspace: Workspace | null;
-  onSelectWorkspace: (workspace: Workspace) => void;
-  onCreateWorkspace: () => void;
-  isCreatingWorkspace?: boolean;
+  tasks: Task[];
+  activeTask: Task | null;
+  onSelectTask: (task: Task) => void;
+  onCreateTask: () => void;
+  isCreatingTask?: boolean;
 }
 
-export const WorkspaceList: React.FC<Props> = ({
-  workspaces,
-  activeWorkspace,
-  onSelectWorkspace,
-  onCreateWorkspace,
-  isCreatingWorkspace = false,
+export const TaskList: React.FC<Props> = ({
+  tasks,
+  activeTask,
+  onSelectTask,
+  onCreateTask,
+  isCreatingTask = false,
 }) => {
   const getStatusIcon = (status: string) => {
     switch (status) {
@@ -45,10 +45,10 @@ export const WorkspaceList: React.FC<Props> = ({
         <Button
           variant="default"
           size="sm"
-          onClick={onCreateWorkspace}
-          disabled={isCreatingWorkspace}
+          onClick={onCreateTask}
+          disabled={isCreatingTask}
         >
-          {isCreatingWorkspace ? (
+          {isCreatingTask ? (
             <>
               <Spinner size="sm" className="mr-2" />
               Creating...
@@ -61,35 +61,35 @@ export const WorkspaceList: React.FC<Props> = ({
         </Button>
       </div>
 
-      {workspaces.length === 0 ? (
+      {tasks.length === 0 ? (
         <div className="flex h-full flex-col items-center justify-center text-gray-500">
           <Bot className="mb-4 h-12 w-12" />
           <p className="text-center">No workspaces yet. Create one to get started!</p>
         </div>
       ) : (
         <div className="flex-1 space-y-3 overflow-y-auto">
-          {workspaces.map((workspace) => (
+          {tasks.map((task) => (
             <Card
-              key={workspace.id}
+              key={task.id}
               className={`cursor-pointer transition-all duration-200 ${
-                activeWorkspace?.id === workspace.id
+                activeTask?.id === task.id
                   ? 'border-blue-500 ring-2 ring-blue-500'
                   : 'border-gray-200 hover:border-gray-400 dark:border-gray-700 dark:hover:border-gray-500'
               }`}
-              onClick={() => onSelectWorkspace(workspace)}
+              onClick={() => onSelectTask(task)}
             >
               <CardHeader className="p-4">
                 <CardTitle className="flex items-center text-lg">
-                  {getStatusIcon(workspace.status)}
-                  <span className="ml-2">{workspace.name}</span>
+                  {getStatusIcon(task.status)}
+                  <span className="ml-2">{task.name}</span>
                 </CardTitle>
                 <CardDescription className="mt-1 flex items-center text-sm text-gray-500 dark:text-gray-400">
                   <GitBranch className="mr-1 h-3 w-3" />
-                  <code className="font-mono text-xs">{workspace.branch}</code>
+                  <code className="font-mono text-xs">{task.branch}</code>
                 </CardDescription>
               </CardHeader>
               <CardContent className="p-4 pt-0 text-xs text-gray-600 dark:text-gray-300">
-                <p className="capitalize">Status: {workspace.status}</p>
+                <p className="capitalize">Status: {task.status}</p>
               </CardContent>
             </Card>
           ))}
@@ -99,4 +99,4 @@ export const WorkspaceList: React.FC<Props> = ({
   );
 };
 
-export default WorkspaceList;
+export default TaskList;
diff --git a/src/renderer/components/WorkspaceModal.tsx b/src/renderer/components/TaskModal.tsx
similarity index 96%
rename from src/renderer/components/WorkspaceModal.tsx
rename to src/renderer/components/TaskModal.tsx
index 50b47b83..29e921eb 100644
--- a/src/renderer/components/WorkspaceModal.tsx
+++ b/src/renderer/components/TaskModal.tsx
@@ -18,10 +18,10 @@ import { isValidProviderId } from '@shared/providers/registry';
 import { type LinearIssueSummary } from '../types/linear';
 import { type GitHubIssueSummary } from '../types/github';
 import {
-  generateFriendlyWorkspaceName,
-  normalizeWorkspaceName,
-  MAX_WORKSPACE_NAME_LENGTH,
-} from '../lib/workspaceNames';
+  generateFriendlyTaskName,
+  normalizeTaskName,
+  MAX_TASK_NAME_LENGTH,
+} from '../lib/taskNames';
 
 const DEFAULT_PROVIDER: Provider = 'claude';
 
@@ -33,7 +33,7 @@ import JiraIssueSelector from './JiraIssueSelector';
 import { type JiraIssueSummary } from '../types/jira';
 import { useGithubAuth } from '../hooks/useGithubAuth';
 
-interface WorkspaceModalProps {
+interface TaskModalProps {
   isOpen: boolean;
   onClose: () => void;
   onCreateWorkspace: (
@@ -51,7 +51,7 @@ interface WorkspaceModalProps {
   projectPath?: string;
 }
 
-const WorkspaceModal: React.FC<WorkspaceModalProps> = ({
+const TaskModal: React.FC<TaskModalProps> = ({
   isOpen,
   onClose,
   onCreateWorkspace,
@@ -60,7 +60,7 @@ const WorkspaceModal: React.FC<WorkspaceModalProps> = ({
   existingNames = [],
   projectPath,
 }) => {
-  const [workspaceName, setWorkspaceName] = useState('');
+  const [taskName, setWorkspaceName] = useState('');
   const [defaultProviderFromSettings, setDefaultProviderFromSettings] =
     useState<Provider>(DEFAULT_PROVIDER);
   const [providerRuns, setProviderRuns] = useState<ProviderRun[]>([
@@ -124,19 +124,19 @@ const WorkspaceModal: React.FC<WorkspaceModalProps> = ({
   }, [hasInitialPromptSupport]);
 
   const normalizedExisting = useMemo(
-    () => existingNames.map((n) => normalizeWorkspaceName(n)).filter(Boolean),
+    () => existingNames.map((n) => normalizeTaskName(n)).filter(Boolean),
     [existingNames]
   );
 
   const validate = useCallback(
     (value: string): string | null => {
-      const normalized = normalizeWorkspaceName(value);
+      const normalized = normalizeTaskName(value);
       if (!normalized) return 'Please enter a Task name.';
       if (normalizedExisting.includes(normalized)) {
         return 'A Task with this name already exists.';
       }
-      if (normalized.length > MAX_WORKSPACE_NAME_LENGTH) {
-        return `Task name is too long (max ${MAX_WORKSPACE_NAME_LENGTH} characters).`;
+      if (normalized.length > MAX_TASK_NAME_LENGTH) {
+        return `Task name is too long (max ${MAX_TASK_NAME_LENGTH} characters).`;
       }
       return null;
     },
@@ -156,7 +156,7 @@ const WorkspaceModal: React.FC<WorkspaceModalProps> = ({
       autoGeneratedName &&
       val !== autoGeneratedName &&
       val.trim() &&
-      normalizeWorkspaceName(val) !== normalizeWorkspaceName(autoGeneratedName)
+      normalizeTaskName(val) !== normalizeTaskName(autoGeneratedName)
     ) {
       setCustomNameTracked(true);
       void (async () => {
@@ -195,7 +195,7 @@ const WorkspaceModal: React.FC<WorkspaceModalProps> = ({
 
     // Generate auto-generated name synchronously to avoid race condition
     // Default assumption: autoGenerateName is true (matches DEFAULT_SETTINGS)
-    const suggested = generateFriendlyWorkspaceName(normalizedExisting);
+    const suggested = generateFriendlyTaskName(normalizedExisting);
     setAutoGeneratedName(suggested);
     setWorkspaceName(suggested);
     setError(validate(suggested));
@@ -402,7 +402,7 @@ const WorkspaceModal: React.FC<WorkspaceModalProps> = ({
                   onSubmit={(e) => {
                     e.preventDefault();
                     setTouched(true);
-                    const err = validate(workspaceName);
+                    const err = validate(taskName);
                     if (err) {
                       setError(err);
                       return;
@@ -411,7 +411,7 @@ const WorkspaceModal: React.FC<WorkspaceModalProps> = ({
                     (async () => {
                       try {
                         await onCreateWorkspace(
-                          normalizeWorkspaceName(workspaceName),
+                          normalizeTaskName(taskName),
                           showAdvanced ? initialPrompt.trim() || undefined : undefined,
                           providerRuns,
                           selectedLinearIssue,
@@ -435,7 +435,7 @@ const WorkspaceModal: React.FC<WorkspaceModalProps> = ({
                     </Label>
                     <Input
                       id="workspace-name"
-                      value={workspaceName}
+                      value={taskName}
                       onChange={(e) => onChange(e.target.value)}
                       onBlur={() => setTouched(true)}
                       placeholder="refactor-api-routes"
@@ -446,11 +446,11 @@ const WorkspaceModal: React.FC<WorkspaceModalProps> = ({
                     />
                   </div>
 
-                  {workspaceName && (
+                  {taskName && (
                     <div className="flex items-center space-x-2 rounded-lg bg-gray-100 p-3 dark:bg-gray-700">
                       <GitBranch className="h-4 w-4 flex-shrink-0 text-gray-500" />
                       <span className="overflow-hidden break-all text-sm text-gray-600 dark:text-gray-400">
-                        {normalizeWorkspaceName(workspaceName)}
+                        {normalizeTaskName(taskName)}
                       </span>
                     </div>
                   )}
@@ -767,7 +767,7 @@ const WorkspaceModal: React.FC<WorkspaceModalProps> = ({
                   </Accordion>
 
                   <div className="flex justify-end">
-                    <Button type="submit" disabled={!!validate(workspaceName) || isCreating}>
+                    <Button type="submit" disabled={!!validate(taskName) || isCreating}>
                       {isCreating ? (
                         <>
                           <Spinner size="sm" className="mr-2" />
@@ -789,4 +789,4 @@ const WorkspaceModal: React.FC<WorkspaceModalProps> = ({
   );
 };
 
-export default WorkspaceModal;
+export default TaskModal;
diff --git a/src/renderer/components/WorkspacePorts.tsx b/src/renderer/components/TaskPorts.tsx
similarity index 100%
rename from src/renderer/components/WorkspacePorts.tsx
rename to src/renderer/components/TaskPorts.tsx
diff --git a/src/renderer/components/WorkspaceTerminalPanel.tsx b/src/renderer/components/TaskTerminalPanel.tsx
similarity index 94%
rename from src/renderer/components/WorkspaceTerminalPanel.tsx
rename to src/renderer/components/TaskTerminalPanel.tsx
index 81ddab07..1064b07b 100644
--- a/src/renderer/components/WorkspaceTerminalPanel.tsx
+++ b/src/renderer/components/TaskTerminalPanel.tsx
@@ -2,11 +2,11 @@ import React, { useMemo, useState, useEffect } from 'react';
 import { TerminalPane } from './TerminalPane';
 import { Bot, Terminal, Plus, X } from 'lucide-react';
 import { useTheme } from '../hooks/useTheme';
-import { useWorkspaceTerminals } from '@/lib/workspaceTerminalsStore';
+import { useTaskTerminals } from '@/lib/taskTerminalsStore';
 import { cn } from '@/lib/utils';
 import type { Provider } from '../types';
 
-interface Workspace {
+interface Task {
   id: string;
   name: string;
   branch: string;
@@ -15,12 +15,12 @@ interface Workspace {
 }
 
 interface Props {
-  workspace: Workspace | null;
+  task: Task | null;
   provider?: Provider;
   className?: string;
 }
 
-const WorkspaceTerminalPanelComponent: React.FC<Props> = ({ workspace, provider, className }) => {
+const TaskTerminalPanelComponent: React.FC<Props> = ({ task, provider, className }) => {
   const { effectiveTheme } = useTheme();
   const {
     terminals,
@@ -29,7 +29,7 @@ const WorkspaceTerminalPanelComponent: React.FC<Props> = ({ workspace, provider,
     createTerminal,
     setActiveTerminal,
     closeTerminal,
-  } = useWorkspaceTerminals(workspace?.id ?? null, workspace?.path);
+  } = useTaskTerminals(task?.id ?? null, task?.path);
 
   const [nativeTheme, setNativeTheme] = useState<{
     background?: string;
@@ -137,7 +137,7 @@ const WorkspaceTerminalPanelComponent: React.FC<Props> = ({ workspace, provider,
     };
   }, [nativeTheme, defaultTheme]);
 
-  if (!workspace) {
+  if (!task) {
     return (
       <div
         className={`flex h-full flex-col items-center justify-center bg-gray-50 dark:bg-gray-900 ${className}`}
@@ -229,7 +229,7 @@ const WorkspaceTerminalPanelComponent: React.FC<Props> = ({ workspace, provider,
           >
             <TerminalPane
               id={terminal.id}
-              cwd={terminal.cwd || workspace.path}
+              cwd={terminal.cwd || task.path}
               variant={effectiveTheme === 'dark' ? 'dark' : 'light'}
               themeOverride={themeOverride}
               className="h-full w-full"
@@ -246,6 +246,6 @@ const WorkspaceTerminalPanelComponent: React.FC<Props> = ({ workspace, provider,
     </div>
   );
 };
-export const WorkspaceTerminalPanel = React.memo(WorkspaceTerminalPanelComponent);
+export const TaskTerminalPanel = React.memo(TaskTerminalPanelComponent);
 
-export default WorkspaceTerminalPanel;
+export default TaskTerminalPanel;
diff --git a/src/renderer/components/kanban/KanbanBoard.tsx b/src/renderer/components/kanban/KanbanBoard.tsx
index e0498ac6..38dfb8fd 100644
--- a/src/renderer/components/kanban/KanbanBoard.tsx
+++ b/src/renderer/components/kanban/KanbanBoard.tsx
@@ -1,5 +1,5 @@
 import React from 'react';
-import type { Project, Workspace } from '../../types/app';
+import type { Project, Task } from '../../types/app';
 import KanbanColumn from './KanbanColumn';
 import KanbanCard from './KanbanCard';
 import { Button } from '../ui/button';
@@ -10,7 +10,7 @@ import {
   watchWorkspacePty,
   watchWorkspaceContainers,
   watchWorkspaceActivity,
-} from '../../lib/workspaceStatus';
+} from '../../lib/taskStatus';
 import { activityStore } from '../../lib/activityStore';
 
 const order: KanbanStatus[] = ['todo', 'in-progress', 'done'];
@@ -22,7 +22,7 @@ const titles: Record<KanbanStatus, string> = {
 
 const KanbanBoard: React.FC<{
   project: Project;
-  onOpenWorkspace?: (ws: Workspace) => void;
+  onOpenWorkspace?: (ws: Task) => void;
   onCreateWorkspace?: () => void;
 }> = ({ project, onOpenWorkspace, onCreateWorkspace }) => {
   const [statusMap, setStatusMap] = React.useState<Record<string, KanbanStatus>>({});
@@ -260,7 +260,7 @@ const KanbanBoard: React.FC<{
     };
   }, [project.id, project.workspaces?.length]);
 
-  const byStatus: Record<KanbanStatus, Workspace[]> = { todo: [], 'in-progress': [], done: [] };
+  const byStatus: Record<KanbanStatus, Task[]> = { todo: [], 'in-progress': [], done: [] };
   for (const ws of project.workspaces || []) {
     const s = statusMap[ws.id] || 'todo';
     byStatus[s].push(ws);
diff --git a/src/renderer/components/kanban/KanbanCard.tsx b/src/renderer/components/kanban/KanbanCard.tsx
index 9c181af8..758e782d 100644
--- a/src/renderer/components/kanban/KanbanCard.tsx
+++ b/src/renderer/components/kanban/KanbanCard.tsx
@@ -1,5 +1,5 @@
 import React from 'react';
-import type { Workspace } from '../../types/app';
+import type { Task } from '../../types/app';
 import { providerAssets } from '../../providers/assets';
 import { providerMeta, type UiProvider } from '../../providers/meta';
 import { activityStore } from '../../lib/activityStore';
@@ -18,8 +18,8 @@ function resolveProvider(workspaceId: string): UiProvider | null {
 }
 
 const KanbanCard: React.FC<{
-  ws: Workspace;
-  onOpen?: (ws: Workspace) => void;
+  ws: Task;
+  onOpen?: (ws: Task) => void;
   draggable?: boolean;
 }> = ({ ws, onOpen, draggable = true }) => {
   const SHOW_PROVIDER_LOGOS = false;
diff --git a/src/renderer/hooks/useAutoScrollOnWorkspaceSwitch.ts b/src/renderer/hooks/useAutoScrollOnTaskSwitch.ts
similarity index 78%
rename from src/renderer/hooks/useAutoScrollOnWorkspaceSwitch.ts
rename to src/renderer/hooks/useAutoScrollOnTaskSwitch.ts
index 07bc8775..962c027e 100644
--- a/src/renderer/hooks/useAutoScrollOnWorkspaceSwitch.ts
+++ b/src/renderer/hooks/useAutoScrollOnTaskSwitch.ts
@@ -1,7 +1,7 @@
 import { useEffect, useRef, useCallback } from 'react';
 
 /**
- * Hook to auto-scroll terminal containers to bottom when workspace switches
+ * Hook to auto-scroll terminal containers to bottom when task switches
  */
 type ScrollOptions = {
   /**
@@ -11,8 +11,8 @@ type ScrollOptions = {
   onlyIfNearTop?: boolean;
 };
 
-export function useAutoScrollOnWorkspaceSwitch(isActive: boolean, workspaceId: string | null) {
-  const previousWorkspaceIdRef = useRef<string | null>(null);
+export function useAutoScrollOnTaskSwitch(isActive: boolean, taskId: string | null) {
+  const previousTaskIdRef = useRef<string | null>(null);
   const scrollTimeoutRef = useRef<NodeJS.Timeout | null>(null);
 
   const scrollToBottom = useCallback((options: ScrollOptions = {}) => {
@@ -49,18 +49,18 @@ export function useAutoScrollOnWorkspaceSwitch(isActive: boolean, workspaceId: s
     });
 
     if (process.env.NODE_ENV === 'development' && !scrolledAny) {
-      console.debug('[useAutoScrollOnWorkspaceSwitch] No scrollable terminal containers found');
+      console.debug('[useAutoScrollOnTaskSwitch] No scrollable terminal containers found');
     }
   }, []);
 
   useEffect(() => {
-    if (!isActive || !workspaceId) {
+    if (!isActive || !taskId) {
       return;
     }
 
-    // Check if workspace actually changed
-    if (previousWorkspaceIdRef.current !== workspaceId) {
-      previousWorkspaceIdRef.current = workspaceId;
+    // Check if task actually changed
+    if (previousTaskIdRef.current !== taskId) {
+      previousTaskIdRef.current = taskId;
 
       // Clear any existing timeout
       if (scrollTimeoutRef.current) {
@@ -79,7 +79,7 @@ export function useAutoScrollOnWorkspaceSwitch(isActive: boolean, workspaceId: s
         scrollTimeoutRef.current = null;
       }
     };
-  }, [isActive, workspaceId, scrollToBottom]);
+  }, [isActive, taskId, scrollToBottom]);
 
   // Expose a manual scroll function for external use
   return { scrollToBottom };
diff --git a/src/renderer/hooks/useCreatePR.tsx b/src/renderer/hooks/useCreatePR.tsx
index 62627963..2c88fa02 100644
--- a/src/renderer/hooks/useCreatePR.tsx
+++ b/src/renderer/hooks/useCreatePR.tsx
@@ -45,7 +45,7 @@ export function useCreatePR() {
       }
 
       const inferredTitle =
-        prOptions?.title || workspacePath.split(/[/\\]/).filter(Boolean).pop() || 'Workspace';
+        prOptions?.title || workspacePath.split(/[/\\]/).filter(Boolean).pop() || 'Task';
 
       let finalPrOptions = { ...(prOptions || {}), title: inferredTitle };
 
diff --git a/src/renderer/hooks/useWorkspaceBusy.ts b/src/renderer/hooks/useTaskBusy.ts
similarity index 53%
rename from src/renderer/hooks/useWorkspaceBusy.ts
rename to src/renderer/hooks/useTaskBusy.ts
index 831a709a..3ec767e6 100644
--- a/src/renderer/hooks/useWorkspaceBusy.ts
+++ b/src/renderer/hooks/useTaskBusy.ts
@@ -1,8 +1,8 @@
 import { useEffect, useState } from 'react';
 import { activityStore } from '../lib/activityStore';
 
-export function useWorkspaceBusy(workspaceId: string) {
+export function useTaskBusy(taskId: string) {
   const [busy, setBusy] = useState(false);
-  useEffect(() => activityStore.subscribe(workspaceId, setBusy), [workspaceId]);
+  useEffect(() => activityStore.subscribe(taskId, setBusy), [taskId]);
   return busy;
 }
diff --git a/src/renderer/hooks/useWorkspaceChanges.ts b/src/renderer/hooks/useTaskChanges.ts
similarity index 80%
rename from src/renderer/hooks/useWorkspaceChanges.ts
rename to src/renderer/hooks/useTaskChanges.ts
index 2ae87953..06e2c82d 100644
--- a/src/renderer/hooks/useWorkspaceChanges.ts
+++ b/src/renderer/hooks/useTaskChanges.ts
@@ -1,6 +1,6 @@
 import { useState, useEffect, useCallback } from 'react';
 
-export interface WorkspaceChange {
+export interface TaskChange {
   path: string;
   status: string;
   additions: number;
@@ -8,18 +8,18 @@ export interface WorkspaceChange {
   diff?: string;
 }
 
-export interface WorkspaceChanges {
-  workspaceId: string;
-  changes: WorkspaceChange[];
+export interface TaskChanges {
+  taskId: string;
+  changes: TaskChange[];
   totalAdditions: number;
   totalDeletions: number;
   isLoading: boolean;
   error?: string;
 }
 
-export function useWorkspaceChanges(workspacePath: string, workspaceId: string) {
-  const [changes, setChanges] = useState<WorkspaceChanges>({
-    workspaceId,
+export function useTaskChanges(taskPath: string, taskId: string) {
+  const [changes, setChanges] = useState<TaskChanges>({
+    taskId,
     changes: [],
     totalAdditions: 0,
     totalDeletions: 0,
@@ -33,7 +33,7 @@ export function useWorkspaceChanges(workspacePath: string, workspaceId: string)
           setChanges((prev) => ({ ...prev, isLoading: true, error: undefined }));
         }
 
-        const result = await window.electronAPI.getGitStatus(workspacePath);
+        const result = await window.electronAPI.getGitStatus(taskPath);
 
         if (result.success && result.changes) {
           const filtered = result.changes.filter(
@@ -43,7 +43,7 @@ export function useWorkspaceChanges(workspacePath: string, workspaceId: string)
           const totalDeletions = filtered.reduce((sum, change) => sum + (change.deletions || 0), 0);
 
           setChanges({
-            workspaceId,
+            taskId,
             changes: filtered,
             totalAdditions,
             totalDeletions,
@@ -51,7 +51,7 @@ export function useWorkspaceChanges(workspacePath: string, workspaceId: string)
           });
         } else {
           setChanges({
-            workspaceId,
+            taskId,
             changes: [],
             totalAdditions: 0,
             totalDeletions: 0,
@@ -61,7 +61,7 @@ export function useWorkspaceChanges(workspacePath: string, workspaceId: string)
         }
       } catch (error) {
         setChanges({
-          workspaceId,
+          taskId,
           changes: [],
           totalAdditions: 0,
           totalDeletions: 0,
@@ -70,7 +70,7 @@ export function useWorkspaceChanges(workspacePath: string, workspaceId: string)
         });
       }
     },
-    [workspacePath, workspaceId]
+    [taskPath, taskId]
   );
 
   // eslint-disable-next-line react-hooks/set-state-in-effect
diff --git a/src/renderer/lib/workspaceNames.ts b/src/renderer/lib/taskNames.ts
similarity index 63%
rename from src/renderer/lib/workspaceNames.ts
rename to src/renderer/lib/taskNames.ts
index 373b2045..2dd3ba77 100644
--- a/src/renderer/lib/workspaceNames.ts
+++ b/src/renderer/lib/taskNames.ts
@@ -1,6 +1,6 @@
 import { humanId } from 'human-id';
 
-export type WorkspaceNameGenerator = (
+export type TaskNameGenerator = (
   existingNames: Iterable<string>,
   options?: { seed?: number }
 ) => string;
@@ -51,9 +51,9 @@ const NOUNS = [
   'whisper',
 ] as const;
 
-export const MAX_WORKSPACE_NAME_LENGTH = 64;
+export const MAX_TASK_NAME_LENGTH = 64;
 
-export const normalizeWorkspaceName = (input: string): string =>
+export const normalizeTaskName = (input: string): string =>
   input
     .trim()
     .toLowerCase()
@@ -61,36 +61,36 @@ export const normalizeWorkspaceName = (input: string): string =>
     .replace(/[^a-z0-9-]/g, '')
     .replace(/-+/g, '-')
     .replace(/^-+|-+$/g, '')
-    .slice(0, MAX_WORKSPACE_NAME_LENGTH);
+    .slice(0, MAX_TASK_NAME_LENGTH);
 
-export const ensureUniqueWorkspaceName = (
+export const ensureUniqueTaskName = (
   baseName: string,
   existingNames: Iterable<string>,
   maxAttempts = 6
 ): string => {
   const normalizedExisting = new Set(
-    Array.from(existingNames, (name) => normalizeWorkspaceName(name)).filter(Boolean)
+    Array.from(existingNames, (name) => normalizeTaskName(name)).filter(Boolean)
   );
-  const base = normalizeWorkspaceName(baseName);
+  const base = normalizeTaskName(baseName);
   if (base && !normalizedExisting.has(base)) return base;
 
   for (let i = 2; i < 2 + maxAttempts; i++) {
-    const candidate = normalizeWorkspaceName(`${baseName}-${i}`);
+    const candidate = normalizeTaskName(`${baseName}-${i}`);
     if (candidate && !normalizedExisting.has(candidate)) {
       return candidate;
     }
   }
 
-  const fallback = normalizeWorkspaceName(`${baseName}-${Date.now().toString(36)}`);
+  const fallback = normalizeTaskName(`${baseName}-${Date.now().toString(36)}`);
   return fallback || base;
 };
 
 const pick = (list: readonly string[], rnd: () => number) =>
   list[Math.floor(rnd() * list.length)] || '';
 
-const wordlistGenerator: WorkspaceNameGenerator = (existingNames, options) => {
+const wordlistGenerator: TaskNameGenerator = (existingNames, options) => {
   const taken = new Set(
-    Array.from(existingNames || [], (n) => normalizeWorkspaceName(n)).filter(Boolean)
+    Array.from(existingNames || [], (n) => normalizeTaskName(n)).filter(Boolean)
   );
 
   let currentSeed = options?.seed ?? Math.random();
@@ -101,47 +101,47 @@ const wordlistGenerator: WorkspaceNameGenerator = (existingNames, options) => {
 
   for (let i = 0; i < 8; i++) {
     const candidate = `${pick(ADJECTIVES, rng)}-${pick(NOUNS, rng)}`;
-    const normalized = normalizeWorkspaceName(candidate);
+    const normalized = normalizeTaskName(candidate);
     if (normalized && !taken.has(normalized)) {
       return candidate;
     }
   }
 
-  return 'workspace';
+  return 'task';
 };
 
-const humanIdGenerator: WorkspaceNameGenerator = () => {
+const humanIdGenerator: TaskNameGenerator = () => {
   // human-id already filters for SFW words; leave normalization/uniqueness to the wrapper
   return humanId({ separator: '-', capitalize: false });
 };
 
-let activeGenerator: WorkspaceNameGenerator = humanIdGenerator;
+let activeGenerator: TaskNameGenerator = humanIdGenerator;
 
-export const setWorkspaceNameGenerator = (generator: WorkspaceNameGenerator | null | undefined) => {
+export const setTaskNameGenerator = (generator: TaskNameGenerator | null | undefined) => {
   activeGenerator = generator || humanIdGenerator;
 };
 
-export const generateFriendlyWorkspaceName = (
+export const generateFriendlyTaskName = (
   existingNames: Iterable<string> = [],
-  options?: { generator?: WorkspaceNameGenerator; seed?: number }
+  options?: { generator?: TaskNameGenerator; seed?: number }
 ): string => {
   const generator = options?.generator || activeGenerator;
   const seed = options?.seed;
 
   const existingArray = Array.from(existingNames || []);
 
-  const runGenerator = (gen: WorkspaceNameGenerator): string => {
+  const runGenerator = (gen: TaskNameGenerator): string => {
     try {
       const raw = gen(existingArray, { seed });
-      const normalized = normalizeWorkspaceName(raw);
+      const normalized = normalizeTaskName(raw);
       if (normalized) {
-        return ensureUniqueWorkspaceName(normalized, existingArray);
+        return ensureUniqueTaskName(normalized, existingArray);
       }
     } catch {
       // fall through to fallback
     }
     const fallbackRaw = wordlistGenerator(existingArray, { seed });
-    return ensureUniqueWorkspaceName(fallbackRaw, existingArray);
+    return ensureUniqueTaskName(fallbackRaw, existingArray);
   };
 
   const primary = runGenerator(generator);
diff --git a/src/renderer/lib/workspaceStatus.ts b/src/renderer/lib/taskStatus.ts
similarity index 100%
rename from src/renderer/lib/workspaceStatus.ts
rename to src/renderer/lib/taskStatus.ts
diff --git a/src/renderer/lib/workspaceTerminalsStore.ts b/src/renderer/lib/taskTerminalsStore.ts
similarity index 84%
rename from src/renderer/lib/workspaceTerminalsStore.ts
rename to src/renderer/lib/taskTerminalsStore.ts
index 30819b1c..63d2b7a4 100644
--- a/src/renderer/lib/workspaceTerminalsStore.ts
+++ b/src/renderer/lib/taskTerminalsStore.ts
@@ -1,6 +1,6 @@
 import { useMemo, useSyncExternalStore } from 'react';
 
-type WorkspaceTerminal = {
+type TaskTerminal = {
   id: string;
   title: string;
   cwd?: string;
@@ -8,20 +8,20 @@ type WorkspaceTerminal = {
   createdAt: number;
 };
 
-type WorkspaceTerminalsState = {
-  terminals: WorkspaceTerminal[];
+type TaskTerminalsState = {
+  terminals: TaskTerminal[];
   activeId: string | null;
   counter: number;
 };
 
 type WorkspaceSnapshot = {
-  terminals: WorkspaceTerminal[];
+  terminals: TaskTerminal[];
   activeTerminalId: string | null;
 };
 
 const STORAGE_PREFIX = 'emdash:workspaceTerminals:v1';
 
-const workspaceStates = new Map<string, WorkspaceTerminalsState>();
+const workspaceStates = new Map<string, TaskTerminalsState>();
 const workspaceListeners = new Map<string, Set<() => void>>();
 const workspaceSnapshots = new Map<string, WorkspaceSnapshot>();
 
@@ -46,7 +46,7 @@ function storageKey(workspaceId: string) {
   return `${STORAGE_PREFIX}:${workspaceId}`;
 }
 
-function cloneState(state: WorkspaceTerminalsState): WorkspaceTerminalsState {
+function cloneState(state: TaskTerminalsState): TaskTerminalsState {
   return {
     terminals: state.terminals.map((terminal) => ({ ...terminal })),
     activeId: state.activeId,
@@ -54,7 +54,7 @@ function cloneState(state: WorkspaceTerminalsState): WorkspaceTerminalsState {
   };
 }
 
-function loadFromStorage(workspaceId: string): WorkspaceTerminalsState | null {
+function loadFromStorage(workspaceId: string): TaskTerminalsState | null {
   if (!storageAvailable) return null;
   try {
     const raw = window.localStorage.getItem(storageKey(workspaceId));
@@ -78,9 +78,9 @@ function loadFromStorage(workspaceId: string): WorkspaceTerminalsState | null {
                 typeof item.createdAt === 'number' && Number.isFinite(item.createdAt)
                   ? item.createdAt
                   : Date.now(),
-            } satisfies WorkspaceTerminal;
+            } satisfies TaskTerminal;
           })
-          .filter((x: WorkspaceTerminal | null): x is WorkspaceTerminal => Boolean(x))
+          .filter((x: TaskTerminal | null): x is TaskTerminal => Boolean(x))
       : [];
 
     const counter =
@@ -90,7 +90,7 @@ function loadFromStorage(workspaceId: string): WorkspaceTerminalsState | null {
 
     let activeId: string | null = null;
     if (typeof parsed.activeId === 'string' && parsed.activeId) {
-      activeId = terminals.some((terminal: WorkspaceTerminal) => terminal.id === parsed.activeId)
+      activeId = terminals.some((terminal: TaskTerminal) => terminal.id === parsed.activeId)
         ? parsed.activeId
         : (terminals[0]?.id ?? null);
     } else {
@@ -109,7 +109,7 @@ function loadFromStorage(workspaceId: string): WorkspaceTerminalsState | null {
   }
 }
 
-function saveToStorage(workspaceId: string, state: WorkspaceTerminalsState) {
+function saveToStorage(workspaceId: string, state: TaskTerminalsState) {
   if (!storageAvailable) return;
   try {
     const payload = JSON.stringify({
@@ -128,9 +128,9 @@ function makeTerminalId(workspaceId: string): string {
   return `${workspaceId}::term::${Date.now().toString(16)}::${rnd}`;
 }
 
-function createDefaultState(workspaceId: string, workspacePath?: string): WorkspaceTerminalsState {
+function createDefaultState(workspaceId: string, workspacePath?: string): TaskTerminalsState {
   const terminalId = makeTerminalId(workspaceId);
-  const firstTerminal: WorkspaceTerminal = {
+  const firstTerminal: TaskTerminal = {
     id: terminalId,
     title: 'Terminal 1',
     cwd: workspacePath,
@@ -143,7 +143,7 @@ function createDefaultState(workspaceId: string, workspacePath?: string): Worksp
   };
 }
 
-function ensureSnapshot(workspaceId: string, state: WorkspaceTerminalsState) {
+function ensureSnapshot(workspaceId: string, state: TaskTerminalsState) {
   const current = workspaceSnapshots.get(workspaceId);
   if (
     !current ||
@@ -161,7 +161,7 @@ function ensureSnapshot(workspaceId: string, state: WorkspaceTerminalsState) {
 function ensureWorkspaceState(
   workspaceId: string,
   workspacePath?: string
-): WorkspaceTerminalsState {
+): TaskTerminalsState {
   let state = workspaceStates.get(workspaceId);
   if (state) {
     ensureSnapshot(workspaceId, state);
@@ -189,7 +189,7 @@ function emit(workspaceId: string) {
 function updateWorkspaceState(
   workspaceId: string,
   workspacePath: string | undefined,
-  mutate: (draft: WorkspaceTerminalsState) => void
+  mutate: (draft: TaskTerminalsState) => void
 ) {
   const current = ensureWorkspaceState(workspaceId, workspacePath);
   const draft = cloneState(current);
@@ -295,15 +295,15 @@ function closeTerminal(workspaceId: string, terminalId: string, workspacePath?:
   }
 }
 
-export function useWorkspaceTerminals(workspaceId: string | null, workspacePath?: string) {
+export function useTaskTerminals(taskId: string | null, taskPath?: string) {
   const snapshot = useSyncExternalStore(
-    (listener) => subscribe(workspaceId, workspacePath, listener),
-    () => getSnapshot(workspaceId, workspacePath),
-    () => getSnapshot(workspaceId, workspacePath)
+    (listener) => subscribe(taskId, taskPath, listener),
+    () => getSnapshot(taskId, taskPath),
+    () => getSnapshot(taskId, taskPath)
   );
 
   const actions = useMemo(() => {
-    if (!workspaceId) {
+    if (!taskId) {
       return {
         createTerminal: () => undefined,
         setActiveTerminal: (_terminalId: string) => undefined,
@@ -311,11 +311,11 @@ export function useWorkspaceTerminals(workspaceId: string | null, workspacePath?
       };
     }
     return {
-      createTerminal: () => createTerminal(workspaceId, workspacePath),
-      setActiveTerminal: (terminalId: string) => setActive(workspaceId, terminalId, workspacePath),
-      closeTerminal: (terminalId: string) => closeTerminal(workspaceId, terminalId, workspacePath),
+      createTerminal: () => createTerminal(taskId, taskPath),
+      setActiveTerminal: (terminalId: string) => setActive(taskId, terminalId, taskPath),
+      closeTerminal: (terminalId: string) => closeTerminal(taskId, terminalId, taskPath),
     };
-  }, [workspaceId, workspacePath]);
+  }, [taskId, taskPath]);
 
   const activeTerminal =
     snapshot.terminals.find((terminal) => terminal.id === snapshot.activeTerminalId) ?? null;
@@ -328,4 +328,4 @@ export function useWorkspaceTerminals(workspaceId: string | null, workspacePath?
   };
 }
 
-export type { WorkspaceTerminal };
+export type { TaskTerminal };
diff --git a/src/renderer/types/app.ts b/src/renderer/types/app.ts
index 0d8d87af..8c02d254 100644
--- a/src/renderer/types/app.ts
+++ b/src/renderer/types/app.ts
@@ -1,5 +1,5 @@
-import type { Workspace as ChatWorkspace } from './chat';
-export type Workspace = ChatWorkspace & { agentId?: string };
+import type { Task as ChatTask } from './chat';
+export type Task = ChatTask & { agentId?: string };
 
 export interface Project {
   id: string;
@@ -16,11 +16,12 @@ export interface Project {
     repository: string;
     connected: boolean;
   };
-  workspaces?: Workspace[];
+  // Internal DB field name kept as 'workspaces' for compatibility
+  workspaces?: Task[];
 }
 
 // Lightweight shapes for palette/list UIs, if needed later
 export type ProjectSummary = Pick<Project, 'id' | 'name'> & {
-  workspaces?: Pick<Workspace, 'id' | 'name'>[];
+  workspaces?: Pick<Task, 'id' | 'name'>[];
 };
-export type WorkspaceSummary = Pick<Workspace, 'id' | 'name'>;
+export type TaskSummary = Pick<Task, 'id' | 'name'>;
diff --git a/src/renderer/types/chat.ts b/src/renderer/types/chat.ts
index 9db4a124..99ccc7e8 100644
--- a/src/renderer/types/chat.ts
+++ b/src/renderer/types/chat.ts
@@ -3,13 +3,13 @@ import { type LinearIssueSummary } from './linear';
 import { type GitHubIssueSummary } from './github';
 import { type JiraIssueSummary } from './jira';
 
-/** Per-provider run configuration for workspace creation */
+/** Per-provider run configuration for task creation */
 export interface ProviderRun {
   provider: ProviderId;
   runs: number;
 }
 
-export interface WorkspaceMetadata {
+export interface TaskMetadata {
   linearIssue?: LinearIssueSummary | null;
   githubIssue?: GitHubIssueSummary | null;
   jiraIssue?: JiraIssueSummary | null;
@@ -17,10 +17,10 @@ export interface WorkspaceMetadata {
   autoApprove?: boolean | null;
   /** Set to true after the initial injection (prompt/issue) has been sent to the agent */
   initialInjectionSent?: boolean | null;
-  // When present, this workspace is a multi-agent workspace orchestrating multiple worktrees
+  // When present, this task is a multi-agent task orchestrating multiple worktrees
   multiAgent?: {
     enabled: boolean;
-    // Max panes allowed when the workspace was created (UI hint)
+    // Max panes allowed when the task was created (UI hint)
     maxProviders?: number;
     // Per-provider run configuration
     providerRuns?: ProviderRun[];
@@ -29,7 +29,7 @@ export interface WorkspaceMetadata {
     variants: Array<{
       id: string;
       provider: ProviderId;
-      name: string; // worktree display name, e.g. workspaceName-providerSlug
+      name: string; // worktree display name, e.g. taskName-providerSlug
       branch: string;
       path: string; // filesystem path of the worktree
       worktreeId: string; // WorktreeService id (stable hash of path)
@@ -38,14 +38,14 @@ export interface WorkspaceMetadata {
   } | null;
 }
 
-export interface Workspace {
+export interface Task {
   id: string;
   projectId: string;
   name: string;
   branch: string;
   path: string;
   status: 'active' | 'idle' | 'running';
-  metadata?: WorkspaceMetadata | null;
+  metadata?: TaskMetadata | null;
 }
 
 export interface Message {
diff --git a/src/renderer/types/index.ts b/src/renderer/types/index.ts
index 70d9eaf1..39da0c05 100644
--- a/src/renderer/types/index.ts
+++ b/src/renderer/types/index.ts
@@ -41,7 +41,7 @@ export interface Settings {
   maxConcurrentRuns: number;
 }
 
-export interface Workspace {
+export interface Task {
   id: string;
   name: string;
   repos: Repo[];

From 2de539efab2d7a79bf7ca2c0874f1e43d56b903f Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Fri, 12 Dec 2025 17:23:29 -0800
Subject: [PATCH 02/35] refactor: rename workspaceId to taskId throughout
 codebase

---
 src/main/db/schema.ts                         |   6 +-
 src/main/ipc/containerIpc.ts                  |  26 ++---
 src/main/ipc/dbIpc.ts                         |  14 +--
 src/main/ipc/hostPreviewIpc.ts                |  12 +-
 src/main/preload.ts                           |  42 +++----
 src/main/services/DatabaseService.ts          |  32 +++---
 src/main/services/containerRunnerService.ts   |  78 ++++++-------
 src/main/services/hostPreviewService.ts       |  74 ++++++-------
 src/main/services/ptyIpc.ts                   |  16 +--
 src/renderer/App.tsx                          |   8 +-
 src/renderer/components/ActiveRuns.tsx        |  12 +-
 src/renderer/components/BrowserPane.tsx       |  38 +++----
 src/renderer/components/ChatInterface.tsx     |   8 +-
 src/renderer/components/CommandPalette.tsx    |   2 +-
 .../components/CommandPaletteWrapper.tsx      |   4 +-
 src/renderer/components/FileChangesPanel.tsx  |  28 ++---
 src/renderer/components/ProjectMainView.tsx   |   6 +-
 src/renderer/components/ProviderBar.tsx       |  14 +--
 src/renderer/components/RightSidebar.tsx      |   4 +-
 src/renderer/components/TaskDeleteButton.tsx  |  10 +-
 src/renderer/components/TaskItem.tsx          |   2 +-
 src/renderer/components/TaskPorts.tsx         |   8 +-
 src/renderer/components/TerminalPane.tsx      |   2 +-
 .../components/kanban/KanbanBoard.tsx         |   6 +-
 src/renderer/components/kanban/KanbanCard.tsx |   4 +-
 .../components/kanban/KanbanColumn.tsx        |   2 +-
 .../titlebar/BrowserToggleButton.tsx          |  36 +++---
 src/renderer/components/titlebar/Titlebar.tsx |   8 +-
 .../hooks/useInitialPromptInjection.ts        |  10 +-
 src/renderer/hooks/usePlanActivation.ts       |   8 +-
 src/renderer/hooks/usePlanMode.ts             |  10 +-
 src/renderer/hooks/useProviderPreference.ts   |  12 +-
 src/renderer/lib/containerRuns.ts             |  50 ++++-----
 src/renderer/lib/filters.ts                   |   2 +-
 src/renderer/lib/kanbanStore.ts               |   8 +-
 src/renderer/lib/keys.ts                      |   6 +-
 src/renderer/lib/quickPreview.ts              |  10 +-
 src/renderer/lib/taskStatus.ts                |  66 +++++------
 src/renderer/lib/taskTerminalsStore.ts        | 104 +++++++++---------
 src/renderer/terminal/SessionRegistry.ts      |  22 ++--
 .../terminal/TerminalSessionManager.ts        |   8 +-
 src/renderer/types/electron-api.d.ts          |  12 +-
 src/renderer/types/global.d.ts                |   2 +-
 src/shared/container/events.ts                |   4 +-
 src/shared/container/mockRunner.test.ts       |  10 +-
 src/shared/container/mockRunner.ts            |  20 ++--
 src/test/main/ContainerIpc.test.ts            |  12 +-
 src/test/main/ContainerRunnerService.test.ts  |   6 +-
 src/test/renderer/containerRuns.test.ts       |  16 +--
 49 files changed, 450 insertions(+), 450 deletions(-)

diff --git a/src/main/db/schema.ts b/src/main/db/schema.ts
index d65977b3..fcdfd2a5 100644
--- a/src/main/db/schema.ts
+++ b/src/main/db/schema.ts
@@ -53,7 +53,7 @@ export const conversations = sqliteTable(
   'conversations',
   {
     id: text('id').primaryKey(),
-    workspaceId: text('workspace_id')
+    taskId: text('workspace_id')
       .notNull()
       .references(() => workspaces.id, { onDelete: 'cascade' }),
     title: text('title').notNull(),
@@ -65,7 +65,7 @@ export const conversations = sqliteTable(
       .default(sql`CURRENT_TIMESTAMP`),
   },
   (table) => ({
-    workspaceIdIdx: index('idx_conversations_workspace_id').on(table.workspaceId),
+    taskIdIdx: index('idx_conversations_workspace_id').on(table.taskId),
   })
 );
 
@@ -103,7 +103,7 @@ export const workspacesRelations = relations(workspaces, ({ one, many }) => ({
 
 export const conversationsRelations = relations(conversations, ({ one, many }) => ({
   workspace: one(workspaces, {
-    fields: [conversations.workspaceId],
+    fields: [conversations.taskId],
     references: [workspaces.id],
   }),
   messages: many(messages),
diff --git a/src/main/ipc/containerIpc.ts b/src/main/ipc/containerIpc.ts
index 01156af9..539d5c81 100644
--- a/src/main/ipc/containerIpc.ts
+++ b/src/main/ipc/containerIpc.ts
@@ -114,7 +114,7 @@ export function registerContainerIpc(): void {
           ok: false,
           error: {
             code: 'INVALID_ARGUMENT',
-            message: '`workspaceId` and `workspacePath` must be provided to start a container run',
+            message: '`taskId` and `workspacePath` must be provided to start a container run',
             configPath: null,
             configKey: null,
           },
@@ -131,11 +131,11 @@ export function registerContainerIpc(): void {
     'container:stop-run',
     async (_event, args): Promise<{ ok: boolean; error?: string }> => {
       try {
-        const workspaceId = typeof args?.workspaceId === 'string' ? args.workspaceId.trim() : '';
-        if (!workspaceId) {
-          return { ok: false, error: '`workspaceId` must be provided' };
+        const taskId = typeof args?.taskId === 'string' ? args.taskId.trim() : '';
+        if (!taskId) {
+          return { ok: false, error: '`taskId` must be provided' };
         }
-        const res = await containerRunnerService.stopRun(workspaceId);
+        const res = await containerRunnerService.stopRun(taskId);
         return res as any;
       } catch (error: any) {
         return { ok: false, error: error?.message || String(error) };
@@ -158,11 +158,11 @@ export function registerContainerIpc(): void {
       | { ok: false; error: string }
     > => {
       try {
-        const workspaceId = typeof args?.workspaceId === 'string' ? args.workspaceId.trim() : '';
-        if (!workspaceId) {
-          return { ok: false, error: '`workspaceId` must be provided' } as const;
+        const taskId = typeof args?.taskId === 'string' ? args.taskId.trim() : '';
+        if (!taskId) {
+          return { ok: false, error: '`taskId` must be provided' } as const;
         }
-        return await containerRunnerService.inspectRun(workspaceId);
+        return await containerRunnerService.inspectRun(taskId);
       } catch (error: any) {
         const message = error?.message || String(error);
         log.warn('container:inspect-run failed', message);
@@ -218,7 +218,7 @@ function serializeError(error: ContainerConfigLoadError): SerializedContainerCon
 }
 
 function parseStartRunArgs(args: unknown): {
-  workspaceId: string;
+  taskId: string;
   workspacePath: string;
   runId?: string;
   mode?: RunnerMode;
@@ -228,10 +228,10 @@ function parseStartRunArgs(args: unknown): {
   }
 
   const payload = args as Record<string, unknown>;
-  const workspaceId = typeof payload.workspaceId === 'string' ? payload.workspaceId.trim() : '';
+  const taskId = typeof payload.taskId === 'string' ? payload.taskId.trim() : '';
   const workspacePath =
     typeof payload.workspacePath === 'string' ? payload.workspacePath.trim() : '';
-  if (!workspaceId || !workspacePath) {
+  if (!taskId || !workspacePath) {
     return null;
   }
 
@@ -247,7 +247,7 @@ function parseStartRunArgs(args: unknown): {
     }
   }
 
-  return { workspaceId, workspacePath, runId, mode };
+  return { taskId, workspacePath, runId, mode };
 }
 
 function serializeStartRunResult(result: ContainerStartResult): ContainerStartIpcResponse {
diff --git a/src/main/ipc/dbIpc.ts b/src/main/ipc/dbIpc.ts
index 6d8cdb55..9f964496 100644
--- a/src/main/ipc/dbIpc.ts
+++ b/src/main/ipc/dbIpc.ts
@@ -62,9 +62,9 @@ export function registerDatabaseIpc() {
     }
   });
 
-  ipcMain.handle('db:getConversations', async (_, workspaceId: string) => {
+  ipcMain.handle('db:getConversations', async (_, taskId: string) => {
     try {
-      const conversations = await databaseService.getConversations(workspaceId);
+      const conversations = await databaseService.getConversations(taskId);
       return { success: true, conversations };
     } catch (error) {
       log.error('Failed to get conversations:', error);
@@ -72,9 +72,9 @@ export function registerDatabaseIpc() {
     }
   });
 
-  ipcMain.handle('db:getOrCreateDefaultConversation', async (_, workspaceId: string) => {
+  ipcMain.handle('db:getOrCreateDefaultConversation', async (_, taskId: string) => {
     try {
-      const conversation = await databaseService.getOrCreateDefaultConversation(workspaceId);
+      const conversation = await databaseService.getOrCreateDefaultConversation(taskId);
       return { success: true, conversation };
     } catch (error) {
       log.error('Failed to get or create default conversation:', error);
@@ -112,16 +112,16 @@ export function registerDatabaseIpc() {
     }
   });
 
-  ipcMain.handle('db:deleteWorkspace', async (_, workspaceId: string) => {
+  ipcMain.handle('db:deleteWorkspace', async (_, taskId: string) => {
     try {
       // Stop any running Docker container for this workspace before deletion
-      const stopResult = await containerRunnerService.stopRun(workspaceId);
+      const stopResult = await containerRunnerService.stopRun(taskId);
       if (!stopResult.ok) {
         // Log but don't fail workspace deletion if container stop fails
         log.warn('Failed to stop container during workspace deletion:', stopResult.error);
       }
 
-      await databaseService.deleteWorkspace(workspaceId);
+      await databaseService.deleteWorkspace(taskId);
       return { success: true };
     } catch (error) {
       log.error('Failed to delete workspace:', error);
diff --git a/src/main/ipc/hostPreviewIpc.ts b/src/main/ipc/hostPreviewIpc.ts
index 71552398..97c9437e 100644
--- a/src/main/ipc/hostPreviewIpc.ts
+++ b/src/main/ipc/hostPreviewIpc.ts
@@ -7,15 +7,15 @@ export function registerHostPreviewIpc() {
     async (
       _e,
       args: {
-        workspaceId: string;
+        taskId: string;
         workspacePath: string;
         script?: string;
         parentProjectPath?: string;
       }
     ) => {
-      const id = String(args?.workspaceId || '').trim();
+      const id = String(args?.taskId || '').trim();
       const wp = String(args?.workspacePath || '').trim();
-      if (!id || !wp) return { ok: false, error: 'workspaceId and workspacePath are required' };
+      if (!id || !wp) return { ok: false, error: 'taskId and workspacePath are required' };
       return hostPreviewService.start(id, wp, {
         script: args?.script,
         parentProjectPath: args?.parentProjectPath,
@@ -25,10 +25,10 @@ export function registerHostPreviewIpc() {
 
   ipcMain.handle(
     'preview:host:setup',
-    async (_e, args: { workspaceId: string; workspacePath: string }) => {
-      const id = String(args?.workspaceId || '').trim();
+    async (_e, args: { taskId: string; workspacePath: string }) => {
+      const id = String(args?.taskId || '').trim();
       const wp = String(args?.workspacePath || '').trim();
-      if (!id || !wp) return { ok: false, error: 'workspaceId and workspacePath are required' };
+      if (!id || !wp) return { ok: false, error: 'taskId and workspacePath are required' };
       return hostPreviewService.setup(id, wp);
     }
   );
diff --git a/src/main/preload.ts b/src/main/preload.ts
index 36efbb15..8e812719 100644
--- a/src/main/preload.ts
+++ b/src/main/preload.ts
@@ -154,15 +154,15 @@ contextBridge.exposeInMainWorld('electronAPI', {
   loadContainerConfig: (workspacePath: string) =>
     ipcRenderer.invoke('container:load-config', { workspacePath }),
   startContainerRun: (args: {
-    workspaceId: string;
+    taskId: string;
     workspacePath: string;
     runId?: string;
     mode?: 'container' | 'host';
   }) => ipcRenderer.invoke('container:start-run', args),
-  stopContainerRun: (workspaceId: string) =>
-    ipcRenderer.invoke('container:stop-run', { workspaceId }),
-  inspectContainerRun: (workspaceId: string) =>
-    ipcRenderer.invoke('container:inspect-run', { workspaceId }),
+  stopContainerRun: (taskId: string) =>
+    ipcRenderer.invoke('container:stop-run', { taskId }),
+  inspectContainerRun: (taskId: string) =>
+    ipcRenderer.invoke('container:inspect-run', { taskId }),
   resolveServiceIcon: (args: { service: string; allowNetwork?: boolean; workspacePath?: string }) =>
     ipcRenderer.invoke('icons:resolve-service', args),
   openExternal: (url: string) => ipcRenderer.invoke('app:openExternal', url),
@@ -277,13 +277,13 @@ contextBridge.exposeInMainWorld('electronAPI', {
   getWorkspaces: (projectId?: string) => ipcRenderer.invoke('db:getWorkspaces', projectId),
   saveWorkspace: (workspace: any) => ipcRenderer.invoke('db:saveWorkspace', workspace),
   deleteProject: (projectId: string) => ipcRenderer.invoke('db:deleteProject', projectId),
-  deleteWorkspace: (workspaceId: string) => ipcRenderer.invoke('db:deleteWorkspace', workspaceId),
+  deleteWorkspace: (taskId: string) => ipcRenderer.invoke('db:deleteWorkspace', taskId),
 
   // Conversation management
   saveConversation: (conversation: any) => ipcRenderer.invoke('db:saveConversation', conversation),
-  getConversations: (workspaceId: string) => ipcRenderer.invoke('db:getConversations', workspaceId),
-  getOrCreateDefaultConversation: (workspaceId: string) =>
-    ipcRenderer.invoke('db:getOrCreateDefaultConversation', workspaceId),
+  getConversations: (taskId: string) => ipcRenderer.invoke('db:getConversations', taskId),
+  getOrCreateDefaultConversation: (taskId: string) =>
+    ipcRenderer.invoke('db:getOrCreateDefaultConversation', taskId),
   saveMessage: (message: any) => ipcRenderer.invoke('db:saveMessage', message),
   getMessages: (conversationId: string) => ipcRenderer.invoke('db:getMessages', conversationId),
   deleteConversation: (conversationId: string) =>
@@ -320,14 +320,14 @@ contextBridge.exposeInMainWorld('electronAPI', {
 
   // Host preview (non-container)
   hostPreviewStart: (args: {
-    workspaceId: string;
+    taskId: string;
     workspacePath: string;
     script?: string;
     parentProjectPath?: string;
   }) => ipcRenderer.invoke('preview:host:start', args),
-  hostPreviewSetup: (args: { workspaceId: string; workspacePath: string }) =>
+  hostPreviewSetup: (args: { taskId: string; workspacePath: string }) =>
     ipcRenderer.invoke('preview:host:setup', args),
-  hostPreviewStop: (workspaceId: string) => ipcRenderer.invoke('preview:host:stop', workspaceId),
+  hostPreviewStop: (taskId: string) => ipcRenderer.invoke('preview:host:stop', taskId),
   hostPreviewStopAll: (exceptId?: string) => ipcRenderer.invoke('preview:host:stopAll', exceptId),
   onHostPreviewEvent: (listener: (data: any) => void) => {
     const channel = 'preview:host:event';
@@ -540,7 +540,7 @@ export interface ElectronAPI {
       }
   >;
   startContainerRun: (args: {
-    workspaceId: string;
+    taskId: string;
     workspacePath: string;
     runId?: string;
     mode?: 'container' | 'host';
@@ -562,7 +562,7 @@ export interface ElectronAPI {
         };
       }
   >;
-  stopContainerRun: (workspaceId: string) => Promise<{ ok: boolean; error?: string }>;
+  stopContainerRun: (taskId: string) => Promise<{ ok: boolean; error?: string }>;
 
   // GitHub integration
   githubAuth: () => Promise<{
@@ -627,15 +627,15 @@ export interface ElectronAPI {
   getWorkspaces: (projectId?: string) => Promise<any[]>;
   saveWorkspace: (workspace: any) => Promise<{ success: boolean; error?: string }>;
   deleteProject: (projectId: string) => Promise<{ success: boolean; error?: string }>;
-  deleteWorkspace: (workspaceId: string) => Promise<{ success: boolean; error?: string }>;
+  deleteWorkspace: (taskId: string) => Promise<{ success: boolean; error?: string }>;
 
   // Conversation management
   saveConversation: (conversation: any) => Promise<{ success: boolean; error?: string }>;
   getConversations: (
-    workspaceId: string
+    taskId: string
   ) => Promise<{ success: boolean; conversations?: any[]; error?: string }>;
   getOrCreateDefaultConversation: (
-    workspaceId: string
+    taskId: string
   ) => Promise<{ success: boolean; conversation?: any; error?: string }>;
   saveMessage: (message: any) => Promise<{ success: boolean; error?: string }>;
   getMessages: (
@@ -645,18 +645,18 @@ export interface ElectronAPI {
 
   // Host preview (non-container)
   hostPreviewStart: (args: {
-    workspaceId: string;
+    taskId: string;
     workspacePath: string;
     script?: string;
     parentProjectPath?: string;
   }) => Promise<{ ok: boolean; error?: string }>;
   hostPreviewSetup: (args: {
-    workspaceId: string;
+    taskId: string;
     workspacePath: string;
   }) => Promise<{ ok: boolean; error?: string }>;
-  hostPreviewStop: (workspaceId: string) => Promise<{ ok: boolean }>;
+  hostPreviewStop: (taskId: string) => Promise<{ ok: boolean }>;
   onHostPreviewEvent: (
-    listener: (data: { type: 'url'; workspaceId: string; url: string }) => void
+    listener: (data: { type: 'url'; taskId: string; url: string }) => void
   ) => () => void;
 
   // Main-managed browser (WebContentsView)
diff --git a/src/main/services/DatabaseService.ts b/src/main/services/DatabaseService.ts
index db6df61a..b5ccf285 100644
--- a/src/main/services/DatabaseService.ts
+++ b/src/main/services/DatabaseService.ts
@@ -47,7 +47,7 @@ export interface Workspace {
 
 export interface Conversation {
   id: string;
-  workspaceId: string;
+  taskId: string;
   title: string;
   createdAt: string;
   updatedAt: string;
@@ -264,10 +264,10 @@ export class DatabaseService {
     await db.delete(projectsTable).where(eq(projectsTable.id, projectId));
   }
 
-  async deleteWorkspace(workspaceId: string): Promise<void> {
+  async deleteWorkspace(taskId: string): Promise<void> {
     if (this.disabled) return;
     const { db } = await getDrizzleClient();
-    await db.delete(workspacesTable).where(eq(workspacesTable.id, workspaceId));
+    await db.delete(workspacesTable).where(eq(workspacesTable.id, taskId));
   }
 
   // Conversation management methods
@@ -279,7 +279,7 @@ export class DatabaseService {
       .insert(conversationsTable)
       .values({
         id: conversation.id,
-        workspaceId: conversation.workspaceId,
+        taskId: conversation.taskId,
         title: conversation.title,
         updatedAt: sql`CURRENT_TIMESTAMP`,
       })
@@ -292,22 +292,22 @@ export class DatabaseService {
       });
   }
 
-  async getConversations(workspaceId: string): Promise<Conversation[]> {
+  async getConversations(taskId: string): Promise<Conversation[]> {
     if (this.disabled) return [];
     const { db } = await getDrizzleClient();
     const rows = await db
       .select()
       .from(conversationsTable)
-      .where(eq(conversationsTable.workspaceId, workspaceId))
+      .where(eq(conversationsTable.taskId, taskId))
       .orderBy(desc(conversationsTable.updatedAt));
     return rows.map((row) => this.mapDrizzleConversationRow(row));
   }
 
-  async getOrCreateDefaultConversation(workspaceId: string): Promise<Conversation> {
+  async getOrCreateDefaultConversation(taskId: string): Promise<Conversation> {
     if (this.disabled) {
       return {
-        id: `conv-${workspaceId}-default`,
-        workspaceId,
+        id: `conv-${taskId}-default`,
+        taskId,
         title: 'Default Conversation',
         createdAt: new Date().toISOString(),
         updatedAt: new Date().toISOString(),
@@ -318,7 +318,7 @@ export class DatabaseService {
     const existingRows = await db
       .select()
       .from(conversationsTable)
-      .where(eq(conversationsTable.workspaceId, workspaceId))
+      .where(eq(conversationsTable.taskId, taskId))
       .orderBy(asc(conversationsTable.createdAt))
       .limit(1);
 
@@ -326,10 +326,10 @@ export class DatabaseService {
       return this.mapDrizzleConversationRow(existingRows[0]);
     }
 
-    const conversationId = `conv-${workspaceId}-${Date.now()}`;
+    const conversationId = `conv-${taskId}-${Date.now()}`;
     await this.saveConversation({
       id: conversationId,
-      workspaceId,
+      taskId,
       title: 'Default Conversation',
     });
 
@@ -345,7 +345,7 @@ export class DatabaseService {
 
     return {
       id: conversationId,
-      workspaceId,
+      taskId,
       title: 'Default Conversation',
       createdAt: new Date().toISOString(),
       updatedAt: new Date().toISOString(),
@@ -490,7 +490,7 @@ export class DatabaseService {
   private mapDrizzleConversationRow(row: ConversationRow): Conversation {
     return {
       id: row.id,
-      workspaceId: row.workspaceId,
+      taskId: row.taskId,
       title: row.title,
       createdAt: row.createdAt,
       updatedAt: row.updatedAt,
@@ -508,11 +508,11 @@ export class DatabaseService {
     };
   }
 
-  private parseWorkspaceMetadata(serialized: string, workspaceId: string): any {
+  private parseWorkspaceMetadata(serialized: string, taskId: string): any {
     try {
       return JSON.parse(serialized);
     } catch (error) {
-      console.warn(`Failed to parse workspace metadata for ${workspaceId}`, error);
+      console.warn(`Failed to parse workspace metadata for ${taskId}`, error);
       return null;
     }
   }
diff --git a/src/main/services/containerRunnerService.ts b/src/main/services/containerRunnerService.ts
index 30ccdd4a..9eb491a2 100644
--- a/src/main/services/containerRunnerService.ts
+++ b/src/main/services/containerRunnerService.ts
@@ -54,7 +54,7 @@ export interface ContainerStartError {
 }
 
 export interface ContainerStartOptions {
-  workspaceId: string;
+  taskId: string;
   workspacePath: string;
   runId?: string;
   mode?: RunnerMode;
@@ -103,7 +103,7 @@ export class ContainerRunnerService extends EventEmitter {
   }
 
   private async startComposeRun(args: {
-    workspaceId: string;
+    taskId: string;
     workspacePath: string;
     runId: string;
     mode: RunnerMode;
@@ -111,14 +111,14 @@ export class ContainerRunnerService extends EventEmitter {
     now: () => number;
     composeFile: string;
   }): Promise<ContainerStartResult> {
-    const { workspaceId, workspacePath, runId, mode, config, now, composeFile } = args;
+    const { taskId, workspacePath, runId, mode, config, now, composeFile } = args;
     const execAsync = promisify(exec);
-    const project = `emdash_ws_${workspaceId}`;
+    const project = `emdash_ws_${taskId}`;
 
     const emitLifecycle = (
       status: 'building' | 'starting' | 'ready' | 'stopping' | 'stopped' | 'failed'
     ) => {
-      this.emitRunnerEvent({ ts: now(), workspaceId, runId, mode, type: 'lifecycle', status });
+      this.emitRunnerEvent({ ts: now(), taskId, runId, mode, type: 'lifecycle', status });
     };
     const emitPorts = (
       ports: Array<{ service: string; container: number; host: number }>,
@@ -133,7 +133,7 @@ export class ContainerRunnerService extends EventEmitter {
       }));
       this.emitRunnerEvent({
         ts: now(),
-        workspaceId,
+        taskId,
         runId,
         mode,
         type: 'ports',
@@ -150,7 +150,7 @@ export class ContainerRunnerService extends EventEmitter {
         const message = 'Docker Compose is not available. Please install/update Docker Desktop.';
         this.emitRunnerEvent({
           ts: now(),
-          workspaceId,
+          taskId,
           runId,
           mode,
           type: 'error',
@@ -250,7 +250,7 @@ export class ContainerRunnerService extends EventEmitter {
       return { ok: true, runId, config, sourcePath: null };
     } catch (error) {
       log.error('[containers] compose run failed', error);
-      const serialized = this.serializeStartError(error, { workspaceId, runId, mode, now });
+      const serialized = this.serializeStartError(error, { taskId, runId, mode, now });
       if (serialized.event) this.emitRunnerEvent(serialized.event);
       return { ok: false, error: serialized.error };
     }
@@ -429,7 +429,7 @@ export class ContainerRunnerService extends EventEmitter {
     return this.emit(RUN_EVENT_CHANNEL, event);
   }
 
-  async inspectRun(workspaceId: string): Promise<
+  async inspectRun(taskId: string): Promise<
     | {
         ok: true;
         running: boolean;
@@ -439,7 +439,7 @@ export class ContainerRunnerService extends EventEmitter {
     | { ok: false; error: string }
   > {
     const execAsync = promisify(exec);
-    const project = `emdash_ws_${workspaceId}`;
+    const project = `emdash_ws_${taskId}`;
     try {
       const { stdout } = await execAsync(
         `docker compose -p ${JSON.stringify(project)} ps --format json`
@@ -492,24 +492,24 @@ export class ContainerRunnerService extends EventEmitter {
    * Emits runner events compatible with the existing renderer.
    */
   async startRun(options: ContainerStartOptions): Promise<ContainerStartResult> {
-    const existing = this.startInFlight.get(options.workspaceId);
+    const existing = this.startInFlight.get(options.taskId);
     if (existing) return existing;
 
     const promise = this._startRunImpl(options).finally(() => {
-      this.startInFlight.delete(options.workspaceId);
+      this.startInFlight.delete(options.taskId);
     });
-    this.startInFlight.set(options.workspaceId, promise);
+    this.startInFlight.set(options.taskId, promise);
     return promise;
   }
 
   private async _startRunImpl(options: ContainerStartOptions): Promise<ContainerStartResult> {
-    const { workspaceId, workspacePath } = options;
-    if (!workspaceId || !workspacePath) {
+    const { taskId, workspacePath } = options;
+    if (!taskId || !workspacePath) {
       return {
         ok: false,
         error: {
           code: 'INVALID_ARGUMENT',
-          message: '`workspaceId` and `workspacePath` are required',
+          message: '`taskId` and `workspacePath` are required',
           configKey: null,
           configPath: null,
         },
@@ -544,7 +544,7 @@ export class ContainerRunnerService extends EventEmitter {
     const emitLifecycle = (
       status: 'building' | 'starting' | 'ready' | 'stopping' | 'stopped' | 'failed'
     ) => {
-      this.emitRunnerEvent({ ts: now(), workspaceId, runId, mode, type: 'lifecycle', status });
+      this.emitRunnerEvent({ ts: now(), taskId, runId, mode, type: 'lifecycle', status });
     };
 
     const emitPorts = (
@@ -560,7 +560,7 @@ export class ContainerRunnerService extends EventEmitter {
       }));
       this.emitRunnerEvent({
         ts: now(),
-        workspaceId,
+        taskId,
         runId,
         mode,
         type: 'ports',
@@ -578,7 +578,7 @@ export class ContainerRunnerService extends EventEmitter {
         const message = `Configured workdir does not exist: ${workdirAbs}`;
         const event = {
           ts: now(),
-          workspaceId,
+          taskId,
           runId,
           mode,
           type: 'error' as const,
@@ -602,7 +602,7 @@ export class ContainerRunnerService extends EventEmitter {
         const message = `No package.json found in workdir: ${workdirAbs}. Set the correct 'workdir' in .emdash/config.json`;
         this.emitRunnerEvent({
           ts: now(),
-          workspaceId,
+          taskId,
           runId,
           mode,
           type: 'error',
@@ -631,7 +631,7 @@ export class ContainerRunnerService extends EventEmitter {
         const message = 'Docker is not available or not responding. Please start Docker Desktop.';
         const event = {
           ts: now(),
-          workspaceId,
+          taskId,
           runId,
           mode,
           type: 'error' as const,
@@ -650,7 +650,7 @@ export class ContainerRunnerService extends EventEmitter {
       if (composeBase) {
         log.info('[containers] compose detected; delegating to compose runner');
         return await this.startComposeRun({
-          workspaceId,
+          taskId,
           workspacePath: absWorkspace,
           runId,
           mode,
@@ -671,7 +671,7 @@ export class ContainerRunnerService extends EventEmitter {
       emitLifecycle('building');
 
       // Ensure no leftover container with the same name
-      const containerName = `emdash_ws_${workspaceId}`;
+      const containerName = `emdash_ws_${taskId}`;
       try {
         await execAsync(`docker rm -f ${JSON.stringify(containerName)}`);
       } catch {}
@@ -703,7 +703,7 @@ export class ContainerRunnerService extends EventEmitter {
           const message = `Env file not found: ${envAbs}`;
           this.emitRunnerEvent({
             ts: now(),
-            workspaceId,
+            taskId,
             runId,
             mode,
             type: 'error',
@@ -757,7 +757,7 @@ export class ContainerRunnerService extends EventEmitter {
       );
       this.emitRunnerEvent({
         ts: now(),
-        workspaceId,
+        taskId,
         runId,
         mode,
         type: 'lifecycle',
@@ -775,7 +775,7 @@ export class ContainerRunnerService extends EventEmitter {
     } catch (error) {
       log.error('[containers] docker run failed', error);
       const serialized = this.serializeStartError(error, {
-        workspaceId,
+        taskId,
         runId,
         mode,
         now,
@@ -786,15 +786,15 @@ export class ContainerRunnerService extends EventEmitter {
   }
 
   /** Stop and remove a running container for a task (workspace) */
-  async stopRun(workspaceId: string, opts: { now?: () => number; mode?: RunnerMode } = {}) {
+  async stopRun(taskId: string, opts: { now?: () => number; mode?: RunnerMode } = {}) {
     const now = opts.now ?? Date.now;
     const mode = opts.mode ?? 'container';
     const runId = this.generateRunId(now);
-    const containerName = `emdash_ws_${workspaceId}`;
+    const containerName = `emdash_ws_${taskId}`;
     try {
       this.emitRunnerEvent({
         ts: now(),
-        workspaceId,
+        taskId,
         runId,
         mode,
         type: 'lifecycle',
@@ -810,7 +810,7 @@ export class ContainerRunnerService extends EventEmitter {
       } catch {}
       this.emitRunnerEvent({
         ts: now(),
-        workspaceId,
+        taskId,
         runId,
         mode,
         type: 'lifecycle',
@@ -821,7 +821,7 @@ export class ContainerRunnerService extends EventEmitter {
       const message = e instanceof Error ? e.message : String(e);
       this.emitRunnerEvent({
         ts: now(),
-        workspaceId,
+        taskId,
         runId,
         mode,
         type: 'error',
@@ -833,13 +833,13 @@ export class ContainerRunnerService extends EventEmitter {
   }
 
   async startMockRun(options: ContainerStartOptions): Promise<ContainerStartResult> {
-    const { workspaceId, workspacePath } = options;
-    if (!workspaceId || !workspacePath) {
+    const { taskId, workspacePath } = options;
+    if (!taskId || !workspacePath) {
       return {
         ok: false,
         error: {
           code: 'INVALID_ARGUMENT',
-          message: '`workspaceId` and `workspacePath` are required',
+          message: '`taskId` and `workspacePath` are required',
           configKey: null,
           configPath: null,
         },
@@ -860,7 +860,7 @@ export class ContainerRunnerService extends EventEmitter {
 
     try {
       const events = await generateMockStartEvents({
-        workspaceId,
+        taskId,
         config: loadResult.config,
         portAllocator: this.portAllocator,
         runId,
@@ -881,7 +881,7 @@ export class ContainerRunnerService extends EventEmitter {
     } catch (error) {
       log.error('container runner start failed', error);
       const serialized = this.serializeStartError(error, {
-        workspaceId,
+        taskId,
         runId,
         mode,
         now,
@@ -912,7 +912,7 @@ export class ContainerRunnerService extends EventEmitter {
   private serializeStartError(
     cause: unknown,
     context: {
-      workspaceId: string;
+      taskId: string;
       runId: string;
       mode: RunnerMode;
       now: () => number;
@@ -921,7 +921,7 @@ export class ContainerRunnerService extends EventEmitter {
     if (cause instanceof PortAllocationError) {
       const event: RunnerErrorEvent = {
         ts: context.now(),
-        workspaceId: context.workspaceId,
+        taskId: context.taskId,
         runId: context.runId,
         mode: context.mode,
         type: 'error',
@@ -960,7 +960,7 @@ export class ContainerRunnerService extends EventEmitter {
       },
       event: {
         ts: context.now(),
-        workspaceId: context.workspaceId,
+        taskId: context.taskId,
         runId: context.runId,
         mode: context.mode,
         type: 'error',
diff --git a/src/main/services/hostPreviewService.ts b/src/main/services/hostPreviewService.ts
index 837a2ca2..7a3f6750 100644
--- a/src/main/services/hostPreviewService.ts
+++ b/src/main/services/hostPreviewService.ts
@@ -7,7 +7,7 @@ import { log } from '../lib/logger';
 
 export type HostPreviewEvent = {
   type: 'url' | 'setup' | 'exit';
-  workspaceId: string;
+  taskId: string;
   url?: string;
   status?: 'starting' | 'line' | 'done' | 'error';
   line?: string;
@@ -38,10 +38,10 @@ function normalizeUrl(u: string): string {
 
 class HostPreviewService extends EventEmitter {
   private procs = new Map<string, ChildProcessWithoutNullStreams>();
-  private procCwds = new Map<string, string>(); // Track cwd for each workspaceId
+  private procCwds = new Map<string, string>(); // Track cwd for each taskId
 
   async setup(
-    workspaceId: string,
+    taskId: string,
     workspacePath: string
   ): Promise<{ ok: boolean; error?: string }> {
     const cwd = path.resolve(workspacePath);
@@ -56,12 +56,12 @@ class HostPreviewService extends EventEmitter {
         shell: true,
         env: { ...process.env, BROWSER: 'none' },
       });
-      this.emit('event', { type: 'setup', workspaceId, status: 'starting' } as HostPreviewEvent);
+      this.emit('event', { type: 'setup', taskId, status: 'starting' } as HostPreviewEvent);
       const onData = (buf: Buffer) => {
         const line = buf.toString();
         this.emit('event', {
           type: 'setup',
-          workspaceId,
+          taskId,
           status: 'line',
           line,
         } as HostPreviewEvent);
@@ -75,12 +75,12 @@ class HostPreviewService extends EventEmitter {
         });
         child.on('error', reject);
       });
-      this.emit('event', { type: 'setup', workspaceId, status: 'done' } as HostPreviewEvent);
+      this.emit('event', { type: 'setup', taskId, status: 'done' } as HostPreviewEvent);
       return { ok: true };
     } catch (e: any) {
       this.emit('event', {
         type: 'setup',
-        workspaceId,
+        taskId,
         status: 'error',
         line: e?.message || String(e),
       } as HostPreviewEvent);
@@ -121,7 +121,7 @@ class HostPreviewService extends EventEmitter {
   }
 
   async start(
-    workspaceId: string,
+    taskId: string,
     workspacePath: string,
     opts?: { script?: string; parentProjectPath?: string }
   ): Promise<{ ok: boolean; error?: string }> {
@@ -129,16 +129,16 @@ class HostPreviewService extends EventEmitter {
 
     // Log the resolved path to help debug worktree issues
     log.info?.('[hostPreview] start', {
-      workspaceId,
+      taskId,
       workspacePath,
       resolvedCwd: cwd,
       cwdExists: fs.existsSync(cwd),
       hasPackageJson: fs.existsSync(path.join(cwd, 'package.json')),
     });
 
-    // Check if process already exists for this workspaceId
-    const existingProc = this.procs.get(workspaceId);
-    const existingCwd = this.procCwds.get(workspaceId);
+    // Check if process already exists for this taskId
+    const existingProc = this.procs.get(taskId);
+    const existingCwd = this.procCwds.get(taskId);
 
     // If process exists, verify it's running from the correct directory
     if (existingProc) {
@@ -149,27 +149,27 @@ class HostPreviewService extends EventEmitter {
         // Process is still running - check if cwd matches
         if (existingCwd && path.resolve(existingCwd) === cwd) {
           log.info?.('[hostPreview] reusing existing process', {
-            workspaceId,
+            taskId,
             cwd: existingCwd,
           });
           return { ok: true };
         } else {
           // Process exists but is running from wrong directory - stop it
           log.info?.('[hostPreview] stopping process with wrong cwd', {
-            workspaceId,
+            taskId,
             oldCwd: existingCwd,
             newCwd: cwd,
           });
           try {
             existingProc.kill();
           } catch {}
-          this.procs.delete(workspaceId);
-          this.procCwds.delete(workspaceId);
+          this.procs.delete(taskId);
+          this.procCwds.delete(taskId);
         }
       } catch {
         // Process has exited - clean up
-        this.procs.delete(workspaceId);
-        this.procCwds.delete(workspaceId);
+        this.procs.delete(taskId);
+        this.procCwds.delete(taskId);
       }
     }
 
@@ -187,7 +187,7 @@ class HostPreviewService extends EventEmitter {
             const linkType = process.platform === 'win32' ? 'junction' : 'dir';
             fs.symlinkSync(parentNm, wsNm, linkType as any);
             log.info?.('[hostPreview] linked node_modules', {
-              workspaceId,
+              taskId,
               wsNm,
               parentNm,
               linkType,
@@ -235,12 +235,12 @@ class HostPreviewService extends EventEmitter {
           shell: true,
           env: { ...process.env, BROWSER: 'none' },
         });
-        this.emit('event', { type: 'setup', workspaceId, status: 'starting' } as HostPreviewEvent);
+        this.emit('event', { type: 'setup', taskId, status: 'starting' } as HostPreviewEvent);
         const onData = (buf: Buffer) => {
           try {
             this.emit('event', {
               type: 'setup',
-              workspaceId,
+              taskId,
               status: 'line',
               line: buf.toString(),
             } as HostPreviewEvent);
@@ -254,7 +254,7 @@ class HostPreviewService extends EventEmitter {
           });
           inst.on('error', reject);
         });
-        this.emit('event', { type: 'setup', workspaceId, status: 'done' } as HostPreviewEvent);
+        this.emit('event', { type: 'setup', taskId, status: 'done' } as HostPreviewEvent);
       }
     } catch {}
 
@@ -290,7 +290,7 @@ class HostPreviewService extends EventEmitter {
         else args.push(...extra);
       }
       log.info?.('[hostPreview] start', {
-        workspaceId,
+        taskId,
         cwd,
         pm,
         cmd,
@@ -300,7 +300,7 @@ class HostPreviewService extends EventEmitter {
       });
     } catch {
       log.info?.('[hostPreview] start', {
-        workspaceId,
+        taskId,
         cwd,
         pm,
         cmd,
@@ -313,8 +313,8 @@ class HostPreviewService extends EventEmitter {
     const tryStart = async (maxRetries = 3): Promise<{ ok: boolean; error?: string }> => {
       try {
         const child = spawn(cmd, args, { cwd, env, shell: true });
-        this.procs.set(workspaceId, child);
-        this.procCwds.set(workspaceId, cwd); // Store the cwd for this process
+        this.procs.set(taskId, child);
+        this.procCwds.set(taskId, cwd); // Store the cwd for this process
 
         let urlEmitted = false;
         let sawAddrInUse = false;
@@ -325,7 +325,7 @@ class HostPreviewService extends EventEmitter {
           try {
             this.emit('event', {
               type: 'setup',
-              workspaceId,
+              taskId,
               status: 'line',
               line,
             } as HostPreviewEvent);
@@ -351,7 +351,7 @@ class HostPreviewService extends EventEmitter {
                 try {
                   this.emit('event', {
                     type: 'url',
-                    workspaceId,
+                    taskId,
                     url: urlToProbe,
                   } as HostPreviewEvent);
                 } catch {}
@@ -401,7 +401,7 @@ class HostPreviewService extends EventEmitter {
                 try {
                   this.emit('event', {
                     type: 'url',
-                    workspaceId,
+                    taskId,
                     url: `http://localhost:${Number(env.PORT) || forcedPort}`,
                   } as HostPreviewEvent);
                 } catch {}
@@ -417,8 +417,8 @@ class HostPreviewService extends EventEmitter {
 
         child.on('exit', async () => {
           clearInterval(probeInterval);
-          this.procs.delete(workspaceId);
-          this.procCwds.delete(workspaceId); // Clean up cwd tracking
+          this.procs.delete(taskId);
+          this.procCwds.delete(taskId); // Clean up cwd tracking
           const runtimeMs = Date.now() - startedAt;
           const quickFail = runtimeMs < 4000; // exited very quickly
           if (!urlEmitted && (sawAddrInUse || quickFail) && maxRetries > 0) {
@@ -437,7 +437,7 @@ class HostPreviewService extends EventEmitter {
             else if (pm === 'npm') args.push('--', '-p', String(forcedPort));
             else args.push('-p', String(forcedPort));
             log.info?.('[hostPreview] retry on new port', {
-              workspaceId,
+              taskId,
               port: forcedPort,
               retriesLeft: maxRetries - 1,
             });
@@ -445,7 +445,7 @@ class HostPreviewService extends EventEmitter {
             return;
           }
           try {
-            this.emit('event', { type: 'exit', workspaceId } as HostPreviewEvent);
+            this.emit('event', { type: 'exit', taskId } as HostPreviewEvent);
           } catch {}
         });
         return { ok: true };
@@ -458,14 +458,14 @@ class HostPreviewService extends EventEmitter {
     return await tryStart(3);
   }
 
-  stop(workspaceId: string): { ok: boolean } {
-    const p = this.procs.get(workspaceId);
+  stop(taskId: string): { ok: boolean } {
+    const p = this.procs.get(taskId);
     if (!p) return { ok: true };
     try {
       p.kill();
     } catch {}
-    this.procs.delete(workspaceId);
-    this.procCwds.delete(workspaceId); // Clean up cwd tracking
+    this.procs.delete(taskId);
+    this.procCwds.delete(taskId); // Clean up cwd tracking
     return { ok: true };
   }
 
diff --git a/src/main/services/ptyIpc.ts b/src/main/services/ptyIpc.ts
index 81f237c3..c6c41434 100644
--- a/src/main/services/ptyIpc.ts
+++ b/src/main/services/ptyIpc.ts
@@ -162,25 +162,25 @@ export function registerPtyIpc(): void {
 
 function parseProviderPty(id: string): {
   providerId: ProviderId;
-  workspaceId: string;
+  taskId: string;
 } | null {
-  // Chat terminals are named `${provider}-main-${workspaceId}`
+  // Chat terminals are named `${provider}-main-${taskId}`
   const match = /^([a-z0-9_-]+)-main-(.+)$/.exec(id);
   if (!match) return null;
   const providerId = match[1] as ProviderId;
   if (!PROVIDER_IDS.includes(providerId)) return null;
-  const workspaceId = match[2];
-  return { providerId, workspaceId };
+  const taskId = match[2];
+  return { providerId, taskId };
 }
 
-function providerRunKey(providerId: ProviderId, workspaceId: string) {
-  return `${providerId}:${workspaceId}`;
+function providerRunKey(providerId: ProviderId, taskId: string) {
+  return `${providerId}:${taskId}`;
 }
 
 function maybeMarkProviderStart(id: string) {
   const parsed = parseProviderPty(id);
   if (!parsed) return;
-  const key = providerRunKey(parsed.providerId, parsed.workspaceId);
+  const key = providerRunKey(parsed.providerId, parsed.taskId);
   if (providerPtyTimers.has(key)) return;
   providerPtyTimers.set(key, Date.now());
   telemetry.capture('agent_run_start', { provider: parsed.providerId });
@@ -193,7 +193,7 @@ function maybeMarkProviderFinish(
 ) {
   const parsed = parseProviderPty(id);
   if (!parsed) return;
-  const key = providerRunKey(parsed.providerId, parsed.workspaceId);
+  const key = providerRunKey(parsed.providerId, parsed.taskId);
   const started = providerPtyTimers.get(key);
   providerPtyTimers.delete(key);
 
diff --git a/src/renderer/App.tsx b/src/renderer/App.tsx
index a53ad069..ab0fb7f9 100644
--- a/src/renderer/App.tsx
+++ b/src/renderer/App.tsx
@@ -1173,9 +1173,9 @@ const AppContent: React.FC = () => {
     [activateProjectView, projects]
   );
 
-  const removeWorkspaceFromState = (projectId: string, workspaceId: string, wasActive: boolean) => {
+  const removeWorkspaceFromState = (projectId: string, taskId: string, wasActive: boolean) => {
     const filterWorkspaces = (list?: Task[]) =>
-      (list || []).filter((w) => w.id !== workspaceId);
+      (list || []).filter((w) => w.id !== taskId);
 
     setProjects((prev) =>
       prev.map((project) =>
@@ -1661,7 +1661,7 @@ const AppContent: React.FC = () => {
                   ? getContainerRunState(activeTask.id)?.previewUrl || null
                   : null
               }
-              workspaceId={activeTask?.id || null}
+              taskId={activeTask?.id || null}
               workspacePath={activeTask?.path || null}
               projectPath={selectedProject?.path || null}
               isWorkspaceMultiAgent={Boolean(activeTask?.metadata?.multiAgent?.enabled)}
@@ -1771,7 +1771,7 @@ const AppContent: React.FC = () => {
             />
             <Toaster />
             <BrowserPane
-              workspaceId={activeTask?.id || null}
+              taskId={activeTask?.id || null}
               workspacePath={activeTask?.path || null}
               overlayActive={
                 showSettings || showCommandPalette || showTaskModal || showFirstLaunchModal
diff --git a/src/renderer/components/ActiveRuns.tsx b/src/renderer/components/ActiveRuns.tsx
index d51a69ab..1b40cab7 100644
--- a/src/renderer/components/ActiveRuns.tsx
+++ b/src/renderer/components/ActiveRuns.tsx
@@ -40,13 +40,13 @@ const ActiveRuns: React.FC<Props> = ({ projects, onSelectProject, onSelectTask }
   for (const s of activeRuns) {
     let match: { project: any | null; workspace: any | null } | null = null;
     for (const proj of projects) {
-      const ws = (proj.workspaces || []).find((w: any) => w.id === s.workspaceId) || null;
+      const ws = (proj.workspaces || []).find((w: any) => w.id === s.taskId) || null;
       if (ws) {
         match = { project: proj, workspace: ws };
         break;
       }
     }
-    byId.set(s.workspaceId, match ?? { project: null, workspace: null });
+    byId.set(s.taskId, match ?? { project: null, workspace: null });
   }
 
   return (
@@ -63,10 +63,10 @@ const ActiveRuns: React.FC<Props> = ({ projects, onSelectProject, onSelectTask }
       <SidebarGroupContent>
         <SidebarMenu>
           {activeRuns.map((s) => {
-            const info = byId.get(s.workspaceId);
+            const info = byId.get(s.taskId);
             const project = info?.project || null;
             const ws = info?.workspace || null;
-            const name = ws?.name || s.workspaceId;
+            const name = ws?.name || s.taskId;
             const previewUrl = s.previewUrl;
             const onOpen = () => {
               if (project && ws) {
@@ -75,7 +75,7 @@ const ActiveRuns: React.FC<Props> = ({ projects, onSelectProject, onSelectTask }
               }
             };
             return (
-              <SidebarMenuItem key={`${s.workspaceId}-${s.runId || 'run'}`}>
+              <SidebarMenuItem key={`${s.taskId}-${s.runId || 'run'}`}>
                 <div className="flex items-center justify-between gap-2 rounded-md px-2 py-1.5 hover:bg-black/5 dark:hover:bg-white/5">
                   <button
                     type="button"
@@ -111,7 +111,7 @@ const ActiveRuns: React.FC<Props> = ({ projects, onSelectProject, onSelectTask }
                       onClick={async (e) => {
                         e.stopPropagation();
                         try {
-                          await (window as any).electronAPI.stopContainerRun?.(s.workspaceId);
+                          await (window as any).electronAPI.stopContainerRun?.(s.taskId);
                         } catch {}
                       }}
                     >
diff --git a/src/renderer/components/BrowserPane.tsx b/src/renderer/components/BrowserPane.tsx
index 89256df1..1521a4fb 100644
--- a/src/renderer/components/BrowserPane.tsx
+++ b/src/renderer/components/BrowserPane.tsx
@@ -24,10 +24,10 @@ const DEFAULT_PREVIEW_URLS = [
 ];
 
 const BrowserPane: React.FC<{
-  workspaceId?: string | null;
+  taskId?: string | null;
   workspacePath?: string | null;
   overlayActive?: boolean;
-}> = ({ workspaceId, overlayActive = false }) => {
+}> = ({ taskId, overlayActive = false }) => {
   const {
     isOpen,
     url,
@@ -69,7 +69,7 @@ const BrowserPane: React.FC<{
   const lastWorkspaceUrlRef = React.useRef<string | null>(null);
   React.useEffect(() => {
     const prev = prevWorkspaceIdRef.current;
-    const cur = (workspaceId || '').trim() || null;
+    const cur = (taskId || '').trim() || null;
 
     if (prev && cur && prev !== cur) {
       try {
@@ -97,12 +97,12 @@ const BrowserPane: React.FC<{
     }
 
     prevWorkspaceIdRef.current = cur;
-  }, [workspaceId, clearUrl, hideSpinner]);
+  }, [taskId, clearUrl, hideSpinner]);
 
   React.useEffect(() => {
     const off = (window as any).electronAPI?.onHostPreviewEvent?.((data: any) => {
       try {
-        if (!data || !workspaceId || data.workspaceId !== workspaceId) return;
+        if (!data || !taskId || data.taskId !== taskId) return;
         if (data.type === 'setup') {
           if (data.status === 'line' && data.line) {
             setLines((prev) => {
@@ -115,9 +115,9 @@ const BrowserPane: React.FC<{
           }
         }
         if (data.type === 'url' && data.url) {
-          // CRITICAL: Only process URL events for the current workspaceId
+          // CRITICAL: Only process URL events for the current taskId
           // This ensures we don't load URLs from other worktrees
-          if (!workspaceId || data.workspaceId !== workspaceId) {
+          if (!taskId || data.taskId !== taskId) {
             return;
           }
           setFailed(false);
@@ -126,12 +126,12 @@ const BrowserPane: React.FC<{
           showSpinner();
           navigate(String(data.url));
           try {
-            setLastUrl(String(workspaceId), String(data.url));
+            setLastUrl(String(taskId), String(data.url));
           } catch {}
         }
         if (data.type === 'exit') {
           try {
-            setRunning(String(workspaceId), false);
+            setRunning(String(taskId), false);
           } catch {}
           hideSpinner();
         }
@@ -142,7 +142,7 @@ const BrowserPane: React.FC<{
         off?.();
       } catch {}
     };
-  }, [workspaceId, navigate, showSpinner, hideSpinner]);
+  }, [taskId, navigate, showSpinner, hideSpinner]);
 
   // Verify URL reachability with TCP probe (30s grace window for slow compilers)
   React.useEffect(() => {
@@ -243,7 +243,7 @@ const BrowserPane: React.FC<{
       visibilityTimeoutRef.current = null;
     }
 
-    const shouldShow = isOpen && !overlayActive && !overlayRaised && !!url && !!workspaceId;
+    const shouldShow = isOpen && !overlayActive && !overlayRaised && !!url && !!taskId;
 
     if (!shouldShow) {
       visibilityTimeoutRef.current = setTimeout(() => {
@@ -308,7 +308,7 @@ const BrowserPane: React.FC<{
         resizeObserver?.disconnect?.();
       } catch {}
     };
-  }, [isOpen, url, computeBounds, overlayActive, overlayRaised, hasBoundsChanged, workspaceId]);
+  }, [isOpen, url, computeBounds, overlayActive, overlayRaised, hasBoundsChanged, taskId]);
 
   React.useEffect(() => {
     if (isOpen && !url) setAddress('');
@@ -317,14 +317,14 @@ const BrowserPane: React.FC<{
   const lastUrlRef = React.useRef<string | null>(null);
   const lastWorkspaceIdRef = React.useRef<string | null | undefined>(null);
   React.useEffect(() => {
-    if (workspaceId !== lastWorkspaceIdRef.current) {
+    if (taskId !== lastWorkspaceIdRef.current) {
       lastUrlRef.current = null;
-      lastWorkspaceIdRef.current = workspaceId || null;
+      lastWorkspaceIdRef.current = taskId || null;
       lastWorkspaceUrlRef.current = null;
     }
 
-    if (isOpen && url && !overlayActive && !overlayRaised && workspaceId) {
-      const workspaceUrlKey = `${workspaceId}:${url}`;
+    if (isOpen && url && !overlayActive && !overlayRaised && taskId) {
+      const workspaceUrlKey = `${taskId}:${url}`;
       // Force reload if workspace changed or URL changed
       const isWorkspaceChange = lastWorkspaceUrlRef.current === null;
       if (lastWorkspaceUrlRef.current !== workspaceUrlKey || lastUrlRef.current !== url) {
@@ -344,7 +344,7 @@ const BrowserPane: React.FC<{
         return () => clearTimeout(timeoutId);
       }
     }
-  }, [isOpen, url, overlayActive, overlayRaised, workspaceId]);
+  }, [isOpen, url, overlayActive, overlayRaised, taskId]);
 
   React.useEffect(() => {
     let dragging = false;
@@ -418,7 +418,7 @@ const BrowserPane: React.FC<{
       captureTelemetry('browser_preview_closed');
     });
     try {
-      const id = (workspaceId || '').trim();
+      const id = (taskId || '').trim();
       if (id) (window as any).electronAPI?.hostPreviewStop?.(id);
     } catch {}
     try {
@@ -429,7 +429,7 @@ const BrowserPane: React.FC<{
     } catch {}
     setFailed(false);
     close();
-  }, [workspaceId, clearUrl, close]);
+  }, [taskId, clearUrl, close]);
 
   return (
     <div
diff --git a/src/renderer/components/ChatInterface.tsx b/src/renderer/components/ChatInterface.tsx
index e56f3898..3bc85d53 100644
--- a/src/renderer/components/ChatInterface.tsx
+++ b/src/renderer/components/ChatInterface.tsx
@@ -73,14 +73,14 @@ const ChatInterface: React.FC<Props> = ({
 
   // Log transitions for visibility
   useEffect(() => {
-    log.info('[plan] state changed', { workspaceId: task.id, enabled: planEnabled });
+    log.info('[plan] state changed', { taskId: task.id, enabled: planEnabled });
   }, [planEnabled, task.id]);
 
   // For terminal providers with native plan activation commands
   usePlanActivationTerminal({
     enabled: planEnabled,
     providerId: provider,
-    workspaceId: task.id,
+    taskId: task.id,
     workspacePath: task.path,
   });
 
@@ -447,7 +447,7 @@ const ChatInterface: React.FC<Props> = ({
   // Only use keystroke injection for providers WITHOUT CLI flag support
   // Providers with initialPromptFlag use CLI arg injection via TerminalPane instead
   useInitialPromptInjection({
-    workspaceId: task.id,
+    taskId: task.id,
     providerId: provider,
     prompt: initialInjection,
     enabled: isTerminal && providerMeta[provider]?.initialPromptFlag === undefined,
@@ -759,7 +759,7 @@ const ChatInterface: React.FC<Props> = ({
 
       <ProviderBar
         provider={provider}
-        workspaceId={task.id}
+        taskId={task.id}
         linearIssue={task.metadata?.linearIssue || null}
         githubIssue={task.metadata?.githubIssue || null}
         jiraIssue={task.metadata?.jiraIssue || null}
diff --git a/src/renderer/components/CommandPalette.tsx b/src/renderer/components/CommandPalette.tsx
index 46ed6aad..aacb0b1a 100644
--- a/src/renderer/components/CommandPalette.tsx
+++ b/src/renderer/components/CommandPalette.tsx
@@ -33,7 +33,7 @@ interface CommandPaletteProps {
     }>;
   }>;
   onSelectProject?: (projectId: string) => void;
-  onSelectWorkspace?: (projectId: string, workspaceId: string) => void;
+  onSelectWorkspace?: (projectId: string, taskId: string) => void;
   onOpenSettings?: () => void;
   onToggleLeftSidebar?: () => void;
   onToggleRightSidebar?: () => void;
diff --git a/src/renderer/components/CommandPaletteWrapper.tsx b/src/renderer/components/CommandPaletteWrapper.tsx
index 02401d74..24746584 100644
--- a/src/renderer/components/CommandPaletteWrapper.tsx
+++ b/src/renderer/components/CommandPaletteWrapper.tsx
@@ -39,9 +39,9 @@ const CommandPaletteWrapper: React.FC<CommandPaletteWrapperProps> = ({
         const project = projects.find((p) => p.id === projectId);
         if (project) handleSelectProject(project);
       }}
-      onSelectWorkspace={(projectId, workspaceId) => {
+      onSelectWorkspace={(projectId, taskId) => {
         const project = projects.find((p) => p.id === projectId);
-        const workspace = project?.workspaces?.find((w: Task) => w.id === workspaceId);
+        const workspace = project?.workspaces?.find((w: Task) => w.id === taskId);
         if (project && workspace) {
           handleSelectProject(project);
           handleSelectWorkspace(workspace);
diff --git a/src/renderer/components/FileChangesPanel.tsx b/src/renderer/components/FileChangesPanel.tsx
index a27579af..053e2fec 100644
--- a/src/renderer/components/FileChangesPanel.tsx
+++ b/src/renderer/components/FileChangesPanel.tsx
@@ -12,11 +12,11 @@ import FileTypeIcon from './ui/file-type-icon';
 import { Plus, Undo2, ArrowUpRight } from 'lucide-react';
 
 interface FileChangesPanelProps {
-  workspaceId: string;
+  taskId: string;
   className?: string;
 }
 
-const FileChangesPanelComponent: React.FC<FileChangesPanelProps> = ({ workspaceId, className }) => {
+const FileChangesPanelComponent: React.FC<FileChangesPanelProps> = ({ taskId, className }) => {
   const [showDiffModal, setShowDiffModal] = useState(false);
   const [selectedPath, setSelectedPath] = useState<string | undefined>(undefined);
   const [stagingFiles, setStagingFiles] = useState<Set<string>>(new Set());
@@ -24,24 +24,24 @@ const FileChangesPanelComponent: React.FC<FileChangesPanelProps> = ({ workspaceI
   const [commitMessage, setCommitMessage] = useState('');
   const [isCommitting, setIsCommitting] = useState(false);
   const { isCreating: isCreatingPR, createPR } = useCreatePR();
-  const { fileChanges, refreshChanges } = useFileChanges(workspaceId);
+  const { fileChanges, refreshChanges } = useFileChanges(taskId);
   const { toast } = useToast();
   const hasChanges = fileChanges.length > 0;
   const hasStagedChanges = fileChanges.some((change) => change.isStaged);
-  const { pr, loading: prLoading, refresh: refreshPr } = usePrStatus(workspaceId);
+  const { pr, loading: prLoading, refresh: refreshPr } = usePrStatus(taskId);
   const [branchAhead, setBranchAhead] = useState<number | null>(null);
   const [branchStatusLoading, setBranchStatusLoading] = useState<boolean>(false);
 
   useEffect(() => {
     let cancelled = false;
     const load = async () => {
-      if (!workspaceId || hasChanges) {
+      if (!taskId || hasChanges) {
         setBranchAhead(null);
         return;
       }
       setBranchStatusLoading(true);
       try {
-        const res = await window.electronAPI.getBranchStatus({ workspacePath: workspaceId });
+        const res = await window.electronAPI.getBranchStatus({ workspacePath: taskId });
         if (!cancelled) {
           setBranchAhead(res?.success ? (res?.ahead ?? 0) : 0);
         }
@@ -56,7 +56,7 @@ const FileChangesPanelComponent: React.FC<FileChangesPanelProps> = ({ workspaceI
       cancelled = true;
     };
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [workspaceId, hasChanges]);
+  }, [taskId, hasChanges]);
 
   const handleStageFile = async (filePath: string, event: React.MouseEvent) => {
     event.stopPropagation(); // Prevent opening diff modal
@@ -64,7 +64,7 @@ const FileChangesPanelComponent: React.FC<FileChangesPanelProps> = ({ workspaceI
 
     try {
       const result = await window.electronAPI.stageFile({
-        workspacePath: workspaceId,
+        workspacePath: taskId,
         filePath,
       });
 
@@ -98,7 +98,7 @@ const FileChangesPanelComponent: React.FC<FileChangesPanelProps> = ({ workspaceI
 
     try {
       const result = await window.electronAPI.revertFile({
-        workspacePath: workspaceId,
+        workspacePath: taskId,
         filePath,
       });
 
@@ -155,7 +155,7 @@ const FileChangesPanelComponent: React.FC<FileChangesPanelProps> = ({ workspaceI
     setIsCommitting(true);
     try {
       const result = await window.electronAPI.gitCommitAndPush({
-        workspacePath: workspaceId,
+        workspacePath: taskId,
         commitMessage: commitMessage.trim(),
         createBranchIfOnDefault: true,
         branchPrefix: 'feature',
@@ -174,7 +174,7 @@ const FileChangesPanelComponent: React.FC<FileChangesPanelProps> = ({ workspaceI
         // Proactively load branch status so the Create PR button appears immediately
         try {
           setBranchStatusLoading(true);
-          const bs = await window.electronAPI.getBranchStatus({ workspacePath: workspaceId });
+          const bs = await window.electronAPI.getBranchStatus({ workspacePath: taskId });
           setBranchAhead(bs?.success ? (bs?.ahead ?? 0) : 0);
         } catch {
           setBranchAhead(0);
@@ -252,7 +252,7 @@ const FileChangesPanelComponent: React.FC<FileChangesPanelProps> = ({ workspaceI
                 title="Commit all changes and create a pull request"
                 onClick={async () => {
                   await createPR({
-                    workspacePath: workspaceId,
+                    workspacePath: taskId,
                     onSuccess: async () => {
                       await refreshChanges();
                       try {
@@ -331,7 +331,7 @@ const FileChangesPanelComponent: React.FC<FileChangesPanelProps> = ({ workspaceI
                   title="Create a pull request for the current branch"
                   onClick={async () => {
                     await createPR({
-                      workspacePath: workspaceId,
+                      workspacePath: taskId,
                       onSuccess: async () => {
                         await refreshChanges();
                         try {
@@ -434,7 +434,7 @@ const FileChangesPanelComponent: React.FC<FileChangesPanelProps> = ({ workspaceI
         <ChangesDiffModal
           open={showDiffModal}
           onClose={() => setShowDiffModal(false)}
-          workspacePath={workspaceId}
+          workspacePath={taskId}
           files={fileChanges}
           initialFile={selectedPath}
           onRefreshChanges={refreshChanges}
diff --git a/src/renderer/components/ProjectMainView.tsx b/src/renderer/components/ProjectMainView.tsx
index 0125103d..14c1f731 100644
--- a/src/renderer/components/ProjectMainView.tsx
+++ b/src/renderer/components/ProjectMainView.tsx
@@ -147,7 +147,7 @@ function WorkspaceRow({
     try {
       setIsStartingContainer(true);
       const res = await startContainerRun({
-        workspaceId: ws.id,
+        taskId: ws.id,
         workspacePath: ws.path,
         mode: 'container',
       });
@@ -351,7 +351,7 @@ function WorkspaceRow({
           ) : (
             <WorkspaceDeleteButton
               workspaceName={ws.name}
-              workspaceId={ws.id}
+              taskId={ws.id}
               workspacePath={ws.path}
               onConfirm={async () => {
                 try {
@@ -373,7 +373,7 @@ function WorkspaceRow({
         {containerActive && expanded ? (
           <WorkspacePorts
             key={`ports-${ws.id}`}
-            workspaceId={ws.id}
+            taskId={ws.id}
             workspacePath={ws.path}
             ports={ports}
             previewUrl={previewUrl}
diff --git a/src/renderer/components/ProviderBar.tsx b/src/renderer/components/ProviderBar.tsx
index 45099e64..ca2e33ca 100644
--- a/src/renderer/components/ProviderBar.tsx
+++ b/src/renderer/components/ProviderBar.tsx
@@ -36,7 +36,7 @@ import { getContext7InvocationForProvider } from '../mcp/context7';
 
 type Props = {
   provider: Provider;
-  workspaceId: string;
+  taskId: string;
   linearIssue?: LinearIssueSummary | null;
   githubIssue?: GitHubIssueSummary | null;
   jiraIssue?: JiraIssueSummary | null;
@@ -48,7 +48,7 @@ type Props = {
 
 export const ProviderBar: React.FC<Props> = ({
   provider,
-  workspaceId,
+  taskId,
   linearIssue,
   githubIssue,
   jiraIssue,
@@ -79,12 +79,12 @@ export const ProviderBar: React.FC<Props> = ({
   // Per-workspace default OFF
   React.useEffect(() => {
     try {
-      const key = `c7:ws:${workspaceId}`;
+      const key = `c7:ws:${taskId}`;
       setC7WorkspaceEnabled(localStorage.getItem(key) === '1');
     } catch {
       setC7WorkspaceEnabled(false);
     }
-  }, [workspaceId]);
+  }, [taskId]);
 
   const handleContext7Click = async () => {
     setC7Busy(true);
@@ -94,18 +94,18 @@ export const ProviderBar: React.FC<Props> = ({
       if (!c7WorkspaceEnabled) {
         // Enable for this workspace and send invocation once
         try {
-          localStorage.setItem(`c7:ws:${workspaceId}`, '1');
+          localStorage.setItem(`c7:ws:${taskId}`, '1');
         } catch {}
         setC7WorkspaceEnabled(true);
 
         const isTerminal = providerMeta[provider]?.terminalOnly === true;
         if (!isTerminal) return;
         const phrase = getContext7InvocationForProvider(provider) || 'use context7';
-        const ptyId = `${provider}-main-${workspaceId}`;
+        const ptyId = `${provider}-main-${taskId}`;
         (window as any).electronAPI?.ptyInput?.({ id: ptyId, data: `${phrase}\n` });
       } else {
         try {
-          localStorage.removeItem(`c7:ws:${workspaceId}`);
+          localStorage.removeItem(`c7:ws:${taskId}`);
         } catch {}
         setC7WorkspaceEnabled(false);
       }
diff --git a/src/renderer/components/RightSidebar.tsx b/src/renderer/components/RightSidebar.tsx
index e2f4e5f3..307acc14 100644
--- a/src/renderer/components/RightSidebar.tsx
+++ b/src/renderer/components/RightSidebar.tsx
@@ -138,7 +138,7 @@ const RightSidebar: React.FC<RightSidebarProps> = ({ task, className, ...rest })
             ) : (
               <>
                 <FileChangesPanel
-                  workspaceId={task.path}
+                  taskId={task.path}
                   className="min-h-0 flex-1 border-b border-border"
                 />
                 <TaskTerminalPanel
@@ -186,5 +186,5 @@ const VariantChangesIfAny: React.FC<{ path: string; className?: string }> = ({
 }) => {
   const { fileChanges } = useFileChanges(path);
   if (!fileChanges || fileChanges.length === 0) return null;
-  return <FileChangesPanel workspaceId={path} className={className || 'min-h-0'} />;
+  return <FileChangesPanel taskId={path} className={className || 'min-h-0'} />;
 };
diff --git a/src/renderer/components/TaskDeleteButton.tsx b/src/renderer/components/TaskDeleteButton.tsx
index c6c026de..bde5e371 100644
--- a/src/renderer/components/TaskDeleteButton.tsx
+++ b/src/renderer/components/TaskDeleteButton.tsx
@@ -20,7 +20,7 @@ import DeletePrNotice from './DeletePrNotice';
 
 type Props = {
   workspaceName: string;
-  workspaceId: string;
+  taskId: string;
   workspacePath: string;
   onConfirm: () => void | Promise<void | boolean>;
   className?: string;
@@ -30,7 +30,7 @@ type Props = {
 
 export const WorkspaceDeleteButton: React.FC<Props> = ({
   workspaceName,
-  workspaceId,
+  taskId,
   workspacePath,
   onConfirm,
   className,
@@ -40,11 +40,11 @@ export const WorkspaceDeleteButton: React.FC<Props> = ({
   const [open, setOpen] = React.useState(false);
   const [acknowledge, setAcknowledge] = React.useState(false);
   const targets = useMemo(
-    () => [{ id: workspaceId, name: workspaceName, path: workspacePath }],
-    [workspaceId, workspaceName, workspacePath]
+    () => [{ id: taskId, name: workspaceName, path: workspacePath }],
+    [taskId, workspaceName, workspacePath]
   );
   const { risks, loading, hasData } = useDeleteRisks(targets, open);
-  const status = risks[workspaceId] || {
+  const status = risks[taskId] || {
     staged: 0,
     unstaged: 0,
     untracked: 0,
diff --git a/src/renderer/components/TaskItem.tsx b/src/renderer/components/TaskItem.tsx
index eeeb65cd..7cf4d1db 100644
--- a/src/renderer/components/TaskItem.tsx
+++ b/src/renderer/components/TaskItem.tsx
@@ -51,7 +51,7 @@ export const TaskItem: React.FC<TaskItemProps> = ({
         {showDelete && onDelete ? (
           <TaskDeleteButton
             workspaceName={task.name}
-            workspaceId={task.id}
+            taskId={task.id}
             workspacePath={task.path}
             onConfirm={async () => {
               try {
diff --git a/src/renderer/components/TaskPorts.tsx b/src/renderer/components/TaskPorts.tsx
index 7ad399a0..b7df210a 100644
--- a/src/renderer/components/TaskPorts.tsx
+++ b/src/renderer/components/TaskPorts.tsx
@@ -6,7 +6,7 @@ import { useToast } from '@/hooks/use-toast';
 import { useBrowser } from '@/providers/BrowserProvider';
 
 interface Props {
-  workspaceId: string;
+  taskId: string;
   workspacePath?: string;
   ports: Array<RunnerPortMapping & { url?: string }>;
   previewUrl?: string;
@@ -14,7 +14,7 @@ interface Props {
 }
 
 const WorkspacePorts: React.FC<Props> = ({
-  workspaceId,
+  taskId,
   workspacePath,
   ports,
   previewUrl,
@@ -115,7 +115,7 @@ const WorkspacePorts: React.FC<Props> = ({
 
   return (
     <motion.div
-      id={`ws-${workspaceId}-ports`}
+      id={`ws-${taskId}-ports`}
       className="border-t border-border/60 bg-muted/30 px-4 py-2"
       initial={reduceMotion ? false : { opacity: 0, height: 0 }}
       animate={{ opacity: 1, height: 'auto' }}
@@ -164,7 +164,7 @@ const WorkspacePorts: React.FC<Props> = ({
       {sorted?.length ? (
         <div className="flex flex-wrap gap-2 pt-2">
           {sorted.map((p) => {
-            const key = `${workspaceId}-${p.service}-${p.host}`;
+            const key = `${taskId}-${p.service}-${p.host}`;
             const url = p.url ?? `http://localhost:${p.host}`;
             const isPreview = p.service === previewService;
             return (
diff --git a/src/renderer/components/TerminalPane.tsx b/src/renderer/components/TerminalPane.tsx
index ab5572b4..2db0cb6a 100644
--- a/src/renderer/components/TerminalPane.tsx
+++ b/src/renderer/components/TerminalPane.tsx
@@ -59,7 +59,7 @@ const TerminalPaneComponent: React.FC<Props> = ({
     if (!container) return;
 
     const session = terminalSessionRegistry.attach({
-      workspaceId: id,
+      taskId: id,
       container,
       cwd,
       shell,
diff --git a/src/renderer/components/kanban/KanbanBoard.tsx b/src/renderer/components/kanban/KanbanBoard.tsx
index 38dfb8fd..c1394b93 100644
--- a/src/renderer/components/kanban/KanbanBoard.tsx
+++ b/src/renderer/components/kanban/KanbanBoard.tsx
@@ -267,9 +267,9 @@ const KanbanBoard: React.FC<{
   }
   const hasAny = (project.workspaces?.length ?? 0) > 0;
 
-  const handleDrop = (target: KanbanStatus, workspaceId: string) => {
-    setStatus(workspaceId, target);
-    setStatusMap({ ...statusMap, [workspaceId]: target });
+  const handleDrop = (target: KanbanStatus, taskId: string) => {
+    setStatus(taskId, target);
+    setStatusMap({ ...statusMap, [taskId]: target });
   };
 
   return (
diff --git a/src/renderer/components/kanban/KanbanCard.tsx b/src/renderer/components/kanban/KanbanCard.tsx
index 758e782d..6223b377 100644
--- a/src/renderer/components/kanban/KanbanCard.tsx
+++ b/src/renderer/components/kanban/KanbanCard.tsx
@@ -6,9 +6,9 @@ import { activityStore } from '../../lib/activityStore';
 import ProviderTooltip from './ProviderTooltip';
 import { Spinner } from '../ui/spinner';
 
-function resolveProvider(workspaceId: string): UiProvider | null {
+function resolveProvider(taskId: string): UiProvider | null {
   try {
-    const v = localStorage.getItem(`workspaceProvider:${workspaceId}`);
+    const v = localStorage.getItem(`workspaceProvider:${taskId}`);
     if (!v) return null;
     const id = v.trim() as UiProvider;
     return id in providerAssets ? id : null;
diff --git a/src/renderer/components/kanban/KanbanColumn.tsx b/src/renderer/components/kanban/KanbanColumn.tsx
index 58227670..13acc45a 100644
--- a/src/renderer/components/kanban/KanbanColumn.tsx
+++ b/src/renderer/components/kanban/KanbanColumn.tsx
@@ -3,7 +3,7 @@ import React from 'react';
 const KanbanColumn: React.FC<{
   title: string;
   count: number;
-  onDropCard: (workspaceId: string) => void;
+  onDropCard: (taskId: string) => void;
   children: React.ReactNode;
   action?: React.ReactNode;
 }> = ({ title, count, onDropCard, children, action }) => {
diff --git a/src/renderer/components/titlebar/BrowserToggleButton.tsx b/src/renderer/components/titlebar/BrowserToggleButton.tsx
index fa53356f..357fae13 100644
--- a/src/renderer/components/titlebar/BrowserToggleButton.tsx
+++ b/src/renderer/components/titlebar/BrowserToggleButton.tsx
@@ -15,13 +15,13 @@ import { isReachable, isAppPort, FALLBACK_DELAY_MS, SPINNER_MAX_MS } from '@/lib
 
 interface Props {
   defaultUrl?: string;
-  workspaceId?: string | null;
+  taskId?: string | null;
   workspacePath?: string | null;
   parentProjectPath?: string | null;
 }
 
 const BrowserToggleButton: React.FC<Props> = ({
-  workspaceId,
+  taskId,
   workspacePath,
   parentProjectPath,
 }) => {
@@ -50,28 +50,28 @@ const BrowserToggleButton: React.FC<Props> = ({
   useEffect(() => {
     const off = (window as any).electronAPI?.onHostPreviewEvent?.((data: any) => {
       try {
-        if (data?.type === 'url' && data?.workspaceId && data?.url) {
-          if (workspaceId && data.workspaceId !== workspaceId) return;
+        if (data?.type === 'url' && data?.taskId && data?.url) {
+          if (taskId && data.taskId !== taskId) return;
           const appPort = Number(window.location.port || 0);
           if (isAppPort(String(data.url), appPort)) return;
           browser.open(String(data.url));
           try {
-            if (workspaceId) {
-              setLastUrl(workspaceId, String(data.url));
-              setRunning(workspaceId, true);
+            if (taskId) {
+              setLastUrl(taskId, String(data.url));
+              setRunning(taskId, true);
             }
           } catch {}
         }
-        if (data?.type === 'setup' && data?.workspaceId && data?.status === 'done') {
-          if (workspaceId && data.workspaceId !== workspaceId) return;
+        if (data?.type === 'setup' && data?.taskId && data?.status === 'done') {
+          if (taskId && data.taskId !== taskId) return;
           try {
-            if (workspaceId) setInstalled(workspaceId, true);
+            if (taskId) setInstalled(taskId, true);
           } catch {}
         }
-        if (data?.type === 'exit' && data?.workspaceId) {
-          if (workspaceId && data.workspaceId !== workspaceId) return;
+        if (data?.type === 'exit' && data?.taskId) {
+          if (taskId && data.taskId !== taskId) return;
           try {
-            if (workspaceId) setRunning(workspaceId, false);
+            if (taskId) setRunning(taskId, false);
           } catch {}
         }
       } catch {}
@@ -81,10 +81,10 @@ const BrowserToggleButton: React.FC<Props> = ({
         off?.();
       } catch {}
     };
-  }, [browser, workspaceId]);
+  }, [browser, taskId]);
 
   const handleClick = React.useCallback(async () => {
-    const id = (workspaceId || '').trim();
+    const id = (taskId || '').trim();
     const wp = (workspacePath || '').trim();
     const appPort = Number(window.location.port || 0);
     // Open pane immediately with no URL; we will navigate when ready
@@ -120,7 +120,7 @@ const BrowserToggleButton: React.FC<Props> = ({
         // If install needed, run setup first (only when sentinel not present)
         if (!installed && (await needsInstall(wp))) {
           await (window as any).electronAPI?.hostPreviewSetup?.({
-            workspaceId: id,
+            taskId: id,
             workspacePath: wp,
           });
           setInstalled(id, true);
@@ -128,7 +128,7 @@ const BrowserToggleButton: React.FC<Props> = ({
         const running = isRunning(id);
         if (!running) {
           await (window as any).electronAPI?.hostPreviewStart?.({
-            workspaceId: id,
+            taskId: id,
             workspacePath: wp,
             parentProjectPath: (parentProjectPath || '').trim(),
           });
@@ -153,7 +153,7 @@ const BrowserToggleButton: React.FC<Props> = ({
     }
     // Fallback: clear spinner after a grace period if nothing arrives
     setTimeout(() => browser.hideSpinner(), SPINNER_MAX_MS);
-  }, [browser, workspaceId, workspacePath, parentProjectPath]);
+  }, [browser, taskId, workspacePath, parentProjectPath]);
 
   return (
     <TooltipProvider delayDuration={200}>
diff --git a/src/renderer/components/titlebar/Titlebar.tsx b/src/renderer/components/titlebar/Titlebar.tsx
index 342f5e37..dc2a770f 100644
--- a/src/renderer/components/titlebar/Titlebar.tsx
+++ b/src/renderer/components/titlebar/Titlebar.tsx
@@ -21,7 +21,7 @@ interface TitlebarProps {
   currentPath?: string | null;
   githubUser?: GithubUser | null;
   defaultPreviewUrl?: string | null;
-  workspaceId?: string | null;
+  taskId?: string | null;
   workspacePath?: string | null;
   projectPath?: string | null;
   isWorkspaceMultiAgent?: boolean;
@@ -36,7 +36,7 @@ const Titlebar: React.FC<TitlebarProps> = ({
   currentPath,
   githubUser,
   defaultPreviewUrl,
-  workspaceId,
+  taskId,
   workspacePath,
   projectPath,
   isWorkspaceMultiAgent,
@@ -139,10 +139,10 @@ const Titlebar: React.FC<TitlebarProps> = ({
               </Tooltip>
             </TooltipProvider>
           ) : null}
-          {workspaceId && !isWorkspaceMultiAgent ? (
+          {taskId && !isWorkspaceMultiAgent ? (
             <BrowserToggleButton
               defaultUrl={defaultPreviewUrl || undefined}
-              workspaceId={workspaceId}
+              taskId={taskId}
               workspacePath={workspacePath}
               parentProjectPath={projectPath}
             />
diff --git a/src/renderer/hooks/useInitialPromptInjection.ts b/src/renderer/hooks/useInitialPromptInjection.ts
index 21d7b0bc..5705571d 100644
--- a/src/renderer/hooks/useInitialPromptInjection.ts
+++ b/src/renderer/hooks/useInitialPromptInjection.ts
@@ -7,21 +7,21 @@ import { classifyActivity } from '../lib/activityClassifier';
  * One-shot per workspace. Provider-agnostic.
  */
 export function useInitialPromptInjection(opts: {
-  workspaceId: string;
+  taskId: string;
   providerId: string; // codex | claude | ... used for PTY id prefix
   prompt?: string | null;
   enabled?: boolean;
 }) {
-  const { workspaceId, providerId, prompt, enabled = true } = opts;
+  const { taskId, providerId, prompt, enabled = true } = opts;
 
   useEffect(() => {
     if (!enabled) return;
     const trimmed = (prompt || '').trim();
     if (!trimmed) return;
-    const sentKey = initialPromptSentKey(workspaceId, providerId);
+    const sentKey = initialPromptSentKey(taskId, providerId);
     if (localStorage.getItem(sentKey) === '1') return;
 
-    const ptyId = `${providerId}-main-${workspaceId}`;
+    const ptyId = `${providerId}-main-${taskId}`;
     let sent = false;
     let idleSeen = false;
     let silenceTimer: any = null;
@@ -71,5 +71,5 @@ export function useInitialPromptInjection(opts: {
       offStarted?.();
       offData?.();
     };
-  }, [enabled, workspaceId, providerId, prompt]);
+  }, [enabled, taskId, providerId, prompt]);
 }
diff --git a/src/renderer/hooks/usePlanActivation.ts b/src/renderer/hooks/usePlanActivation.ts
index a8997b2d..a2e322c4 100644
--- a/src/renderer/hooks/usePlanActivation.ts
+++ b/src/renderer/hooks/usePlanActivation.ts
@@ -10,10 +10,10 @@ import { logPlanEvent } from '@/lib/planLogs';
 export function usePlanActivationTerminal(opts: {
   enabled: boolean;
   providerId: string;
-  workspaceId: string;
+  taskId: string;
   workspacePath: string;
 }) {
-  const { enabled, providerId, workspaceId, workspacePath } = opts;
+  const { enabled, providerId, taskId, workspacePath } = opts;
 
   useEffect(() => {
     if (!enabled) return;
@@ -22,7 +22,7 @@ export function usePlanActivationTerminal(opts: {
     const cmd = meta.planActivate;
     if (!cmd) return;
 
-    const ptyId = `${providerId}-main-${workspaceId}`;
+    const ptyId = `${providerId}-main-${taskId}`;
     const onceKey = `plan:activated:${ptyId}`;
     try {
       if (localStorage.getItem(onceKey) === '1') return;
@@ -53,5 +53,5 @@ export function usePlanActivationTerminal(opts: {
       } catch {}
       clearTimeout(t);
     };
-  }, [enabled, providerId, workspaceId]);
+  }, [enabled, providerId, taskId]);
 }
diff --git a/src/renderer/hooks/usePlanMode.ts b/src/renderer/hooks/usePlanMode.ts
index 742abdf4..1aaa1b37 100644
--- a/src/renderer/hooks/usePlanMode.ts
+++ b/src/renderer/hooks/usePlanMode.ts
@@ -3,8 +3,8 @@ import { PLANNING_MD } from '@/lib/planRules';
 import { log } from '@/lib/logger';
 import { logPlanEvent } from '@/lib/planLogs';
 
-export function usePlanMode(workspaceId: string, workspacePath: string) {
-  const key = useMemo(() => `planMode:${workspaceId}`, [workspaceId]);
+export function usePlanMode(taskId: string, workspacePath: string) {
+  const key = useMemo(() => `planMode:${taskId}`, [taskId]);
   const [enabled, setEnabled] = useState<boolean>(() => {
     try {
       return localStorage.getItem(key) === '1';
@@ -169,7 +169,7 @@ export function usePlanMode(workspaceId: string, workspacePath: string) {
   useEffect(() => {
     (async () => {
       if (enabled) {
-        log.info('[plan] enabled', { workspaceId, workspacePath });
+        log.info('[plan] enabled', { taskId, workspacePath });
         await logPlanEvent(workspacePath, 'Plan Mode enabled');
         void (async () => {
           const { captureTelemetry } = await import('../lib/telemetryClient');
@@ -202,7 +202,7 @@ export function usePlanMode(workspaceId: string, workspacePath: string) {
         } catch {}
 
         if (wasActive) {
-          log.info('[plan] disabled', { workspaceId, workspacePath });
+          log.info('[plan] disabled', { taskId, workspacePath });
           await logPlanEvent(workspacePath, 'Plan Mode disabled');
           void (async () => {
             const { captureTelemetry } = await import('../lib/telemetryClient');
@@ -223,7 +223,7 @@ export function usePlanMode(workspaceId: string, workspacePath: string) {
         }
       }
     })();
-  }, [enabled, ensureGitExclude, ensurePlanFile, removePlanFile, workspaceId, workspacePath]);
+  }, [enabled, ensureGitExclude, ensurePlanFile, removePlanFile, taskId, workspacePath]);
 
   const toggle = useCallback(() => setEnabled((v) => !v), []);
 
diff --git a/src/renderer/hooks/useProviderPreference.ts b/src/renderer/hooks/useProviderPreference.ts
index 402bc9cd..cfcab763 100644
--- a/src/renderer/hooks/useProviderPreference.ts
+++ b/src/renderer/hooks/useProviderPreference.ts
@@ -3,7 +3,7 @@ import { useEffect, useState } from 'react';
 export type ProviderId = 'codex' | 'claude';
 
 export function useProviderPreference(
-  workspaceId: string,
+  taskId: string,
   conversationId: string | null,
   initial: ProviderId = 'codex'
 ) {
@@ -15,7 +15,7 @@ export function useProviderPreference(
       setProvider(initial);
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [workspaceId, conversationId]);
+  }, [taskId, conversationId]);
 
   // Restore preferred provider for this conversation/workspace
   useEffect(() => {
@@ -27,20 +27,20 @@ export function useProviderPreference(
         setProvider(saved);
         return;
       }
-      const wkKey = `workspaceProvider:${workspaceId}`;
+      const wkKey = `workspaceProvider:${taskId}`;
       const wkSaved = localStorage.getItem(wkKey) as ProviderId | null;
       if (wkSaved) setProvider(wkSaved);
     } catch {}
-  }, [conversationId, workspaceId]);
+  }, [conversationId, taskId]);
 
   // Persist provider selection per conversation and workspace
   useEffect(() => {
     if (!conversationId) return;
     try {
       localStorage.setItem(`conversationProvider:${conversationId}`, provider);
-      localStorage.setItem(`workspaceProvider:${workspaceId}`, provider);
+      localStorage.setItem(`workspaceProvider:${taskId}`, provider);
     } catch {}
-  }, [provider, conversationId, workspaceId]);
+  }, [provider, conversationId, taskId]);
 
   return { provider, setProvider };
 }
diff --git a/src/renderer/lib/containerRuns.ts b/src/renderer/lib/containerRuns.ts
index 4e20e4b7..38d6ef8f 100644
--- a/src/renderer/lib/containerRuns.ts
+++ b/src/renderer/lib/containerRuns.ts
@@ -15,7 +15,7 @@ type Listener = (event: RunnerEvent) => void;
 type WorkspaceListener = (state: ContainerRunState) => void;
 
 interface StartRunArgs {
-  workspaceId: string;
+  taskId: string;
   workspacePath: string;
   runId?: string;
   mode?: RunnerMode;
@@ -33,11 +33,11 @@ function clean(value: string | undefined | null): string | undefined {
   return trimmed.length ? trimmed : undefined;
 }
 
-function getOrCreateState(workspaceId: string): ContainerRunState {
-  const existing = workspaceStates.get(workspaceId);
+function getOrCreateState(taskId: string): ContainerRunState {
+  const existing = workspaceStates.get(taskId);
   if (existing) return existing;
   const created: ContainerRunState = {
-    workspaceId,
+    taskId,
     runId: undefined,
     status: 'idle',
     containerId: undefined,
@@ -47,7 +47,7 @@ function getOrCreateState(workspaceId: string): ContainerRunState {
     lastUpdatedAt: 0,
     lastError: null,
   };
-  workspaceStates.set(workspaceId, created);
+  workspaceStates.set(taskId, created);
   return created;
 }
 
@@ -57,7 +57,7 @@ function clonePort(port: RunnerPortMapping): RunnerPortMapping & { url: string }
 }
 
 function updateWorkspaceState(event: RunnerEvent) {
-  const state = getOrCreateState(event.workspaceId);
+  const state = getOrCreateState(event.taskId);
   const isNewRun = state.runId && state.runId !== event.runId;
   if (!state.runId || isNewRun) {
     state.runId = event.runId;
@@ -125,9 +125,9 @@ function updateWorkspaceState(event: RunnerEvent) {
       break;
   }
   state.lastUpdatedAt = event.ts;
-  workspaceStates.set(event.workspaceId, { ...state });
+  workspaceStates.set(event.taskId, { ...state });
 
-  const wsListeners = workspaceListeners.get(event.workspaceId);
+  const wsListeners = workspaceListeners.get(event.taskId);
   if (wsListeners) {
     for (const listener of wsListeners) {
       try {
@@ -176,14 +176,14 @@ export function subscribeToContainerRuns(listener: Listener): () => void {
 }
 
 export function subscribeToWorkspaceRunState(
-  workspaceId: string,
+  taskId: string,
   listener: WorkspaceListener
 ): () => void {
   ensureSubscribed();
-  const set = workspaceListeners.get(workspaceId) ?? new Set<WorkspaceListener>();
+  const set = workspaceListeners.get(taskId) ?? new Set<WorkspaceListener>();
   set.add(listener);
-  workspaceListeners.set(workspaceId, set);
-  const current = workspaceStates.get(workspaceId);
+  workspaceListeners.set(taskId, set);
+  const current = workspaceStates.get(taskId);
   if (current) {
     try {
       listener({ ...current });
@@ -193,35 +193,35 @@ export function subscribeToWorkspaceRunState(
   }
 
   return () => {
-    const listenersForWorkspace = workspaceListeners.get(workspaceId);
+    const listenersForWorkspace = workspaceListeners.get(taskId);
     if (!listenersForWorkspace) return;
     listenersForWorkspace.delete(listener);
     if (listenersForWorkspace.size === 0) {
-      workspaceListeners.delete(workspaceId);
+      workspaceListeners.delete(taskId);
     }
   };
 }
 
-export function getContainerRunState(workspaceId: string): ContainerRunState | undefined {
-  const state = workspaceStates.get(workspaceId);
+export function getContainerRunState(taskId: string): ContainerRunState | undefined {
+  const state = workspaceStates.get(taskId);
   return state ? { ...state } : undefined;
 }
 
 export async function startContainerRun(args: StartRunArgs) {
   ensureSubscribed();
   const api = (window as any).electronAPI;
-  const workspaceId = clean(args.workspaceId);
+  const taskId = clean(args.taskId);
   const workspacePath = clean(args.workspacePath);
   const runId = clean(args.runId);
   const mode = args.mode;
   const payload: Record<string, any> = {};
-  if (workspaceId) payload.workspaceId = workspaceId;
+  if (taskId) payload.taskId = taskId;
   if (workspacePath) payload.workspacePath = workspacePath;
   if (runId) payload.runId = runId;
   if (mode === 'container' || mode === 'host') payload.mode = mode;
 
-  if (!workspaceId || !workspacePath) {
-    throw new Error('workspaceId and workspacePath are required to start a container run');
+  if (!taskId || !workspacePath) {
+    throw new Error('taskId and workspacePath are required to start a container run');
   }
 
   if (!api || typeof api.startContainerRun !== 'function') {
@@ -283,19 +283,19 @@ export function subscribeToAllRunStates(
  * Inspect any existing compose stack for this workspace and hydrate local state,
  * so UI shows ports/running status after a window refresh.
  */
-export async function refreshWorkspaceRunState(workspaceId: string) {
+export async function refreshWorkspaceRunState(taskId: string) {
   ensureSubscribed();
   const api = (window as any).electronAPI;
   if (!api?.inspectContainerRun) return;
   try {
-    const res = await api.inspectContainerRun(workspaceId);
+    const res = await api.inspectContainerRun(taskId);
     if (!res?.ok) return;
     const now = Date.now();
     if (res.running && Array.isArray(res.ports) && res.ports.length > 0) {
       const runId = `resume_${now}`;
       const portsEvent: RunnerEvent = {
         ts: now,
-        workspaceId,
+        taskId,
         runId,
         mode: 'container',
         type: 'ports',
@@ -309,7 +309,7 @@ export async function refreshWorkspaceRunState(workspaceId: string) {
       updateWorkspaceState(portsEvent);
       const lifecycleEvent: RunnerEvent = {
         ts: now,
-        workspaceId,
+        taskId,
         runId,
         mode: 'container',
         type: 'lifecycle',
@@ -323,7 +323,7 @@ export async function refreshWorkspaceRunState(workspaceId: string) {
 }
 
 export interface ContainerRunState {
-  workspaceId: string;
+  taskId: string;
   runId?: string;
   status: RunnerLifecycleStatus | 'idle';
   containerId?: string;
diff --git a/src/renderer/lib/filters.ts b/src/renderer/lib/filters.ts
index 79ea07fd..4074be52 100644
--- a/src/renderer/lib/filters.ts
+++ b/src/renderer/lib/filters.ts
@@ -1,6 +1,6 @@
 export interface FilterContext {
   phase: 'chunk' | 'final' | 'historical';
-  workspaceId: string;
+  taskId: string;
   conversationId?: string | null;
 }
 
diff --git a/src/renderer/lib/kanbanStore.ts b/src/renderer/lib/kanbanStore.ts
index dd0cae7b..898f533b 100644
--- a/src/renderer/lib/kanbanStore.ts
+++ b/src/renderer/lib/kanbanStore.ts
@@ -29,13 +29,13 @@ function write(next: MapShape) {
   } catch {}
 }
 
-export function getStatus(workspaceId: string): KanbanStatus {
+export function getStatus(taskId: string): KanbanStatus {
   const map = read();
-  return (map[workspaceId] as KanbanStatus) || 'todo';
+  return (map[taskId] as KanbanStatus) || 'todo';
 }
 
-export function setStatus(workspaceId: string, status: KanbanStatus): void {
-  const map = { ...read(), [workspaceId]: status };
+export function setStatus(taskId: string, status: KanbanStatus): void {
+  const map = { ...read(), [taskId]: status };
   write(map);
 }
 
diff --git a/src/renderer/lib/keys.ts b/src/renderer/lib/keys.ts
index 26db07b8..2e32e35f 100644
--- a/src/renderer/lib/keys.ts
+++ b/src/renderer/lib/keys.ts
@@ -1,5 +1,5 @@
 // If providerId is supplied, scope the flag per provider; otherwise fall back to legacy key.
-export const initialPromptSentKey = (workspaceId: string, providerId?: string) =>
+export const initialPromptSentKey = (taskId: string, providerId?: string) =>
   providerId && providerId.trim()
-    ? `initialPromptSent:${workspaceId}:${providerId.trim()}`
-    : `initialPromptSent:${workspaceId}`;
+    ? `initialPromptSent:${taskId}:${providerId.trim()}`
+    : `initialPromptSent:${taskId}`;
diff --git a/src/renderer/lib/quickPreview.ts b/src/renderer/lib/quickPreview.ts
index d08c1056..b22aef5d 100644
--- a/src/renderer/lib/quickPreview.ts
+++ b/src/renderer/lib/quickPreview.ts
@@ -43,23 +43,23 @@ export async function ensureCompose(workspacePath?: string): Promise<boolean> {
 }
 
 export async function quickStartPreview(args: {
-  workspaceId: string;
+  taskId: string;
   workspacePath: string;
   onPreviewUrl?: (url: string) => void;
 }): Promise<{ ok: boolean; error?: string }> {
-  const { workspaceId, workspacePath, onPreviewUrl } = args;
+  const { taskId, workspacePath, onPreviewUrl } = args;
   try {
     const node = await isNodeProject(workspacePath);
     if (!node) return { ok: false, error: 'Not a Node.js project (no package.json).' };
     await ensureCompose(workspacePath);
-    await startContainerRun({ workspaceId, workspacePath, mode: 'container' });
+    await startContainerRun({ taskId, workspacePath, mode: 'container' });
     // If already have a preview, use it immediately
-    const existing = getContainerRunState(workspaceId);
+    const existing = getContainerRunState(taskId);
     if (existing?.previewUrl && onPreviewUrl) onPreviewUrl(existing.previewUrl);
     // Subscribe for preview becoming ready
     const unsubRef: { current: null | (() => void) } = { current: null };
     await new Promise<void>((resolve) => {
-      unsubRef.current = subscribeToWorkspaceRunState(workspaceId, (state) => {
+      unsubRef.current = subscribeToWorkspaceRunState(taskId, (state) => {
         if (state.previewUrl) {
           onPreviewUrl?.(state.previewUrl);
           resolve();
diff --git a/src/renderer/lib/taskStatus.ts b/src/renderer/lib/taskStatus.ts
index a6a3fd0d..58b95565 100644
--- a/src/renderer/lib/taskStatus.ts
+++ b/src/renderer/lib/taskStatus.ts
@@ -30,11 +30,11 @@ function ensureTicker() {
   }, 2_000);
 }
 
-function setStatusInternal(workspaceId: string, next: Derived) {
-  const prev = statusByWorkspace.get(workspaceId) || 'idle';
+function setStatusInternal(taskId: string, next: Derived) {
+  const prev = statusByWorkspace.get(taskId) || 'idle';
   if (prev === next) return;
-  statusByWorkspace.set(workspaceId, next);
-  const ls = listenersByWorkspace.get(workspaceId);
+  statusByWorkspace.set(taskId, next);
+  const ls = listenersByWorkspace.get(taskId);
   if (ls)
     for (const fn of Array.from(ls)) {
       try {
@@ -53,28 +53,28 @@ function wireGlobal() {
   // Agent streams removed; PTY and container activity drive status.
 }
 
-export function getDerivedStatus(workspaceId: string): Derived {
+export function getDerivedStatus(taskId: string): Derived {
   wireGlobal();
-  return statusByWorkspace.get(workspaceId) || 'idle';
+  return statusByWorkspace.get(taskId) || 'idle';
 }
 
-export function subscribeDerivedStatus(workspaceId: string, listener: Listener): () => void {
+export function subscribeDerivedStatus(taskId: string, listener: Listener): () => void {
   wireGlobal();
-  let set = listenersByWorkspace.get(workspaceId);
+  let set = listenersByWorkspace.get(taskId);
   if (!set) {
     set = new Set<Listener>();
-    listenersByWorkspace.set(workspaceId, set);
+    listenersByWorkspace.set(taskId, set);
   }
   set.add(listener);
   // Emit current immediately
   try {
-    listener(getDerivedStatus(workspaceId));
+    listener(getDerivedStatus(taskId));
   } catch {}
   return () => {
-    const set2 = listenersByWorkspace.get(workspaceId);
+    const set2 = listenersByWorkspace.get(taskId);
     if (!set2) return;
     set2.delete(listener);
-    if (set2.size === 0) listenersByWorkspace.delete(workspaceId);
+    if (set2.size === 0) listenersByWorkspace.delete(taskId);
   };
 }
 
@@ -82,30 +82,30 @@ export function subscribeDerivedStatus(workspaceId: string, listener: Listener):
 // Call once per workspace to ensure terminal output marks the workspace busy.
 // Kept as a separate watcher so future non‑PTY providers can remain decoupled.
 const ptyUnsubs = new Map<string, () => void>();
-export function watchWorkspacePty(workspaceId: string): () => void {
+export function watchWorkspacePty(taskId: string): () => void {
   wireGlobal();
-  if (ptyUnsubs.has(workspaceId)) return ptyUnsubs.get(workspaceId)!;
+  if (ptyUnsubs.has(taskId)) return ptyUnsubs.get(taskId)!;
   const api: any = (window as any).electronAPI;
   let off: (() => void) | null = null;
   let offExit: (() => void) | null = null;
   let offStarted: (() => void) | null = null;
   try {
-    off = api?.onPtyData?.(workspaceId, (_chunk: string) => {
-      lastActivity.set(workspaceId, Date.now());
-      setStatusInternal(workspaceId, 'busy');
+    off = api?.onPtyData?.(taskId, (_chunk: string) => {
+      lastActivity.set(taskId, Date.now());
+      setStatusInternal(taskId, 'busy');
     });
   } catch {}
   try {
     offStarted = api?.onPtyStarted?.((payload: { id: string }) => {
-      if (payload?.id !== workspaceId) return;
-      lastActivity.set(workspaceId, Date.now());
-      setStatusInternal(workspaceId, 'busy');
+      if (payload?.id !== taskId) return;
+      lastActivity.set(taskId, Date.now());
+      setStatusInternal(taskId, 'busy');
     });
   } catch {}
   try {
-    offExit = api?.onPtyExit?.(workspaceId, () => {
-      lastActivity.set(workspaceId, Date.now());
-      setStatusInternal(workspaceId, 'idle');
+    offExit = api?.onPtyExit?.(taskId, () => {
+      lastActivity.set(taskId, Date.now());
+      setStatusInternal(taskId, 'idle');
     });
   } catch {}
   const cleanup = () => {
@@ -118,20 +118,20 @@ export function watchWorkspacePty(workspaceId: string): () => void {
     try {
       offStarted?.();
     } catch {}
-    ptyUnsubs.delete(workspaceId);
+    ptyUnsubs.delete(taskId);
   };
-  ptyUnsubs.set(workspaceId, cleanup);
+  ptyUnsubs.set(taskId, cleanup);
   return cleanup;
 }
 
 // Container runs also imply workspace activity (build/start/ready)
-export function watchWorkspaceContainers(workspaceId: string): () => void {
+export function watchWorkspaceContainers(taskId: string): () => void {
   wireGlobal();
-  const off = subscribeToWorkspaceRunState(workspaceId, (state) => {
+  const off = subscribeToWorkspaceRunState(taskId, (state) => {
     const s = String(state?.status || 'idle');
     const active = /^(starting|building|running|ready)$/i.test(s);
-    lastActivity.set(workspaceId, Date.now());
-    setStatusInternal(workspaceId, active ? 'busy' : 'idle');
+    lastActivity.set(taskId, Date.now());
+    setStatusInternal(taskId, active ? 'busy' : 'idle');
   });
   return off;
 }
@@ -139,11 +139,11 @@ export function watchWorkspaceContainers(workspaceId: string): () => void {
 // Align with the app's activity indicator (left sidebar).
 // Subscribes to the shared activityStore which understands provider-specific PTY IDs
 // and classifies chunks as busy/idle with debouncing.
-export function watchWorkspaceActivity(workspaceId: string): () => void {
+export function watchWorkspaceActivity(taskId: string): () => void {
   wireGlobal();
-  const off = activityStore.subscribe(workspaceId, (isBusy) => {
-    lastActivity.set(workspaceId, Date.now());
-    setStatusInternal(workspaceId, isBusy ? 'busy' : 'idle');
+  const off = activityStore.subscribe(taskId, (isBusy) => {
+    lastActivity.set(taskId, Date.now());
+    setStatusInternal(taskId, isBusy ? 'busy' : 'idle');
   });
   return off;
 }
diff --git a/src/renderer/lib/taskTerminalsStore.ts b/src/renderer/lib/taskTerminalsStore.ts
index 63d2b7a4..95e5dc29 100644
--- a/src/renderer/lib/taskTerminalsStore.ts
+++ b/src/renderer/lib/taskTerminalsStore.ts
@@ -42,8 +42,8 @@ const storageAvailable = (() => {
   }
 })();
 
-function storageKey(workspaceId: string) {
-  return `${STORAGE_PREFIX}:${workspaceId}`;
+function storageKey(taskId: string) {
+  return `${STORAGE_PREFIX}:${taskId}`;
 }
 
 function cloneState(state: TaskTerminalsState): TaskTerminalsState {
@@ -54,10 +54,10 @@ function cloneState(state: TaskTerminalsState): TaskTerminalsState {
   };
 }
 
-function loadFromStorage(workspaceId: string): TaskTerminalsState | null {
+function loadFromStorage(taskId: string): TaskTerminalsState | null {
   if (!storageAvailable) return null;
   try {
-    const raw = window.localStorage.getItem(storageKey(workspaceId));
+    const raw = window.localStorage.getItem(storageKey(taskId));
     if (!raw) return null;
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== 'object') return null;
@@ -109,7 +109,7 @@ function loadFromStorage(workspaceId: string): TaskTerminalsState | null {
   }
 }
 
-function saveToStorage(workspaceId: string, state: TaskTerminalsState) {
+function saveToStorage(taskId: string, state: TaskTerminalsState) {
   if (!storageAvailable) return;
   try {
     const payload = JSON.stringify({
@@ -117,19 +117,19 @@ function saveToStorage(workspaceId: string, state: TaskTerminalsState) {
       activeId: state.activeId,
       counter: state.counter,
     });
-    window.localStorage.setItem(storageKey(workspaceId), payload);
+    window.localStorage.setItem(storageKey(taskId), payload);
   } catch {
     // ignore storage errors
   }
 }
 
-function makeTerminalId(workspaceId: string): string {
+function makeTerminalId(taskId: string): string {
   const rnd = Math.random().toString(16).slice(2, 10);
-  return `${workspaceId}::term::${Date.now().toString(16)}::${rnd}`;
+  return `${taskId}::term::${Date.now().toString(16)}::${rnd}`;
 }
 
-function createDefaultState(workspaceId: string, workspacePath?: string): TaskTerminalsState {
-  const terminalId = makeTerminalId(workspaceId);
+function createDefaultState(taskId: string, workspacePath?: string): TaskTerminalsState {
+  const terminalId = makeTerminalId(taskId);
   const firstTerminal: TaskTerminal = {
     id: terminalId,
     title: 'Terminal 1',
@@ -143,39 +143,39 @@ function createDefaultState(workspaceId: string, workspacePath?: string): TaskTe
   };
 }
 
-function ensureSnapshot(workspaceId: string, state: TaskTerminalsState) {
-  const current = workspaceSnapshots.get(workspaceId);
+function ensureSnapshot(taskId: string, state: TaskTerminalsState) {
+  const current = workspaceSnapshots.get(taskId);
   if (
     !current ||
     current.terminals !== state.terminals ||
     current.activeTerminalId !== state.activeId
   ) {
-    workspaceSnapshots.set(workspaceId, {
+    workspaceSnapshots.set(taskId, {
       terminals: state.terminals,
       activeTerminalId: state.activeId,
     });
   }
-  return workspaceSnapshots.get(workspaceId)!;
+  return workspaceSnapshots.get(taskId)!;
 }
 
 function ensureWorkspaceState(
-  workspaceId: string,
+  taskId: string,
   workspacePath?: string
 ): TaskTerminalsState {
-  let state = workspaceStates.get(workspaceId);
+  let state = workspaceStates.get(taskId);
   if (state) {
-    ensureSnapshot(workspaceId, state);
+    ensureSnapshot(taskId, state);
     return state;
   }
 
-  state = loadFromStorage(workspaceId) ?? createDefaultState(workspaceId, workspacePath);
-  workspaceStates.set(workspaceId, state);
-  ensureSnapshot(workspaceId, state);
+  state = loadFromStorage(taskId) ?? createDefaultState(taskId, workspacePath);
+  workspaceStates.set(taskId, state);
+  ensureSnapshot(taskId, state);
   return state;
 }
 
-function emit(workspaceId: string) {
-  const listeners = workspaceListeners.get(workspaceId);
+function emit(taskId: string) {
+  const listeners = workspaceListeners.get(taskId);
   if (!listeners) return;
   for (const listener of listeners) {
     try {
@@ -187,67 +187,67 @@ function emit(workspaceId: string) {
 }
 
 function updateWorkspaceState(
-  workspaceId: string,
+  taskId: string,
   workspacePath: string | undefined,
   mutate: (draft: TaskTerminalsState) => void
 ) {
-  const current = ensureWorkspaceState(workspaceId, workspacePath);
+  const current = ensureWorkspaceState(taskId, workspacePath);
   const draft = cloneState(current);
   mutate(draft);
   // Ensure state remains valid
   if (!draft.terminals.length) {
-    const fallback = createDefaultState(workspaceId, workspacePath);
-    workspaceStates.set(workspaceId, fallback);
-    ensureSnapshot(workspaceId, fallback);
-    saveToStorage(workspaceId, fallback);
-    emit(workspaceId);
+    const fallback = createDefaultState(taskId, workspacePath);
+    workspaceStates.set(taskId, fallback);
+    ensureSnapshot(taskId, fallback);
+    saveToStorage(taskId, fallback);
+    emit(taskId);
     return;
   }
   if (typeof draft.activeId !== 'string' || !draft.terminals.some((t) => t.id === draft.activeId)) {
     draft.activeId = draft.terminals[0].id;
   }
   draft.counter = Math.max(draft.counter, draft.terminals.length);
-  workspaceStates.set(workspaceId, draft);
-  ensureSnapshot(workspaceId, draft);
-  saveToStorage(workspaceId, draft);
-  emit(workspaceId);
+  workspaceStates.set(taskId, draft);
+  ensureSnapshot(taskId, draft);
+  saveToStorage(taskId, draft);
+  emit(taskId);
 }
 
-function getSnapshot(workspaceId: string | null, workspacePath?: string): WorkspaceSnapshot {
-  if (!workspaceId) return EMPTY_SNAPSHOT;
-  const state = ensureWorkspaceState(workspaceId, workspacePath);
-  return ensureSnapshot(workspaceId, state);
+function getSnapshot(taskId: string | null, workspacePath?: string): WorkspaceSnapshot {
+  if (!taskId) return EMPTY_SNAPSHOT;
+  const state = ensureWorkspaceState(taskId, workspacePath);
+  return ensureSnapshot(taskId, state);
 }
 
 function subscribe(
-  workspaceId: string | null,
+  taskId: string | null,
   workspacePath: string | undefined,
   listener: () => void
 ): () => void {
-  if (!workspaceId) {
+  if (!taskId) {
     return () => undefined;
   }
-  ensureWorkspaceState(workspaceId, workspacePath);
-  let set = workspaceListeners.get(workspaceId);
+  ensureWorkspaceState(taskId, workspacePath);
+  let set = workspaceListeners.get(taskId);
   if (!set) {
     set = new Set();
-    workspaceListeners.set(workspaceId, set);
+    workspaceListeners.set(taskId, set);
   }
   set.add(listener);
   return () => {
-    const listeners = workspaceListeners.get(workspaceId);
+    const listeners = workspaceListeners.get(taskId);
     if (!listeners) return;
     listeners.delete(listener);
     if (listeners.size === 0) {
-      workspaceListeners.delete(workspaceId);
+      workspaceListeners.delete(taskId);
     }
   };
 }
 
-function createTerminal(workspaceId: string, workspacePath?: string) {
-  updateWorkspaceState(workspaceId, workspacePath, (draft) => {
+function createTerminal(taskId: string, workspacePath?: string) {
+  updateWorkspaceState(taskId, workspacePath, (draft) => {
     const nextIndex = draft.counter + 1;
-    const id = makeTerminalId(workspaceId);
+    const id = makeTerminalId(taskId);
     draft.counter = nextIndex;
     draft.activeId = id;
     draft.terminals = [
@@ -262,23 +262,23 @@ function createTerminal(workspaceId: string, workspacePath?: string) {
   });
 }
 
-function setActive(workspaceId: string, terminalId: string, workspacePath?: string) {
-  updateWorkspaceState(workspaceId, workspacePath, (draft) => {
+function setActive(taskId: string, terminalId: string, workspacePath?: string) {
+  updateWorkspaceState(taskId, workspacePath, (draft) => {
     if (draft.terminals.some((terminal) => terminal.id === terminalId)) {
       draft.activeId = terminalId;
     }
   });
 }
 
-function closeTerminal(workspaceId: string, terminalId: string, workspacePath?: string) {
-  const state = ensureWorkspaceState(workspaceId, workspacePath);
+function closeTerminal(taskId: string, terminalId: string, workspacePath?: string) {
+  const state = ensureWorkspaceState(taskId, workspacePath);
   if (state.terminals.length <= 1) {
     return;
   }
   const exists = state.terminals.some((terminal) => terminal.id === terminalId);
   if (!exists) return;
 
-  updateWorkspaceState(workspaceId, workspacePath, (draft) => {
+  updateWorkspaceState(taskId, workspacePath, (draft) => {
     const idx = draft.terminals.findIndex((terminal) => terminal.id === terminalId);
     draft.terminals = draft.terminals.filter((terminal) => terminal.id !== terminalId);
     if (draft.activeId === terminalId) {
diff --git a/src/renderer/terminal/SessionRegistry.ts b/src/renderer/terminal/SessionRegistry.ts
index 9f86b39e..dc0e4c0b 100644
--- a/src/renderer/terminal/SessionRegistry.ts
+++ b/src/renderer/terminal/SessionRegistry.ts
@@ -7,7 +7,7 @@ import {
 const DEFAULT_SCROLLBACK_LINES = 100_000;
 
 interface AttachOptions {
-  workspaceId: string;
+  taskId: string;
   container: HTMLElement;
   cwd?: string;
   shell?: string;
@@ -28,19 +28,19 @@ class SessionRegistry {
     return session;
   }
 
-  detach(workspaceId: string) {
-    this.sessions.get(workspaceId)?.detach();
+  detach(taskId: string) {
+    this.sessions.get(taskId)?.detach();
   }
 
-  dispose(workspaceId: string) {
-    const session = this.sessions.get(workspaceId);
+  dispose(taskId: string) {
+    const session = this.sessions.get(taskId);
     if (!session) return;
     session.dispose();
-    this.sessions.delete(workspaceId);
+    this.sessions.delete(taskId);
   }
 
-  getSession(workspaceId: string): TerminalSessionManager | undefined {
-    return this.sessions.get(workspaceId);
+  getSession(taskId: string): TerminalSessionManager | undefined {
+    return this.sessions.get(taskId);
   }
 
   disposeAll() {
@@ -50,11 +50,11 @@ class SessionRegistry {
   }
 
   private getOrCreate(options: AttachOptions): TerminalSessionManager {
-    const existing = this.sessions.get(options.workspaceId);
+    const existing = this.sessions.get(options.taskId);
     if (existing) return existing;
 
     const sessionOptions: TerminalSessionOptions = {
-      workspaceId: options.workspaceId,
+      taskId: options.taskId,
       cwd: options.cwd,
       shell: options.shell,
       env: options.env,
@@ -67,7 +67,7 @@ class SessionRegistry {
     };
 
     const session = new TerminalSessionManager(sessionOptions);
-    this.sessions.set(options.workspaceId, session);
+    this.sessions.set(options.taskId, session);
     return session;
   }
 }
diff --git a/src/renderer/terminal/TerminalSessionManager.ts b/src/renderer/terminal/TerminalSessionManager.ts
index aea15ef1..fefe4d30 100644
--- a/src/renderer/terminal/TerminalSessionManager.ts
+++ b/src/renderer/terminal/TerminalSessionManager.ts
@@ -19,7 +19,7 @@ export interface SessionTheme {
 }
 
 export interface TerminalSessionOptions {
-  workspaceId: string;
+  taskId: string;
   cwd?: string;
   shell?: string;
   env?: Record<string, string>;
@@ -60,7 +60,7 @@ export class TerminalSessionManager {
   private lastSnapshotReason: 'interval' | 'detach' | 'dispose' | null = null;
 
   constructor(private readonly options: TerminalSessionOptions) {
-    this.id = options.workspaceId;
+    this.id = options.taskId;
 
     this.container = document.createElement('div');
     this.container.className = 'terminal-session-root';
@@ -400,8 +400,8 @@ export class TerminalSessionManager {
   }
 
   private connectPty() {
-    const { workspaceId, cwd, shell, env, initialSize, autoApprove, initialPrompt } = this.options;
-    const id = workspaceId;
+    const { taskId, cwd, shell, env, initialSize, autoApprove, initialPrompt } = this.options;
+    const id = taskId;
     void window.electronAPI
       .ptyStart({
         id,
diff --git a/src/renderer/types/electron-api.d.ts b/src/renderer/types/electron-api.d.ts
index 92e56e6d..03e5dddb 100644
--- a/src/renderer/types/electron-api.d.ts
+++ b/src/renderer/types/electron-api.d.ts
@@ -320,7 +320,7 @@ declare global {
           }
       >;
       startContainerRun: (args: {
-        workspaceId: string;
+        taskId: string;
         workspacePath: string;
         runId?: string;
         mode?: RunnerMode;
@@ -346,7 +346,7 @@ declare global {
             };
           }
       >;
-      stopContainerRun: (workspaceId: string) => Promise<{ ok: boolean; error?: string }>;
+      stopContainerRun: (taskId: string) => Promise<{ ok: boolean; error?: string }>;
       openExternal: (url: string) => Promise<{ success: boolean; error?: string }>;
       openIn: (args: {
         app: 'finder' | 'cursor' | 'vscode' | 'terminal' | 'ghostty' | 'zed' | 'iterm2';
@@ -575,7 +575,7 @@ declare global {
       getWorkspaces: (projectId?: string) => Promise<any[]>;
       saveWorkspace: (workspace: any) => Promise<{ success: boolean; error?: string }>;
       deleteProject: (projectId: string) => Promise<{ success: boolean; error?: string }>;
-      deleteWorkspace: (workspaceId: string) => Promise<{ success: boolean; error?: string }>;
+      deleteWorkspace: (taskId: string) => Promise<{ success: boolean; error?: string }>;
 
       // Message operations
       saveMessage: (message: any) => Promise<{ success: boolean; error?: string }>;
@@ -583,7 +583,7 @@ declare global {
         conversationId: string
       ) => Promise<{ success: boolean; messages?: any[]; error?: string }>;
       getOrCreateDefaultConversation: (
-        workspaceId: string
+        taskId: string
       ) => Promise<{ success: boolean; conversation?: any; error?: string }>;
 
       // Debug helpers
@@ -902,7 +902,7 @@ export interface ElectronAPI {
   getWorkspaces: (projectId?: string) => Promise<any[]>;
   saveWorkspace: (workspace: any) => Promise<{ success: boolean; error?: string }>;
   deleteProject: (projectId: string) => Promise<{ success: boolean; error?: string }>;
-  deleteWorkspace: (workspaceId: string) => Promise<{ success: boolean; error?: string }>;
+  deleteWorkspace: (taskId: string) => Promise<{ success: boolean; error?: string }>;
 
   // Message operations
   saveMessage: (message: any) => Promise<{ success: boolean; error?: string }>;
@@ -910,7 +910,7 @@ export interface ElectronAPI {
     conversationId: string
   ) => Promise<{ success: boolean; messages?: any[]; error?: string }>;
   getOrCreateDefaultConversation: (
-    workspaceId: string
+    taskId: string
   ) => Promise<{ success: boolean; conversation?: any; error?: string }>;
 
   // Debug helpers
diff --git a/src/renderer/types/global.d.ts b/src/renderer/types/global.d.ts
index bd2385e8..26b4711a 100644
--- a/src/renderer/types/global.d.ts
+++ b/src/renderer/types/global.d.ts
@@ -208,7 +208,7 @@ declare global {
       getWorkspaces: (projectId?: string) => Promise<any[]>;
       saveWorkspace: (workspace: any) => Promise<{ success: boolean; error?: string }>;
       deleteProject: (projectId: string) => Promise<{ success: boolean; error?: string }>;
-      deleteWorkspace: (workspaceId: string) => Promise<{ success: boolean; error?: string }>;
+      deleteWorkspace: (taskId: string) => Promise<{ success: boolean; error?: string }>;
     };
   }
 }
diff --git a/src/shared/container/events.ts b/src/shared/container/events.ts
index 40308b1a..c81bbeac 100644
--- a/src/shared/container/events.ts
+++ b/src/shared/container/events.ts
@@ -31,7 +31,7 @@ export type RunnerResultStatus = 'stopped' | 'failed';
 
 interface RunnerEventEnvelope<T extends RunnerEventType> {
   ts: number;
-  workspaceId: string;
+  taskId: string;
   mode: RunnerMode;
   type: T;
   runId: string;
@@ -85,7 +85,7 @@ export function isRunnerEvent(value: unknown): value is RunnerEvent {
   const candidate = value as Partial<RunnerEvent>;
   if (
     typeof candidate.ts !== 'number' ||
-    typeof candidate.workspaceId !== 'string' ||
+    typeof candidate.taskId !== 'string' ||
     typeof candidate.mode !== 'string' ||
     typeof candidate.type !== 'string' ||
     typeof candidate.runId !== 'string'
diff --git a/src/shared/container/mockRunner.test.ts b/src/shared/container/mockRunner.test.ts
index 2d7ebf38..577d6707 100644
--- a/src/shared/container/mockRunner.test.ts
+++ b/src/shared/container/mockRunner.test.ts
@@ -24,7 +24,7 @@ describe('generateMockStartEvents', () => {
     };
 
     const events = await generateMockStartEvents({
-      workspaceId: 'ws_123',
+      taskId: 'ws_123',
       config: baseConfig,
       portAllocator: buildMockPortAllocator([45000, 45001]),
       runId: 'run-1',
@@ -40,9 +40,9 @@ describe('generateMockStartEvents', () => {
       'lifecycle',
     ]);
 
-    const metadata = events.map(({ workspaceId, runId, mode }) => ({ workspaceId, runId, mode }));
+    const metadata = events.map(({ taskId, runId, mode }) => ({ taskId, runId, mode }));
     metadata.forEach((meta) => {
-      expect(meta).toEqual({ workspaceId: 'ws_123', runId: 'run-1', mode: 'container' });
+      expect(meta).toEqual({ taskId: 'ws_123', runId: 'run-1', mode: 'container' });
     });
 
     const portsEvent = events[2];
@@ -73,7 +73,7 @@ describe('generateMockStartEvents', () => {
     const now = vi.fn(() => timestamp);
 
     const events = await generateMockStartEvents({
-      workspaceId: 'ws_abc',
+      taskId: 'ws_abc',
       config: baseConfig,
       portAllocator: buildMockPortAllocator([46000, 46001]),
       now,
@@ -92,7 +92,7 @@ describe('generateMockStartEvents', () => {
     };
 
     const events = await generateMockStartEvents({
-      workspaceId: 'ws_next',
+      taskId: 'ws_next',
       config,
       portAllocator: buildMockPortAllocator([50000, 50001]),
     });
diff --git a/src/shared/container/mockRunner.ts b/src/shared/container/mockRunner.ts
index 427876fb..eece9bdd 100644
--- a/src/shared/container/mockRunner.ts
+++ b/src/shared/container/mockRunner.ts
@@ -6,7 +6,7 @@ export interface PortAllocator {
 }
 
 export interface MockStartOptions {
-  workspaceId: string;
+  taskId: string;
   config: ResolvedContainerConfig;
   portAllocator: PortAllocator;
   runId?: string;
@@ -21,8 +21,8 @@ function resolveRunId(runId: string | undefined, now: () => number): string {
   return `r_${new Date(now()).toISOString()}`;
 }
 
-function resolveContainerId(workspaceId: string): string {
-  return `emdash_ws_${workspaceId}`;
+function resolveContainerId(taskId: string): string {
+  return `emdash_ws_${taskId}`;
 }
 
 function previewServiceFromConfig(config: ResolvedContainerConfig): string {
@@ -40,13 +40,13 @@ function createTimestampGenerator(now: () => number): () => number {
 }
 
 function createEventBase(
-  workspaceId: string,
+  taskId: string,
   runId: string,
   mode: RunnerMode,
   nextTs: () => number
 ) {
   return {
-    workspaceId,
+    taskId,
     runId,
     mode,
     ts: nextTs(),
@@ -58,7 +58,7 @@ export async function generateMockStartEvents(options: MockStartOptions): Promis
   const nextTs = createTimestampGenerator(now);
   const mode = options.mode ?? DEFAULT_MODE;
   const runId = resolveRunId(options.runId, now);
-  const containerId = resolveContainerId(options.workspaceId);
+  const containerId = resolveContainerId(options.taskId);
   const previewService = previewServiceFromConfig(options.config);
 
   const ports = await options.portAllocator.allocate(options.config.ports);
@@ -66,24 +66,24 @@ export async function generateMockStartEvents(options: MockStartOptions): Promis
 
   return [
     {
-      ...createEventBase(options.workspaceId, runId, mode, nextTs),
+      ...createEventBase(options.taskId, runId, mode, nextTs),
       type: 'lifecycle',
       status: 'building',
     },
     {
-      ...createEventBase(options.workspaceId, runId, mode, nextTs),
+      ...createEventBase(options.taskId, runId, mode, nextTs),
       type: 'lifecycle',
       status: 'starting',
       containerId,
     },
     {
-      ...createEventBase(options.workspaceId, runId, mode, nextTs),
+      ...createEventBase(options.taskId, runId, mode, nextTs),
       type: 'ports',
       previewService,
       ports: mappedPorts,
     },
     {
-      ...createEventBase(options.workspaceId, runId, mode, nextTs),
+      ...createEventBase(options.taskId, runId, mode, nextTs),
       type: 'lifecycle',
       status: 'ready',
     },
diff --git a/src/test/main/ContainerIpc.test.ts b/src/test/main/ContainerIpc.test.ts
index 5a4b3a7a..2abbd1b2 100644
--- a/src/test/main/ContainerIpc.test.ts
+++ b/src/test/main/ContainerIpc.test.ts
@@ -211,11 +211,11 @@ describe('registerContainerIpc', () => {
 
       const result = await handler(
         {},
-        { workspaceId: ' ws-1 ', workspacePath: ' /tmp/workspace ' }
+        { taskId: ' ws-1 ', workspacePath: ' /tmp/workspace ' }
       );
 
       expect(startRunMock).toHaveBeenCalledWith({
-        workspaceId: 'ws-1',
+        taskId: 'ws-1',
         workspacePath: '/tmp/workspace',
       });
       expect(result).toEqual({
@@ -239,7 +239,7 @@ describe('registerContainerIpc', () => {
       registerContainerIpc();
       const handler = getHandler('container:start-run');
 
-      const result = await handler({}, { workspaceId: 'ws-1', workspacePath: '/tmp/workspace' });
+      const result = await handler({}, { taskId: 'ws-1', workspacePath: '/tmp/workspace' });
 
       expect(result).toEqual({
         ok: false,
@@ -256,13 +256,13 @@ describe('registerContainerIpc', () => {
       registerContainerIpc();
       const handler = getHandler('container:start-run');
 
-      const result = await handler({}, { workspaceId: '', workspacePath: '' });
+      const result = await handler({}, { taskId: '', workspacePath: '' });
 
       expect(result).toEqual({
         ok: false,
         error: {
           code: 'INVALID_ARGUMENT',
-          message: '`workspaceId` and `workspacePath` must be provided to start a container run',
+          message: '`taskId` and `workspacePath` must be provided to start a container run',
           configKey: null,
           configPath: null,
         },
@@ -281,7 +281,7 @@ describe('registerContainerIpc', () => {
 
     const event: RunnerEvent = {
       ts: 1700000000000,
-      workspaceId: 'ws-1',
+      taskId: 'ws-1',
       runId: 'run-1',
       mode: 'container',
       type: 'lifecycle',
diff --git a/src/test/main/ContainerRunnerService.test.ts b/src/test/main/ContainerRunnerService.test.ts
index 9a0b6a90..7dc550f3 100644
--- a/src/test/main/ContainerRunnerService.test.ts
+++ b/src/test/main/ContainerRunnerService.test.ts
@@ -53,7 +53,7 @@ describe('ContainerRunnerService', () => {
     service.onRunnerEvent((event) => events.push(event));
 
     const result = await service.startMockRun({
-      workspaceId: 'ws-1',
+      taskId: 'ws-1',
       workspacePath: '/tmp/workspace',
       runId: 'run-123',
       now: () => 1700000000000,
@@ -97,7 +97,7 @@ describe('ContainerRunnerService', () => {
     service.onRunnerEvent(listener);
 
     const result = await service.startMockRun({
-      workspaceId: 'ws-1',
+      taskId: 'ws-1',
       workspacePath: '/tmp/workspace',
     });
 
@@ -136,7 +136,7 @@ describe('ContainerRunnerService', () => {
     service.onRunnerEvent((event) => events.push(event));
 
     const result = await service.startMockRun({
-      workspaceId: 'ws-1',
+      taskId: 'ws-1',
       workspacePath: '/tmp/workspace',
       runId: 'run-err',
       now: () => 1700000000100,
diff --git a/src/test/renderer/containerRuns.test.ts b/src/test/renderer/containerRuns.test.ts
index f5477158..90dad4c3 100644
--- a/src/test/renderer/containerRuns.test.ts
+++ b/src/test/renderer/containerRuns.test.ts
@@ -67,12 +67,12 @@ describe('containerRuns renderer bridge', () => {
     startRunMock.mockResolvedValue({ ok: true, runId: 'run-1', sourcePath: null });
 
     const result = await startContainerRun({
-      workspaceId: ' ws-1 ',
+      taskId: ' ws-1 ',
       workspacePath: ' /tmp/workspace ',
     });
 
     expect(startRunMock).toHaveBeenCalledWith({
-      workspaceId: 'ws-1',
+      taskId: 'ws-1',
       workspacePath: '/tmp/workspace',
     });
     expect(result).toEqual({ ok: true, runId: 'run-1', sourcePath: null });
@@ -85,7 +85,7 @@ describe('containerRuns renderer bridge', () => {
 
     const sample: RunnerEvent = {
       ts: 1700000000000,
-      workspaceId: 'ws-1',
+      taskId: 'ws-1',
       runId: 'run-2',
       mode: 'container',
       type: 'lifecycle',
@@ -108,7 +108,7 @@ describe('containerRuns renderer bridge', () => {
 
     triggerEvent({
       ts: 1,
-      workspaceId: 'ws-1',
+      taskId: 'ws-1',
       runId: 'run-1',
       mode: 'container',
       type: 'lifecycle',
@@ -117,7 +117,7 @@ describe('containerRuns renderer bridge', () => {
 
     triggerEvent({
       ts: 2,
-      workspaceId: 'ws-1',
+      taskId: 'ws-1',
       runId: 'run-1',
       mode: 'container',
       type: 'ports',
@@ -130,7 +130,7 @@ describe('containerRuns renderer bridge', () => {
 
     triggerEvent({
       ts: 3,
-      workspaceId: 'ws-1',
+      taskId: 'ws-1',
       runId: 'run-1',
       mode: 'container',
       type: 'lifecycle',
@@ -149,11 +149,11 @@ describe('containerRuns renderer bridge', () => {
   it('re-registers listener after reset', async () => {
     startRunMock.mockResolvedValue({ ok: true, runId: 'run-3', sourcePath: null });
 
-    await startContainerRun({ workspaceId: 'ws-1', workspacePath: '/tmp/workspace' });
+    await startContainerRun({ taskId: 'ws-1', workspacePath: '/tmp/workspace' });
     expect(onRunEventMock).toHaveBeenCalledTimes(1);
 
     resetContainerRunListeners();
-    await startContainerRun({ workspaceId: 'ws-1', workspacePath: '/tmp/workspace' });
+    await startContainerRun({ taskId: 'ws-1', workspacePath: '/tmp/workspace' });
     expect(onRunEventMock).toHaveBeenCalledTimes(2);
   });
 });

From a93f43a42dd9d648b9b5db30f1e9bc8bdd946761 Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Fri, 12 Dec 2025 17:30:48 -0800
Subject: [PATCH 03/35] refactor: rename workspacePath to taskPath

---
 src/main/ipc/containerIpc.ts                  |  28 ++---
 src/main/ipc/gitIpc.ts                        | 116 +++++++++---------
 src/main/ipc/hostPreviewIpc.ts                |  12 +-
 src/main/preload.ts                           |  50 ++++----
 src/main/services/GitService.ts               |  38 +++---
 src/main/services/containerConfigService.ts   |  14 +--
 src/main/services/containerRunnerService.ts   |  54 ++++----
 src/main/services/fsIpc.ts                    |  12 +-
 src/main/services/hostPreviewService.ts       |  10 +-
 src/main/services/iconService.ts              |   6 +-
 src/main/services/planLockIpc.ts              |  12 +-
 src/renderer/App.tsx                          |   4 +-
 src/renderer/components/BrowserPane.tsx       |   2 +-
 src/renderer/components/ChangesDiffModal.tsx  |  12 +-
 src/renderer/components/ChatInterface.tsx     |   4 +-
 .../components/ContainerStatusBadge.tsx       |  10 +-
 src/renderer/components/FileChangesPanel.tsx  |  16 +--
 src/renderer/components/ProjectMainView.tsx   |  10 +-
 src/renderer/components/TaskDeleteButton.tsx  |   8 +-
 src/renderer/components/TaskItem.tsx          |   2 +-
 src/renderer/components/TaskPorts.tsx         |  14 +--
 .../components/kanban/KanbanBoard.tsx         |   4 +-
 src/renderer/components/kanban/KanbanCard.tsx |   2 +-
 .../components/kanban/ProviderTooltip.tsx     |  12 +-
 .../titlebar/BrowserToggleButton.tsx          |  12 +-
 src/renderer/components/titlebar/Titlebar.tsx |   6 +-
 src/renderer/hooks/useCreatePR.tsx            |  10 +-
 src/renderer/hooks/useDeleteRisks.ts          |   2 +-
 src/renderer/hooks/useFileChanges.ts          |  10 +-
 src/renderer/hooks/useFileDiff.ts             |   8 +-
 src/renderer/hooks/usePlanActivation.ts       |   6 +-
 src/renderer/hooks/usePlanMode.ts             |  70 +++++------
 src/renderer/hooks/usePrStatus.ts             |   8 +-
 src/renderer/lib/attachments.ts               |   6 +-
 src/renderer/lib/containerRuns.ts             |  10 +-
 src/renderer/lib/planLogs.ts                  |   4 +-
 src/renderer/lib/quickPreview.ts              |  24 ++--
 src/renderer/lib/taskTerminalsStore.ts        |  38 +++---
 src/renderer/types/electron-api.d.ts          |  24 ++--
 src/renderer/types/global.d.ts                |   2 +-
 src/test/main/ContainerIpc.test.ts            |  18 +--
 src/test/main/ContainerRunnerService.test.ts  |   6 +-
 src/test/renderer/containerRuns.test.ts       |   8 +-
 src/types/electron-extra.d.ts                 |   4 +-
 44 files changed, 364 insertions(+), 364 deletions(-)

diff --git a/src/main/ipc/containerIpc.ts b/src/main/ipc/containerIpc.ts
index 539d5c81..49acb9e2 100644
--- a/src/main/ipc/containerIpc.ts
+++ b/src/main/ipc/containerIpc.ts
@@ -63,13 +63,13 @@ export function registerContainerIpc(): void {
   ipcMain.handle(
     'container:load-config',
     async (_event, args): Promise<ContainerConfigIpcResponse> => {
-      const workspacePath = resolveWorkspacePath(args);
-      if (!workspacePath) {
+      const taskPath = resolveWorkspacePath(args);
+      if (!taskPath) {
         return {
           ok: false,
           error: {
             code: 'INVALID_ARGUMENT',
-            message: '`workspacePath` must be a non-empty string',
+            message: '`taskPath` must be a non-empty string',
             configPath: null,
             configKey: null,
           },
@@ -77,7 +77,7 @@ export function registerContainerIpc(): void {
       }
 
       try {
-        const result = await loadWorkspaceContainerConfig(workspacePath);
+        const result = await loadWorkspaceContainerConfig(taskPath);
         if (result.ok) {
           return {
             ok: true,
@@ -114,7 +114,7 @@ export function registerContainerIpc(): void {
           ok: false,
           error: {
             code: 'INVALID_ARGUMENT',
-            message: '`taskId` and `workspacePath` must be provided to start a container run',
+            message: '`taskId` and `taskPath` must be provided to start a container run',
             configPath: null,
             configKey: null,
           },
@@ -177,9 +177,9 @@ export function registerContainerIpc(): void {
       try {
         const service = typeof args?.service === 'string' ? args.service : '';
         const allowNetwork = args?.allowNetwork === true;
-        const workspacePath =
-          typeof args?.workspacePath === 'string' ? args.workspacePath : undefined;
-        const res = await resolveServiceIcon({ service, allowNetwork, workspacePath });
+        const taskPath =
+          typeof args?.taskPath === 'string' ? args.taskPath : undefined;
+        const res = await resolveServiceIcon({ service, allowNetwork, taskPath });
         if (res.ok) return { ok: true, dataUrl: res.dataUrl };
         return { ok: false };
       } catch (error: any) {
@@ -196,7 +196,7 @@ function resolveWorkspacePath(args: unknown): string | null {
   }
 
   if (args && typeof args === 'object') {
-    const candidate = (args as { workspacePath?: unknown }).workspacePath;
+    const candidate = (args as { taskPath?: unknown }).taskPath;
     if (typeof candidate === 'string') {
       const trimmed = candidate.trim();
       if (trimmed.length > 0) {
@@ -219,7 +219,7 @@ function serializeError(error: ContainerConfigLoadError): SerializedContainerCon
 
 function parseStartRunArgs(args: unknown): {
   taskId: string;
-  workspacePath: string;
+  taskPath: string;
   runId?: string;
   mode?: RunnerMode;
 } | null {
@@ -229,9 +229,9 @@ function parseStartRunArgs(args: unknown): {
 
   const payload = args as Record<string, unknown>;
   const taskId = typeof payload.taskId === 'string' ? payload.taskId.trim() : '';
-  const workspacePath =
-    typeof payload.workspacePath === 'string' ? payload.workspacePath.trim() : '';
-  if (!taskId || !workspacePath) {
+  const taskPath =
+    typeof payload.taskPath === 'string' ? payload.taskPath.trim() : '';
+  if (!taskId || !taskPath) {
     return null;
   }
 
@@ -247,7 +247,7 @@ function parseStartRunArgs(args: unknown): {
     }
   }
 
-  return { taskId, workspacePath, runId, mode };
+  return { taskId, taskPath, runId, mode };
 }
 
 function serializeStartRunResult(result: ContainerStartResult): ContainerStartIpcResponse {
diff --git a/src/main/ipc/gitIpc.ts b/src/main/ipc/gitIpc.ts
index 67b79a02..f301a8d1 100644
--- a/src/main/ipc/gitIpc.ts
+++ b/src/main/ipc/gitIpc.ts
@@ -33,9 +33,9 @@ export function registerGitIpc() {
   }
   const GIT = resolveGitBin();
   // Git: Status (moved from Codex IPC)
-  ipcMain.handle('git:get-status', async (_, workspacePath: string) => {
+  ipcMain.handle('git:get-status', async (_, taskPath: string) => {
     try {
-      const changes = await gitGetStatus(workspacePath);
+      const changes = await gitGetStatus(taskPath);
       return { success: true, changes };
     } catch (error) {
       return { success: false, error: error as string };
@@ -45,9 +45,9 @@ export function registerGitIpc() {
   // Git: Per-file diff (moved from Codex IPC)
   ipcMain.handle(
     'git:get-file-diff',
-    async (_, args: { workspacePath: string; filePath: string }) => {
+    async (_, args: { taskPath: string; filePath: string }) => {
       try {
-        const diff = await gitGetFileDiff(args.workspacePath, args.filePath);
+        const diff = await gitGetFileDiff(args.taskPath, args.filePath);
         return { success: true, diff };
       } catch (error) {
         return { success: false, error: error as string };
@@ -56,10 +56,10 @@ export function registerGitIpc() {
   );
 
   // Git: Stage file
-  ipcMain.handle('git:stage-file', async (_, args: { workspacePath: string; filePath: string }) => {
+  ipcMain.handle('git:stage-file', async (_, args: { taskPath: string; filePath: string }) => {
     try {
-      log.info('Staging file:', { workspacePath: args.workspacePath, filePath: args.filePath });
-      await gitStageFile(args.workspacePath, args.filePath);
+      log.info('Staging file:', { taskPath: args.taskPath, filePath: args.filePath });
+      await gitStageFile(args.taskPath, args.filePath);
       log.info('File staged successfully:', args.filePath);
       return { success: true };
     } catch (error) {
@@ -71,10 +71,10 @@ export function registerGitIpc() {
   // Git: Revert file
   ipcMain.handle(
     'git:revert-file',
-    async (_, args: { workspacePath: string; filePath: string }) => {
+    async (_, args: { taskPath: string; filePath: string }) => {
       try {
-        log.info('Reverting file:', { workspacePath: args.workspacePath, filePath: args.filePath });
-        const result = await gitRevertFile(args.workspacePath, args.filePath);
+        log.info('Reverting file:', { taskPath: args.taskPath, filePath: args.filePath });
+        const result = await gitRevertFile(args.taskPath, args.filePath);
         log.info('File operation completed:', { filePath: args.filePath, action: result.action });
         return { success: true, action: result.action };
       } catch (error) {
@@ -89,7 +89,7 @@ export function registerGitIpc() {
     async (
       _,
       args: {
-        workspacePath: string;
+        taskPath: string;
         title?: string;
         body?: string;
         base?: string;
@@ -99,10 +99,10 @@ export function registerGitIpc() {
         fill?: boolean;
       }
     ) => {
-      const { workspacePath, title, body, base, head, draft, web, fill } =
+      const { taskPath, title, body, base, head, draft, web, fill } =
         args ||
         ({} as {
-          workspacePath: string;
+          taskPath: string;
           title?: string;
           body?: string;
           base?: string;
@@ -117,11 +117,11 @@ export function registerGitIpc() {
         // Stage and commit any pending changes
         try {
           const { stdout: statusOut } = await execAsync('git status --porcelain', {
-            cwd: workspacePath,
+            cwd: taskPath,
           });
           if (statusOut && statusOut.trim().length > 0) {
             const { stdout: addOut, stderr: addErr } = await execAsync('git add -A', {
-              cwd: workspacePath,
+              cwd: taskPath,
             });
             if (addOut?.trim()) outputs.push(addOut.trim());
             if (addErr?.trim()) outputs.push(addErr.trim());
@@ -130,7 +130,7 @@ export function registerGitIpc() {
             try {
               const { stdout: commitOut, stderr: commitErr } = await execAsync(
                 `git commit -m ${JSON.stringify(commitMsg)}`,
-                { cwd: workspacePath }
+                { cwd: taskPath }
               );
               if (commitOut?.trim()) outputs.push(commitOut.trim());
               if (commitErr?.trim()) outputs.push(commitErr.trim());
@@ -150,16 +150,16 @@ export function registerGitIpc() {
 
         // Ensure branch is pushed to origin so PR includes latest commit
         try {
-          await execAsync('git push', { cwd: workspacePath });
+          await execAsync('git push', { cwd: taskPath });
           outputs.push('git push: success');
         } catch (pushErr) {
           try {
             const { stdout: branchOut } = await execAsync('git rev-parse --abbrev-ref HEAD', {
-              cwd: workspacePath,
+              cwd: taskPath,
             });
             const branch = branchOut.trim();
             await execAsync(`git push --set-upstream origin ${JSON.stringify(branch)}`, {
-              cwd: workspacePath,
+              cwd: taskPath,
             });
             outputs.push(`git push --set-upstream origin ${branch}: success`);
           } catch (pushErr2) {
@@ -177,13 +177,13 @@ export function registerGitIpc() {
         try {
           const { stdout: repoOut } = await execAsync(
             'gh repo view --json nameWithOwner -q .nameWithOwner',
-            { cwd: workspacePath }
+            { cwd: taskPath }
           );
           repoNameWithOwner = (repoOut || '').trim();
         } catch {
           try {
             const { stdout: urlOut } = await execAsync('git remote get-url origin', {
-              cwd: workspacePath,
+              cwd: taskPath,
             });
             const url = (urlOut || '').trim();
             // Handle both SSH and HTTPS forms
@@ -201,14 +201,14 @@ export function registerGitIpc() {
         // Determine current branch and default base branch (fallback to main)
         let currentBranch = '';
         try {
-          const { stdout } = await execAsync('git branch --show-current', { cwd: workspacePath });
+          const { stdout } = await execAsync('git branch --show-current', { cwd: taskPath });
           currentBranch = (stdout || '').trim();
         } catch {}
         let defaultBranch = 'main';
         try {
           const { stdout } = await execAsync(
             'gh repo view --json defaultBranchRef -q .defaultBranchRef.name',
-            { cwd: workspacePath }
+            { cwd: taskPath }
           );
           const db = (stdout || '').trim();
           if (db) defaultBranch = db;
@@ -216,7 +216,7 @@ export function registerGitIpc() {
           try {
             const { stdout } = await execAsync(
               'git remote show origin | sed -n "/HEAD branch/s/.*: //p"',
-              { cwd: workspacePath }
+              { cwd: taskPath }
             );
             const db2 = (stdout || '').trim();
             if (db2) defaultBranch = db2;
@@ -228,7 +228,7 @@ export function registerGitIpc() {
           const baseRef = base || defaultBranch;
           const { stdout: aheadOut } = await execAsync(
             `git rev-list --count ${JSON.stringify(`origin/${baseRef}`)}..HEAD`,
-            { cwd: workspacePath }
+            { cwd: taskPath }
           );
           const aheadCount = parseInt((aheadOut || '0').trim(), 10) || 0;
           if (aheadCount <= 0) {
@@ -263,7 +263,7 @@ current branch '${currentBranch}' ahead of base '${baseRef}'.`,
 
         const cmd = `gh pr create ${flags.join(' ')}`.trim();
 
-        const { stdout, stderr } = await execAsync(cmd, { cwd: workspacePath });
+        const { stdout, stderr } = await execAsync(cmd, { cwd: taskPath });
         const out = [...outputs, (stdout || '').trim() || (stderr || '').trim()]
           .filter(Boolean)
           .join('\n');
@@ -281,11 +281,11 @@ current branch '${currentBranch}' ahead of base '${baseRef}'.`,
   );
 
   // Git: Get PR status for current branch via GitHub CLI
-  ipcMain.handle('git:get-pr-status', async (_, args: { workspacePath: string }) => {
-    const { workspacePath } = args || ({} as { workspacePath: string });
+  ipcMain.handle('git:get-pr-status', async (_, args: { taskPath: string }) => {
+    const { taskPath } = args || ({} as { taskPath: string });
     try {
       // Ensure we're in a git repo
-      await execAsync('git rev-parse --is-inside-work-tree', { cwd: workspacePath });
+      await execAsync('git rev-parse --is-inside-work-tree', { cwd: taskPath });
 
       const queryFields = [
         'number',
@@ -303,7 +303,7 @@ current branch '${currentBranch}' ahead of base '${baseRef}'.`,
       ];
       const cmd = `gh pr view --json ${queryFields.join(',')} -q .`;
       try {
-        const { stdout } = await execAsync(cmd, { cwd: workspacePath });
+        const { stdout } = await execAsync(cmd, { cwd: taskPath });
         const json = (stdout || '').trim();
         const data = json ? JSON.parse(json) : null;
         if (!data) return { success: false, error: 'No PR data returned' };
@@ -327,7 +327,7 @@ current branch '${currentBranch}' ahead of base '${baseRef}'.`,
             ? `git diff --shortstat ${JSON.stringify(targetRef)}...HEAD`
             : 'git diff --shortstat HEAD~1..HEAD';
           try {
-            const { stdout: diffOut } = await execAsync(shortstatCmd, { cwd: workspacePath });
+            const { stdout: diffOut } = await execAsync(shortstatCmd, { cwd: taskPath });
             const statLine = (diffOut || '').trim();
             const m =
               statLine &&
@@ -364,25 +364,25 @@ current branch '${currentBranch}' ahead of base '${baseRef}'.`,
     async (
       _,
       args: {
-        workspacePath: string;
+        taskPath: string;
         commitMessage?: string;
         createBranchIfOnDefault?: boolean;
         branchPrefix?: string;
       }
     ) => {
       const {
-        workspacePath,
+        taskPath,
         commitMessage = 'chore: apply workspace changes',
         createBranchIfOnDefault = true,
         branchPrefix = 'orch',
       } = (args ||
         ({} as {
-          workspacePath: string;
+          taskPath: string;
           commitMessage?: string;
           createBranchIfOnDefault?: boolean;
           branchPrefix?: string;
         })) as {
-        workspacePath: string;
+        taskPath: string;
         commitMessage?: string;
         createBranchIfOnDefault?: boolean;
         branchPrefix?: string;
@@ -390,11 +390,11 @@ current branch '${currentBranch}' ahead of base '${baseRef}'.`,
 
       try {
         // Ensure we're in a git repo
-        await execAsync('git rev-parse --is-inside-work-tree', { cwd: workspacePath });
+        await execAsync('git rev-parse --is-inside-work-tree', { cwd: taskPath });
 
         // Determine current branch
         const { stdout: currentBranchOut } = await execAsync('git branch --show-current', {
-          cwd: workspacePath,
+          cwd: taskPath,
         });
         const currentBranch = (currentBranchOut || '').trim();
 
@@ -403,7 +403,7 @@ current branch '${currentBranch}' ahead of base '${baseRef}'.`,
         try {
           const { stdout } = await execAsync(
             'gh repo view --json defaultBranchRef -q .defaultBranchRef.name',
-            { cwd: workspacePath }
+            { cwd: taskPath }
           );
           const db = (stdout || '').trim();
           if (db) defaultBranch = db;
@@ -411,7 +411,7 @@ current branch '${currentBranch}' ahead of base '${baseRef}'.`,
           try {
             const { stdout } = await execAsync(
               'git remote show origin | sed -n "/HEAD branch/s/.*: //p"',
-              { cwd: workspacePath }
+              { cwd: taskPath }
             );
             const db2 = (stdout || '').trim();
             if (db2) defaultBranch = db2;
@@ -423,19 +423,19 @@ current branch '${currentBranch}' ahead of base '${baseRef}'.`,
         if (createBranchIfOnDefault && (!currentBranch || currentBranch === defaultBranch)) {
           const short = Date.now().toString(36);
           const name = `${branchPrefix}/${short}`;
-          await execAsync(`git checkout -b ${JSON.stringify(name)}`, { cwd: workspacePath });
+          await execAsync(`git checkout -b ${JSON.stringify(name)}`, { cwd: taskPath });
           activeBranch = name;
         }
 
         // Stage (only if needed) and commit
         try {
-          const { stdout: st } = await execAsync('git status --porcelain', { cwd: workspacePath });
+          const { stdout: st } = await execAsync('git status --porcelain', { cwd: taskPath });
           const hasWorkingChanges = Boolean(st && st.trim().length > 0);
 
           const readStagedFiles = async () => {
             try {
               const { stdout } = await execAsync('git diff --cached --name-only', {
-                cwd: workspacePath,
+                cwd: taskPath,
               });
               return (stdout || '')
                 .split('\n')
@@ -450,18 +450,18 @@ current branch '${currentBranch}' ahead of base '${baseRef}'.`,
 
           // Only auto-stage everything when nothing is staged yet (preserves manual staging choices)
           if (hasWorkingChanges && stagedFiles.length === 0) {
-            await execAsync('git add -A', { cwd: workspacePath });
+            await execAsync('git add -A', { cwd: taskPath });
           }
 
           // Never commit plan mode artifacts
           try {
-            await execAsync('git reset -q .emdash || true', { cwd: workspacePath });
+            await execAsync('git reset -q .emdash || true', { cwd: taskPath });
           } catch {}
           try {
-            await execAsync('git reset -q PLANNING.md || true', { cwd: workspacePath });
+            await execAsync('git reset -q PLANNING.md || true', { cwd: taskPath });
           } catch {}
           try {
-            await execAsync('git reset -q planning.md || true', { cwd: workspacePath });
+            await execAsync('git reset -q planning.md || true', { cwd: taskPath });
           } catch {}
 
           stagedFiles = await readStagedFiles();
@@ -469,7 +469,7 @@ current branch '${currentBranch}' ahead of base '${baseRef}'.`,
           if (stagedFiles.length > 0) {
             try {
               await execAsync(`git commit -m ${JSON.stringify(commitMessage)}`, {
-                cwd: workspacePath,
+                cwd: taskPath,
               });
             } catch (commitErr) {
               const msg = commitErr as string;
@@ -482,14 +482,14 @@ current branch '${currentBranch}' ahead of base '${baseRef}'.`,
 
         // Push current branch (set upstream if needed)
         try {
-          await execAsync('git push', { cwd: workspacePath });
+          await execAsync('git push', { cwd: taskPath });
         } catch (pushErr) {
           await execAsync(`git push --set-upstream origin ${JSON.stringify(activeBranch)}`, {
-            cwd: workspacePath,
+            cwd: taskPath,
           });
         }
 
-        const { stdout: out } = await execAsync('git status -sb', { cwd: workspacePath });
+        const { stdout: out } = await execAsync('git status -sb', { cwd: taskPath });
         return { success: true, branch: activeBranch, output: (out || '').trim() };
       } catch (error) {
         log.error('Failed to commit and push:', error);
@@ -499,15 +499,15 @@ current branch '${currentBranch}' ahead of base '${baseRef}'.`,
   );
 
   // Git: Get branch status (current branch, default branch, ahead/behind counts)
-  ipcMain.handle('git:get-branch-status', async (_, args: { workspacePath: string }) => {
-    const { workspacePath } = args || ({} as { workspacePath: string });
+  ipcMain.handle('git:get-branch-status', async (_, args: { taskPath: string }) => {
+    const { taskPath } = args || ({} as { taskPath: string });
     try {
       // Ensure repo (avoid /bin/sh by using execFile)
-      await execFileAsync(GIT, ['rev-parse', '--is-inside-work-tree'], { cwd: workspacePath });
+      await execFileAsync(GIT, ['rev-parse', '--is-inside-work-tree'], { cwd: taskPath });
 
       // Current branch
       const { stdout: currentBranchOut } = await execFileAsync(GIT, ['branch', '--show-current'], {
-        cwd: workspacePath,
+        cwd: taskPath,
       });
       const branch = (currentBranchOut || '').trim();
 
@@ -517,7 +517,7 @@ current branch '${currentBranch}' ahead of base '${baseRef}'.`,
         const { stdout } = await execFileAsync(
           'gh',
           ['repo', 'view', '--json', 'defaultBranchRef', '-q', '.defaultBranchRef.name'],
-          { cwd: workspacePath }
+          { cwd: taskPath }
         );
         const db = (stdout || '').trim();
         if (db) defaultBranch = db;
@@ -527,7 +527,7 @@ current branch '${currentBranch}' ahead of base '${baseRef}'.`,
           const { stdout } = await execFileAsync(
             GIT,
             ['symbolic-ref', '--short', 'refs/remotes/origin/HEAD'],
-            { cwd: workspacePath }
+            { cwd: taskPath }
           );
           const line = (stdout || '').trim();
           const last = line.split('/').pop();
@@ -543,7 +543,7 @@ current branch '${currentBranch}' ahead of base '${baseRef}'.`,
         const { stdout } = await execFileAsync(
           GIT,
           ['rev-list', '--left-right', '--count', `origin/${defaultBranch}...HEAD`],
-          { cwd: workspacePath }
+          { cwd: taskPath }
         );
         const parts = (stdout || '').trim().split(/\s+/);
         if (parts.length >= 2) {
@@ -552,7 +552,7 @@ current branch '${currentBranch}' ahead of base '${baseRef}'.`,
         }
       } catch {
         try {
-          const { stdout } = await execFileAsync(GIT, ['status', '-sb'], { cwd: workspacePath });
+          const { stdout } = await execFileAsync(GIT, ['status', '-sb'], { cwd: taskPath });
           const line = (stdout || '').split(/\n/)[0] || '';
           const m = line.match(/ahead\s+(\d+)/i);
           const n = line.match(/behind\s+(\d+)/i);
diff --git a/src/main/ipc/hostPreviewIpc.ts b/src/main/ipc/hostPreviewIpc.ts
index 97c9437e..8a5b6a97 100644
--- a/src/main/ipc/hostPreviewIpc.ts
+++ b/src/main/ipc/hostPreviewIpc.ts
@@ -8,14 +8,14 @@ export function registerHostPreviewIpc() {
       _e,
       args: {
         taskId: string;
-        workspacePath: string;
+        taskPath: string;
         script?: string;
         parentProjectPath?: string;
       }
     ) => {
       const id = String(args?.taskId || '').trim();
-      const wp = String(args?.workspacePath || '').trim();
-      if (!id || !wp) return { ok: false, error: 'taskId and workspacePath are required' };
+      const wp = String(args?.taskPath || '').trim();
+      if (!id || !wp) return { ok: false, error: 'taskId and taskPath are required' };
       return hostPreviewService.start(id, wp, {
         script: args?.script,
         parentProjectPath: args?.parentProjectPath,
@@ -25,10 +25,10 @@ export function registerHostPreviewIpc() {
 
   ipcMain.handle(
     'preview:host:setup',
-    async (_e, args: { taskId: string; workspacePath: string }) => {
+    async (_e, args: { taskId: string; taskPath: string }) => {
       const id = String(args?.taskId || '').trim();
-      const wp = String(args?.workspacePath || '').trim();
-      if (!id || !wp) return { ok: false, error: 'taskId and workspacePath are required' };
+      const wp = String(args?.taskPath || '').trim();
+      if (!id || !wp) return { ok: false, error: 'taskId and taskPath are required' };
       return hostPreviewService.setup(id, wp);
     }
   );
diff --git a/src/main/preload.ts b/src/main/preload.ts
index 8e812719..77931c9a 100644
--- a/src/main/preload.ts
+++ b/src/main/preload.ts
@@ -111,7 +111,7 @@ contextBridge.exposeInMainWorld('electronAPI', {
     ipcRenderer.invoke('fs:write', { root, relPath, content, mkdirs }),
   fsRemove: (root: string, relPath: string) => ipcRenderer.invoke('fs:remove', { root, relPath }),
   // Attachments
-  saveAttachment: (args: { workspacePath: string; srcPath: string; subdir?: string }) =>
+  saveAttachment: (args: { taskPath: string; srcPath: string; subdir?: string }) =>
     ipcRenderer.invoke('fs:save-attachment', args),
 
   // Project management
@@ -123,21 +123,21 @@ contextBridge.exposeInMainWorld('electronAPI', {
   fetchProjectBaseRef: (args: { projectId: string; projectPath: string }) =>
     ipcRenderer.invoke('projectSettings:fetchBaseRef', args),
   getGitInfo: (projectPath: string) => ipcRenderer.invoke('git:getInfo', projectPath),
-  getGitStatus: (workspacePath: string) => ipcRenderer.invoke('git:get-status', workspacePath),
-  getFileDiff: (args: { workspacePath: string; filePath: string }) =>
+  getGitStatus: (taskPath: string) => ipcRenderer.invoke('git:get-status', taskPath),
+  getFileDiff: (args: { taskPath: string; filePath: string }) =>
     ipcRenderer.invoke('git:get-file-diff', args),
-  stageFile: (args: { workspacePath: string; filePath: string }) =>
+  stageFile: (args: { taskPath: string; filePath: string }) =>
     ipcRenderer.invoke('git:stage-file', args),
-  revertFile: (args: { workspacePath: string; filePath: string }) =>
+  revertFile: (args: { taskPath: string; filePath: string }) =>
     ipcRenderer.invoke('git:revert-file', args),
   gitCommitAndPush: (args: {
-    workspacePath: string;
+    taskPath: string;
     commitMessage?: string;
     createBranchIfOnDefault?: boolean;
     branchPrefix?: string;
   }) => ipcRenderer.invoke('git:commit-and-push', args),
   createPullRequest: (args: {
-    workspacePath: string;
+    taskPath: string;
     title?: string;
     body?: string;
     base?: string;
@@ -146,16 +146,16 @@ contextBridge.exposeInMainWorld('electronAPI', {
     web?: boolean;
     fill?: boolean;
   }) => ipcRenderer.invoke('git:create-pr', args),
-  getPrStatus: (args: { workspacePath: string }) => ipcRenderer.invoke('git:get-pr-status', args),
-  getBranchStatus: (args: { workspacePath: string }) =>
+  getPrStatus: (args: { taskPath: string }) => ipcRenderer.invoke('git:get-pr-status', args),
+  getBranchStatus: (args: { taskPath: string }) =>
     ipcRenderer.invoke('git:get-branch-status', args),
   listRemoteBranches: (args: { projectPath: string; remote?: string }) =>
     ipcRenderer.invoke('git:list-remote-branches', args),
-  loadContainerConfig: (workspacePath: string) =>
-    ipcRenderer.invoke('container:load-config', { workspacePath }),
+  loadContainerConfig: (taskPath: string) =>
+    ipcRenderer.invoke('container:load-config', { taskPath }),
   startContainerRun: (args: {
     taskId: string;
-    workspacePath: string;
+    taskPath: string;
     runId?: string;
     mode?: 'container' | 'host';
   }) => ipcRenderer.invoke('container:start-run', args),
@@ -163,7 +163,7 @@ contextBridge.exposeInMainWorld('electronAPI', {
     ipcRenderer.invoke('container:stop-run', { taskId }),
   inspectContainerRun: (taskId: string) =>
     ipcRenderer.invoke('container:inspect-run', { taskId }),
-  resolveServiceIcon: (args: { service: string; allowNetwork?: boolean; workspacePath?: string }) =>
+  resolveServiceIcon: (args: { service: string; allowNetwork?: boolean; taskPath?: string }) =>
     ipcRenderer.invoke('icons:resolve-service', args),
   openExternal: (url: string) => ipcRenderer.invoke('app:openExternal', url),
   // Telemetry (minimal, anonymous)
@@ -294,8 +294,8 @@ contextBridge.exposeInMainWorld('electronAPI', {
     ipcRenderer.invoke('debug:append-log', filePath, content, options ?? {}),
 
   // PlanMode strict lock
-  planApplyLock: (workspacePath: string) => ipcRenderer.invoke('plan:lock', workspacePath),
-  planReleaseLock: (workspacePath: string) => ipcRenderer.invoke('plan:unlock', workspacePath),
+  planApplyLock: (taskPath: string) => ipcRenderer.invoke('plan:lock', taskPath),
+  planReleaseLock: (taskPath: string) => ipcRenderer.invoke('plan:unlock', taskPath),
   onPlanEvent: (
     listener: (data: {
       type: 'write_blocked' | 'remove_blocked';
@@ -321,11 +321,11 @@ contextBridge.exposeInMainWorld('electronAPI', {
   // Host preview (non-container)
   hostPreviewStart: (args: {
     taskId: string;
-    workspacePath: string;
+    taskPath: string;
     script?: string;
     parentProjectPath?: string;
   }) => ipcRenderer.invoke('preview:host:start', args),
-  hostPreviewSetup: (args: { taskId: string; workspacePath: string }) =>
+  hostPreviewSetup: (args: { taskId: string; taskPath: string }) =>
     ipcRenderer.invoke('preview:host:setup', args),
   hostPreviewStop: (taskId: string) => ipcRenderer.invoke('preview:host:stop', taskId),
   hostPreviewStopAll: (exceptId?: string) => ipcRenderer.invoke('preview:host:stopAll', exceptId),
@@ -461,7 +461,7 @@ export interface ElectronAPI {
     rootPath?: string;
     error?: string;
   }>;
-  getGitStatus: (workspacePath: string) => Promise<{
+  getGitStatus: (taskPath: string) => Promise<{
     success: boolean;
     changes?: Array<{
       path: string;
@@ -472,19 +472,19 @@ export interface ElectronAPI {
     }>;
     error?: string;
   }>;
-  getFileDiff: (args: { workspacePath: string; filePath: string }) => Promise<{
+  getFileDiff: (args: { taskPath: string; filePath: string }) => Promise<{
     success: boolean;
     diff?: { lines: Array<{ left?: string; right?: string; type: 'context' | 'add' | 'del' }> };
     error?: string;
   }>;
   gitCommitAndPush: (args: {
-    workspacePath: string;
+    taskPath: string;
     commitMessage?: string;
     createBranchIfOnDefault?: boolean;
     branchPrefix?: string;
   }) => Promise<{ success: boolean; branch?: string; output?: string; error?: string }>;
   createPullRequest: (args: {
-    workspacePath: string;
+    taskPath: string;
     title?: string;
     body?: string;
     base?: string;
@@ -521,7 +521,7 @@ export interface ElectronAPI {
 
   onRunEvent: (callback: (event: any) => void) => void;
   removeRunEventListeners: () => void;
-  loadContainerConfig: (workspacePath: string) => Promise<
+  loadContainerConfig: (taskPath: string) => Promise<
     | { ok: true; config: any; sourcePath: string | null }
     | {
         ok: false;
@@ -541,7 +541,7 @@ export interface ElectronAPI {
   >;
   startContainerRun: (args: {
     taskId: string;
-    workspacePath: string;
+    taskPath: string;
     runId?: string;
     mode?: 'container' | 'host';
   }) => Promise<
@@ -646,13 +646,13 @@ export interface ElectronAPI {
   // Host preview (non-container)
   hostPreviewStart: (args: {
     taskId: string;
-    workspacePath: string;
+    taskPath: string;
     script?: string;
     parentProjectPath?: string;
   }) => Promise<{ ok: boolean; error?: string }>;
   hostPreviewSetup: (args: {
     taskId: string;
-    workspacePath: string;
+    taskPath: string;
   }) => Promise<{ ok: boolean; error?: string }>;
   hostPreviewStop: (taskId: string) => Promise<{ ok: boolean }>;
   onHostPreviewEvent: (
diff --git a/src/main/services/GitService.ts b/src/main/services/GitService.ts
index a906a704..4ab7f28b 100644
--- a/src/main/services/GitService.ts
+++ b/src/main/services/GitService.ts
@@ -13,17 +13,17 @@ export type GitChange = {
   isStaged: boolean;
 };
 
-export async function getStatus(workspacePath: string): Promise<GitChange[]> {
+export async function getStatus(taskPath: string): Promise<GitChange[]> {
   try {
     await execFileAsync('git', ['rev-parse', '--is-inside-work-tree'], {
-      cwd: workspacePath,
+      cwd: taskPath,
     });
   } catch {
     return [];
   }
 
   const { stdout: statusOutput } = await execFileAsync('git', ['status', '--porcelain'], {
-    cwd: workspacePath,
+    cwd: taskPath,
   });
 
   if (!statusOutput.trim()) return [];
@@ -76,20 +76,20 @@ export async function getStatus(workspacePath: string): Promise<GitChange[]> {
 
     try {
       const staged = await execFileAsync('git', ['diff', '--numstat', '--cached', '--', filePath], {
-        cwd: workspacePath,
+        cwd: taskPath,
       });
       if (staged.stdout && staged.stdout.trim()) sumNumstat(staged.stdout);
     } catch {}
 
     try {
       const unstaged = await execFileAsync('git', ['diff', '--numstat', '--', filePath], {
-        cwd: workspacePath,
+        cwd: taskPath,
       });
       if (unstaged.stdout && unstaged.stdout.trim()) sumNumstat(unstaged.stdout);
     } catch {}
 
     if (additions === 0 && deletions === 0 && statusCode.includes('?')) {
-      const absPath = path.join(workspacePath, filePath);
+      const absPath = path.join(taskPath, filePath);
       try {
         const stat = fs.existsSync(absPath) ? fs.statSync(absPath) : undefined;
         if (stat && stat.isFile()) {
@@ -107,12 +107,12 @@ export async function getStatus(workspacePath: string): Promise<GitChange[]> {
   return changes;
 }
 
-export async function stageFile(workspacePath: string, filePath: string): Promise<void> {
-  await execFileAsync('git', ['add', '--', filePath], { cwd: workspacePath });
+export async function stageFile(taskPath: string, filePath: string): Promise<void> {
+  await execFileAsync('git', ['add', '--', filePath], { cwd: taskPath });
 }
 
 export async function revertFile(
-  workspacePath: string,
+  taskPath: string,
   filePath: string
 ): Promise<{ action: 'unstaged' | 'reverted' }> {
   // Check if file is staged
@@ -121,31 +121,31 @@ export async function revertFile(
       'git',
       ['diff', '--cached', '--name-only', '--', filePath],
       {
-        cwd: workspacePath,
+        cwd: taskPath,
       }
     );
 
     if (stagedStatus.trim()) {
       // File is staged, unstage it (but keep working directory changes)
-      await execFileAsync('git', ['reset', 'HEAD', '--', filePath], { cwd: workspacePath });
+      await execFileAsync('git', ['reset', 'HEAD', '--', filePath], { cwd: taskPath });
       return { action: 'unstaged' };
     }
   } catch {}
 
   // File is not staged, revert working directory changes
-  await execFileAsync('git', ['checkout', 'HEAD', '--', filePath], { cwd: workspacePath });
+  await execFileAsync('git', ['checkout', 'HEAD', '--', filePath], { cwd: taskPath });
   return { action: 'reverted' };
 }
 
 export async function getFileDiff(
-  workspacePath: string,
+  taskPath: string,
   filePath: string
 ): Promise<{ lines: Array<{ left?: string; right?: string; type: 'context' | 'add' | 'del' }> }> {
   try {
     const { stdout } = await execFileAsync(
       'git',
       ['diff', '--no-color', '--unified=2000', 'HEAD', '--', filePath],
-      { cwd: workspacePath }
+      { cwd: taskPath }
     );
 
     const linesRaw = stdout.split('\n');
@@ -170,13 +170,13 @@ export async function getFileDiff(
 
     if (result.length === 0) {
       try {
-        const abs = path.join(workspacePath, filePath);
+        const abs = path.join(taskPath, filePath);
         if (fs.existsSync(abs)) {
           const content = fs.readFileSync(abs, 'utf8');
           return { lines: content.split('\n').map((l) => ({ right: l, type: 'add' as const })) };
         } else {
           const { stdout: prev } = await execFileAsync('git', ['show', `HEAD:${filePath}`], {
-            cwd: workspacePath,
+            cwd: taskPath,
           });
           return { lines: prev.split('\n').map((l) => ({ left: l, type: 'del' as const })) };
         }
@@ -188,7 +188,7 @@ export async function getFileDiff(
     return { lines: result };
   } catch {
     try {
-      const abs = path.join(workspacePath, filePath);
+      const abs = path.join(taskPath, filePath);
       const content = fs.readFileSync(abs, 'utf8');
       const lines = content.split('\n');
       return { lines: lines.map((l) => ({ right: l, type: 'add' as const })) };
@@ -197,7 +197,7 @@ export async function getFileDiff(
         const { stdout } = await execFileAsync(
           'git',
           ['diff', '--no-color', '--unified=2000', 'HEAD', '--', filePath],
-          { cwd: workspacePath }
+          { cwd: taskPath }
         );
         const linesRaw = stdout.split('\n');
         const result: Array<{ left?: string; right?: string; type: 'context' | 'add' | 'del' }> =
@@ -222,7 +222,7 @@ export async function getFileDiff(
         if (result.length === 0) {
           try {
             const { stdout: prev } = await execFileAsync('git', ['show', `HEAD:${filePath}`], {
-              cwd: workspacePath,
+              cwd: taskPath,
             });
             return { lines: prev.split('\n').map((l) => ({ left: l, type: 'del' as const })) };
           } catch {
diff --git a/src/main/services/containerConfigService.ts b/src/main/services/containerConfigService.ts
index 4a0fdac4..05cdcf48 100644
--- a/src/main/services/containerConfigService.ts
+++ b/src/main/services/containerConfigService.ts
@@ -56,10 +56,10 @@ export interface ContainerConfigLoadFailure {
 export type ContainerConfigLoadResult = ContainerConfigLoadSuccess | ContainerConfigLoadFailure;
 
 export async function loadWorkspaceContainerConfig(
-  workspacePath: string
+  taskPath: string
 ): Promise<ContainerConfigLoadResult> {
-  const configPath = path.join(workspacePath, CONFIG_RELATIVE_PATH);
-  const inferredPackageManager = inferPackageManager(workspacePath);
+  const configPath = path.join(taskPath, CONFIG_RELATIVE_PATH);
+  const inferredPackageManager = inferPackageManager(taskPath);
 
   const readResult = await readConfigFile(configPath);
   if (readResult.error) {
@@ -97,9 +97,9 @@ export async function loadWorkspaceContainerConfig(
   }
 }
 
-function inferPackageManager(workspacePath: string): PackageManager | undefined {
+function inferPackageManager(taskPath: string): PackageManager | undefined {
   for (const { file, manager } of PACKAGE_MANAGER_LOCKFILES) {
-    const candidate = path.join(workspacePath, file);
+    const candidate = path.join(taskPath, file);
     if (fs.existsSync(candidate)) {
       return manager;
     }
@@ -150,6 +150,6 @@ function parseConfigJson(
   }
 }
 
-export function inferPackageManagerForWorkspace(workspacePath: string): PackageManager | undefined {
-  return inferPackageManager(workspacePath);
+export function inferPackageManagerForWorkspace(taskPath: string): PackageManager | undefined {
+  return inferPackageManager(taskPath);
 }
diff --git a/src/main/services/containerRunnerService.ts b/src/main/services/containerRunnerService.ts
index 9eb491a2..74bdcfc1 100644
--- a/src/main/services/containerRunnerService.ts
+++ b/src/main/services/containerRunnerService.ts
@@ -55,7 +55,7 @@ export interface ContainerStartError {
 
 export interface ContainerStartOptions {
   taskId: string;
-  workspacePath: string;
+  taskPath: string;
   runId?: string;
   mode?: RunnerMode;
   now?: () => number;
@@ -93,10 +93,10 @@ export class ContainerRunnerService extends EventEmitter {
     return this;
   }
 
-  private findComposeFile(workspacePath: string): string | null {
+  private findComposeFile(taskPath: string): string | null {
     const candidates = ['docker-compose.yml', 'docker-compose.yaml', 'compose.yml', 'compose.yaml'];
     for (const rel of candidates) {
-      const abs = path.join(workspacePath, rel);
+      const abs = path.join(taskPath, rel);
       if (fs.existsSync(abs)) return abs;
     }
     return null;
@@ -104,14 +104,14 @@ export class ContainerRunnerService extends EventEmitter {
 
   private async startComposeRun(args: {
     taskId: string;
-    workspacePath: string;
+    taskPath: string;
     runId: string;
     mode: RunnerMode;
     config: ResolvedContainerConfig;
     now: () => number;
     composeFile: string;
   }): Promise<ContainerStartResult> {
-    const { taskId, workspacePath, runId, mode, config, now, composeFile } = args;
+    const { taskId, taskPath, runId, mode, config, now, composeFile } = args;
     const execAsync = promisify(exec);
     const project = `emdash_ws_${taskId}`;
 
@@ -164,7 +164,7 @@ export class ContainerRunnerService extends EventEmitter {
       }
 
       // Always attempt autodiscovery first to avoid introducing unknown services (e.g. default 'app')
-      const discovered = await this.discoverComposePorts(composeFile, workspacePath);
+      const discovered = await this.discoverComposePorts(composeFile, taskPath);
       let portRequests: ResolvedContainerPortConfig[] = [];
       if (discovered.length > 0) {
         portRequests = discovered.map((d) => ({
@@ -194,12 +194,12 @@ export class ContainerRunnerService extends EventEmitter {
       }
 
       // Build a sanitized compose file that removes host bindings (ports) and replaces with expose
-      const sanitizedAbs = path.join(workspacePath, '.emdash', 'compose.sanitized.json');
+      const sanitizedAbs = path.join(taskPath, '.emdash', 'compose.sanitized.json');
       try {
         fs.mkdirSync(path.dirname(sanitizedAbs), { recursive: true });
       } catch {}
       try {
-        const cfgJson = await this.loadComposeConfigJson(composeFile, workspacePath);
+        const cfgJson = await this.loadComposeConfigJson(composeFile, taskPath);
         const portMap = new Map<string, number[]>();
         for (const req of portRequests) {
           const arr = portMap.get(req.service) ?? [];
@@ -213,7 +213,7 @@ export class ContainerRunnerService extends EventEmitter {
       }
 
       // Write override file mapping container ports -> random host ports
-      const overrideAbs = path.join(workspacePath, '.emdash', 'compose.override.yml');
+      const overrideAbs = path.join(taskPath, '.emdash', 'compose.override.yml');
       try {
         fs.mkdirSync(path.dirname(overrideAbs), { recursive: true });
       } catch {}
@@ -221,7 +221,7 @@ export class ContainerRunnerService extends EventEmitter {
 
       // Run compose up -d
       const argsArr: string[] = ['compose'];
-      const envFileAbs = config.envFile ? path.resolve(workspacePath, config.envFile) : null;
+      const envFileAbs = config.envFile ? path.resolve(taskPath, config.envFile) : null;
       if (envFileAbs && fs.existsSync(envFileAbs)) argsArr.push('--env-file', envFileAbs);
       // Prefer sanitized file when available
       const composePathForUp = fs.existsSync(sanitizedAbs) ? sanitizedAbs : composeFile;
@@ -319,11 +319,11 @@ export class ContainerRunnerService extends EventEmitter {
     return result.length ? result : allocated;
   }
 
-  private async loadComposeConfigJson(composeFile: string, workspacePath: string): Promise<any> {
+  private async loadComposeConfigJson(composeFile: string, taskPath: string): Promise<any> {
     const execAsync = promisify(exec);
     const { stdout } = await execAsync(
       `docker compose -f ${JSON.stringify(composeFile)} config --format json`,
-      { cwd: workspacePath }
+      { cwd: taskPath }
     );
     try {
       return JSON.parse(stdout || '{}');
@@ -359,13 +359,13 @@ export class ContainerRunnerService extends EventEmitter {
 
   private async discoverComposePorts(
     composeFile: string,
-    workspacePath: string
+    taskPath: string
   ): Promise<Array<{ service: string; container: number }>> {
     const execAsync = promisify(exec);
     try {
       const { stdout } = await execAsync(
         `docker compose -f ${JSON.stringify(composeFile)} config --format json`,
-        { cwd: workspacePath }
+        { cwd: taskPath }
       );
       const cfg = JSON.parse(stdout || '{}');
       const services = cfg?.services || cfg?.Services || {};
@@ -503,13 +503,13 @@ export class ContainerRunnerService extends EventEmitter {
   }
 
   private async _startRunImpl(options: ContainerStartOptions): Promise<ContainerStartResult> {
-    const { taskId, workspacePath } = options;
-    if (!taskId || !workspacePath) {
+    const { taskId, taskPath } = options;
+    if (!taskId || !taskPath) {
       return {
         ok: false,
         error: {
           code: 'INVALID_ARGUMENT',
-          message: '`taskId` and `workspacePath` are required',
+          message: '`taskId` and `taskPath` are required',
           configKey: null,
           configPath: null,
         },
@@ -517,7 +517,7 @@ export class ContainerRunnerService extends EventEmitter {
     }
 
     // Load container config
-    const loadResult = await this.loadConfig(workspacePath);
+    const loadResult = await this.loadConfig(taskPath);
     if (loadResult.ok === false) {
       return {
         ok: false,
@@ -571,7 +571,7 @@ export class ContainerRunnerService extends EventEmitter {
 
     try {
       // Host-side preflight checks to prevent unintended workspace mutations
-      const absWorkspace = path.resolve(workspacePath);
+      const absWorkspace = path.resolve(taskPath);
       const workdirAbs = path.resolve(absWorkspace, config.workdir);
 
       if (!fs.existsSync(workdirAbs)) {
@@ -651,7 +651,7 @@ export class ContainerRunnerService extends EventEmitter {
         log.info('[containers] compose detected; delegating to compose runner');
         return await this.startComposeRun({
           taskId,
-          workspacePath: absWorkspace,
+          taskPath: absWorkspace,
           runId,
           mode,
           config,
@@ -698,7 +698,7 @@ export class ContainerRunnerService extends EventEmitter {
 
       // Env file (optional)
       if (config.envFile) {
-        const envAbs = path.resolve(workspacePath, config.envFile);
+        const envAbs = path.resolve(taskPath, config.envFile);
         if (!fs.existsSync(envAbs)) {
           const message = `Env file not found: ${envAbs}`;
           this.emitRunnerEvent({
@@ -833,20 +833,20 @@ export class ContainerRunnerService extends EventEmitter {
   }
 
   async startMockRun(options: ContainerStartOptions): Promise<ContainerStartResult> {
-    const { taskId, workspacePath } = options;
-    if (!taskId || !workspacePath) {
+    const { taskId, taskPath } = options;
+    if (!taskId || !taskPath) {
       return {
         ok: false,
         error: {
           code: 'INVALID_ARGUMENT',
-          message: '`taskId` and `workspacePath` are required',
+          message: '`taskId` and `taskPath` are required',
           configKey: null,
           configPath: null,
         },
       };
     }
 
-    const loadResult = await this.loadConfig(workspacePath);
+    const loadResult = await this.loadConfig(taskPath);
     if (loadResult.ok === false) {
       return {
         ok: false,
@@ -896,8 +896,8 @@ export class ContainerRunnerService extends EventEmitter {
     }
   }
 
-  private async loadConfig(workspacePath: string): Promise<ContainerConfigLoadResult> {
-    return loadWorkspaceContainerConfig(workspacePath);
+  private async loadConfig(taskPath: string): Promise<ContainerConfigLoadResult> {
+    return loadWorkspaceContainerConfig(taskPath);
   }
 
   private serializeConfigError(error: ContainerConfigLoadError): ContainerStartError {
diff --git a/src/main/services/fsIpc.ts b/src/main/services/fsIpc.ts
index a3b8c8fd..5c8b42a9 100644
--- a/src/main/services/fsIpc.ts
+++ b/src/main/services/fsIpc.ts
@@ -158,11 +158,11 @@ export function registerFsIpc(): void {
   // Save an attachment (e.g., image) into a workspace-managed folder
   ipcMain.handle(
     'fs:save-attachment',
-    async (_event, args: { workspacePath: string; srcPath: string; subdir?: string }) => {
+    async (_event, args: { taskPath: string; srcPath: string; subdir?: string }) => {
       try {
-        const { workspacePath, srcPath } = args;
-        if (!workspacePath || !fs.existsSync(workspacePath))
-          return { success: false, error: 'Invalid workspacePath' };
+        const { taskPath, srcPath } = args;
+        if (!taskPath || !fs.existsSync(taskPath))
+          return { success: false, error: 'Invalid taskPath' };
         if (!srcPath || !fs.existsSync(srcPath))
           return { success: false, error: 'Invalid srcPath' };
 
@@ -172,7 +172,7 @@ export function registerFsIpc(): void {
         }
 
         const baseDir = path.join(
-          workspacePath,
+          taskPath,
           '.emdash',
           args.subdir || DEFAULT_ATTACHMENTS_SUBDIR
         );
@@ -191,7 +191,7 @@ export function registerFsIpc(): void {
 
         fs.copyFileSync(srcPath, destAbs);
 
-        const relFromWorkspace = path.relative(workspacePath, destAbs);
+        const relFromWorkspace = path.relative(taskPath, destAbs);
         return {
           success: true,
           absPath: destAbs,
diff --git a/src/main/services/hostPreviewService.ts b/src/main/services/hostPreviewService.ts
index 7a3f6750..a633368c 100644
--- a/src/main/services/hostPreviewService.ts
+++ b/src/main/services/hostPreviewService.ts
@@ -42,9 +42,9 @@ class HostPreviewService extends EventEmitter {
 
   async setup(
     taskId: string,
-    workspacePath: string
+    taskPath: string
   ): Promise<{ ok: boolean; error?: string }> {
-    const cwd = path.resolve(workspacePath);
+    const cwd = path.resolve(taskPath);
     const pm = detectPackageManager(cwd);
     const cmd = pm;
     // Prefer clean install for npm when lockfile exists
@@ -122,15 +122,15 @@ class HostPreviewService extends EventEmitter {
 
   async start(
     taskId: string,
-    workspacePath: string,
+    taskPath: string,
     opts?: { script?: string; parentProjectPath?: string }
   ): Promise<{ ok: boolean; error?: string }> {
-    const cwd = path.resolve(workspacePath);
+    const cwd = path.resolve(taskPath);
 
     // Log the resolved path to help debug worktree issues
     log.info?.('[hostPreview] start', {
       taskId,
-      workspacePath,
+      taskPath,
       resolvedCwd: cwd,
       cwdExists: fs.existsSync(cwd),
       hasPackageJson: fs.existsSync(path.join(cwd, 'package.json')),
diff --git a/src/main/services/iconService.ts b/src/main/services/iconService.ts
index df22e390..c3a49ac6 100644
--- a/src/main/services/iconService.ts
+++ b/src/main/services/iconService.ts
@@ -125,7 +125,7 @@ async function fetchHttps(
 
 export async function resolveServiceIcon(opts: {
   service: string;
-  workspacePath?: string;
+  taskPath?: string;
   allowNetwork?: boolean;
 }): Promise<{ ok: true; dataUrl: string } | { ok: false }> {
   const service = opts.service?.trim();
@@ -133,8 +133,8 @@ export async function resolveServiceIcon(opts: {
   const slug = toSlug(service);
 
   // 1) Workspace overrides
-  if (opts.workspacePath) {
-    const p = path.join(opts.workspacePath, '.emdash', 'service-icons');
+  if (opts.taskPath) {
+    const p = path.join(opts.taskPath, '.emdash', 'service-icons');
     const candidates = ['.svg', '.png', '.jpg', '.jpeg', '.ico'].map((ext) =>
       path.join(p, `${slug}${ext}`)
     );
diff --git a/src/main/services/planLockIpc.ts b/src/main/services/planLockIpc.ts
index 442b0327..55c2d6b1 100644
--- a/src/main/services/planLockIpc.ts
+++ b/src/main/services/planLockIpc.ts
@@ -130,18 +130,18 @@ function releaseLock(root: string): { success: boolean; restored: number; error?
 }
 
 export function registerPlanLockIpc(): void {
-  ipcMain.handle('plan:lock', async (_e, workspacePath: string) => {
+  ipcMain.handle('plan:lock', async (_e, taskPath: string) => {
     if (isWindows()) {
       // Best-effort: still attempt chmod; ACL hardening could be added with icacls in a future pass
-      return applyLock(workspacePath);
+      return applyLock(taskPath);
     }
-    return applyLock(workspacePath);
+    return applyLock(taskPath);
   });
 
-  ipcMain.handle('plan:unlock', async (_e, workspacePath: string) => {
+  ipcMain.handle('plan:unlock', async (_e, taskPath: string) => {
     if (isWindows()) {
-      return releaseLock(workspacePath);
+      return releaseLock(taskPath);
     }
-    return releaseLock(workspacePath);
+    return releaseLock(taskPath);
   });
 }
diff --git a/src/renderer/App.tsx b/src/renderer/App.tsx
index ab0fb7f9..957bb226 100644
--- a/src/renderer/App.tsx
+++ b/src/renderer/App.tsx
@@ -1662,7 +1662,7 @@ const AppContent: React.FC = () => {
                   : null
               }
               taskId={activeTask?.id || null}
-              workspacePath={activeTask?.path || null}
+              taskPath={activeTask?.path || null}
               projectPath={selectedProject?.path || null}
               isWorkspaceMultiAgent={Boolean(activeTask?.metadata?.multiAgent?.enabled)}
               githubUser={user}
@@ -1772,7 +1772,7 @@ const AppContent: React.FC = () => {
             <Toaster />
             <BrowserPane
               taskId={activeTask?.id || null}
-              workspacePath={activeTask?.path || null}
+              taskPath={activeTask?.path || null}
               overlayActive={
                 showSettings || showCommandPalette || showTaskModal || showFirstLaunchModal
               }
diff --git a/src/renderer/components/BrowserPane.tsx b/src/renderer/components/BrowserPane.tsx
index 1521a4fb..b147753c 100644
--- a/src/renderer/components/BrowserPane.tsx
+++ b/src/renderer/components/BrowserPane.tsx
@@ -25,7 +25,7 @@ const DEFAULT_PREVIEW_URLS = [
 
 const BrowserPane: React.FC<{
   taskId?: string | null;
-  workspacePath?: string | null;
+  taskPath?: string | null;
   overlayActive?: boolean;
 }> = ({ taskId, overlayActive = false }) => {
   const {
diff --git a/src/renderer/components/ChangesDiffModal.tsx b/src/renderer/components/ChangesDiffModal.tsx
index ece2bfb4..bc499f77 100644
--- a/src/renderer/components/ChangesDiffModal.tsx
+++ b/src/renderer/components/ChangesDiffModal.tsx
@@ -12,7 +12,7 @@ import { getLanguageFromPath } from '../lib/languageUtils';
 interface ChangesDiffModalProps {
   open: boolean;
   onClose: () => void;
-  workspacePath: string;
+  taskPath: string;
   files: FileChange[];
   initialFile?: string;
   onRefreshChanges?: () => Promise<void> | void;
@@ -98,14 +98,14 @@ const HighlightedLine: React.FC<{
 export const ChangesDiffModal: React.FC<ChangesDiffModalProps> = ({
   open,
   onClose,
-  workspacePath,
+  taskPath,
   files,
   initialFile,
   onRefreshChanges,
 }) => {
   const [selected, setSelected] = useState<string | undefined>(initialFile || files[0]?.path);
   const [refreshKey, setRefreshKey] = useState(0);
-  const { lines, loading } = useFileDiff(workspacePath, selected, refreshKey);
+  const { lines, loading } = useFileDiff(taskPath, selected, refreshKey);
   const shouldReduceMotion = useReducedMotion();
   const { toast } = useToast();
   const [expandedSections, setExpandedSections] = useState<Set<number>>(new Set());
@@ -245,7 +245,7 @@ export const ChangesDiffModal: React.FC<ChangesDiffModalProps> = ({
   const loadWorkingCopy = async (pathRel: string) => {
     setEditorLoading(true);
     try {
-      const res = await window.electronAPI.fsRead(workspacePath, pathRel, 512 * 1024);
+      const res = await window.electronAPI.fsRead(taskPath, pathRel, 512 * 1024);
       if (!res?.success) {
         toast({ title: 'Cannot Edit', description: res?.error || 'Failed to read file.' });
         setIsEditing(false);
@@ -477,7 +477,7 @@ export const ChangesDiffModal: React.FC<ChangesDiffModalProps> = ({
                           try {
                             const contentToWrite = editorValue.replace(/\n/g, eol);
                             const res = await window.electronAPI.fsWriteFile(
-                              workspacePath,
+                              taskPath,
                               selected,
                               contentToWrite,
                               true
@@ -728,7 +728,7 @@ export const ChangesDiffModal: React.FC<ChangesDiffModalProps> = ({
                                       try {
                                         const contentToWrite = editorValue.replace(/\n/g, eol);
                                         const res = await window.electronAPI.fsWriteFile(
-                                          workspacePath,
+                                          taskPath,
                                           selected!,
                                           contentToWrite,
                                           true
diff --git a/src/renderer/components/ChatInterface.tsx b/src/renderer/components/ChatInterface.tsx
index 3bc85d53..64beb440 100644
--- a/src/renderer/components/ChatInterface.tsx
+++ b/src/renderer/components/ChatInterface.tsx
@@ -81,7 +81,7 @@ const ChatInterface: React.FC<Props> = ({
     enabled: planEnabled,
     providerId: provider,
     taskId: task.id,
-    workspacePath: task.path,
+    taskPath: task.path,
   });
 
   useEffect(() => {
@@ -502,7 +502,7 @@ const ChatInterface: React.FC<Props> = ({
             const res = await api.resolveServiceIcon({
               service: name,
               allowNetwork: true,
-              workspacePath: task.path,
+              taskPath: task.path,
             });
             if (!cancelled && res?.ok && typeof res.dataUrl === 'string') setSrc(res.dataUrl);
           } catch {}
diff --git a/src/renderer/components/ContainerStatusBadge.tsx b/src/renderer/components/ContainerStatusBadge.tsx
index 8c7f57b1..342b3fc9 100644
--- a/src/renderer/components/ContainerStatusBadge.tsx
+++ b/src/renderer/components/ContainerStatusBadge.tsx
@@ -12,7 +12,7 @@ interface Props {
   onStart: (e: React.MouseEvent) => void | Promise<void>;
   onStop: (e: React.MouseEvent) => void | Promise<void>;
   showStop?: boolean; // optionally hide stop control (e.g., read-only view)
-  workspacePath?: string; // optional: used to detect compose and tweak tooltip copy
+  taskPath?: string; // optional: used to detect compose and tweak tooltip copy
 }
 
 export const ContainerStatusBadge: React.FC<Props> = ({
@@ -24,14 +24,14 @@ export const ContainerStatusBadge: React.FC<Props> = ({
   onStart,
   onStop,
   showStop = true,
-  workspacePath,
+  taskPath,
 }) => {
   const [hasCompose, setHasCompose] = React.useState(false);
   React.useEffect(() => {
     let cancelled = false;
     (async () => {
       try {
-        if (!workspacePath) return;
+        if (!taskPath) return;
         const api: any = (window as any).electronAPI;
         const candidates = [
           'docker-compose.yml',
@@ -40,7 +40,7 @@ export const ContainerStatusBadge: React.FC<Props> = ({
           'compose.yaml',
         ];
         for (const file of candidates) {
-          const res = await api?.fsRead?.(workspacePath, file, 1);
+          const res = await api?.fsRead?.(taskPath, file, 1);
           if (!cancelled && res?.success) {
             setHasCompose(true);
             return;
@@ -54,7 +54,7 @@ export const ContainerStatusBadge: React.FC<Props> = ({
     return () => {
       cancelled = true;
     };
-  }, [workspacePath]);
+  }, [taskPath]);
 
   if (!active) {
     return (
diff --git a/src/renderer/components/FileChangesPanel.tsx b/src/renderer/components/FileChangesPanel.tsx
index 053e2fec..4e6714e7 100644
--- a/src/renderer/components/FileChangesPanel.tsx
+++ b/src/renderer/components/FileChangesPanel.tsx
@@ -41,7 +41,7 @@ const FileChangesPanelComponent: React.FC<FileChangesPanelProps> = ({ taskId, cl
       }
       setBranchStatusLoading(true);
       try {
-        const res = await window.electronAPI.getBranchStatus({ workspacePath: taskId });
+        const res = await window.electronAPI.getBranchStatus({ taskPath: taskId });
         if (!cancelled) {
           setBranchAhead(res?.success ? (res?.ahead ?? 0) : 0);
         }
@@ -64,7 +64,7 @@ const FileChangesPanelComponent: React.FC<FileChangesPanelProps> = ({ taskId, cl
 
     try {
       const result = await window.electronAPI.stageFile({
-        workspacePath: taskId,
+        taskPath: taskId,
         filePath,
       });
 
@@ -98,7 +98,7 @@ const FileChangesPanelComponent: React.FC<FileChangesPanelProps> = ({ taskId, cl
 
     try {
       const result = await window.electronAPI.revertFile({
-        workspacePath: taskId,
+        taskPath: taskId,
         filePath,
       });
 
@@ -155,7 +155,7 @@ const FileChangesPanelComponent: React.FC<FileChangesPanelProps> = ({ taskId, cl
     setIsCommitting(true);
     try {
       const result = await window.electronAPI.gitCommitAndPush({
-        workspacePath: taskId,
+        taskPath: taskId,
         commitMessage: commitMessage.trim(),
         createBranchIfOnDefault: true,
         branchPrefix: 'feature',
@@ -174,7 +174,7 @@ const FileChangesPanelComponent: React.FC<FileChangesPanelProps> = ({ taskId, cl
         // Proactively load branch status so the Create PR button appears immediately
         try {
           setBranchStatusLoading(true);
-          const bs = await window.electronAPI.getBranchStatus({ workspacePath: taskId });
+          const bs = await window.electronAPI.getBranchStatus({ taskPath: taskId });
           setBranchAhead(bs?.success ? (bs?.ahead ?? 0) : 0);
         } catch {
           setBranchAhead(0);
@@ -252,7 +252,7 @@ const FileChangesPanelComponent: React.FC<FileChangesPanelProps> = ({ taskId, cl
                 title="Commit all changes and create a pull request"
                 onClick={async () => {
                   await createPR({
-                    workspacePath: taskId,
+                    taskPath: taskId,
                     onSuccess: async () => {
                       await refreshChanges();
                       try {
@@ -331,7 +331,7 @@ const FileChangesPanelComponent: React.FC<FileChangesPanelProps> = ({ taskId, cl
                   title="Create a pull request for the current branch"
                   onClick={async () => {
                     await createPR({
-                      workspacePath: taskId,
+                      taskPath: taskId,
                       onSuccess: async () => {
                         await refreshChanges();
                         try {
@@ -434,7 +434,7 @@ const FileChangesPanelComponent: React.FC<FileChangesPanelProps> = ({ taskId, cl
         <ChangesDiffModal
           open={showDiffModal}
           onClose={() => setShowDiffModal(false)}
-          workspacePath={taskId}
+          taskPath={taskId}
           files={fileChanges}
           initialFile={selectedPath}
           onRefreshChanges={refreshChanges}
diff --git a/src/renderer/components/ProjectMainView.tsx b/src/renderer/components/ProjectMainView.tsx
index 14c1f731..1ba8aa71 100644
--- a/src/renderer/components/ProjectMainView.tsx
+++ b/src/renderer/components/ProjectMainView.tsx
@@ -148,7 +148,7 @@ function WorkspaceRow({
       setIsStartingContainer(true);
       const res = await startContainerRun({
         taskId: ws.id,
-        workspacePath: ws.path,
+        taskPath: ws.path,
         mode: 'container',
       });
       if (res?.ok !== true) {
@@ -294,7 +294,7 @@ function WorkspaceRow({
               stoppingAction={isStoppingContainer}
               onStart={handleStartContainer}
               onStop={handleStopContainer}
-              workspacePath={ws.path}
+              taskPath={ws.path}
             />
           )}
           {containerActive ? (
@@ -352,7 +352,7 @@ function WorkspaceRow({
             <WorkspaceDeleteButton
               workspaceName={ws.name}
               taskId={ws.id}
-              workspacePath={ws.path}
+              taskPath={ws.path}
               onConfirm={async () => {
                 try {
                   setIsDeleting(true);
@@ -374,7 +374,7 @@ function WorkspaceRow({
           <WorkspacePorts
             key={`ports-${ws.id}`}
             taskId={ws.id}
-            workspacePath={ws.path}
+            taskPath={ws.path}
             ports={ports}
             previewUrl={previewUrl}
             previewService={previewService}
@@ -567,7 +567,7 @@ const ProjectMainView: React.FC<ProjectMainViewProps> = ({
           const [statusRes, infoRes, prRes] = await Promise.allSettled([
             window.electronAPI.getGitStatus(ws.path),
             window.electronAPI.getGitInfo(ws.path),
-            window.electronAPI.getPrStatus({ workspacePath: ws.path }),
+            window.electronAPI.getPrStatus({ taskPath: ws.path }),
           ]);
 
           let staged = 0;
diff --git a/src/renderer/components/TaskDeleteButton.tsx b/src/renderer/components/TaskDeleteButton.tsx
index bde5e371..5ee482a6 100644
--- a/src/renderer/components/TaskDeleteButton.tsx
+++ b/src/renderer/components/TaskDeleteButton.tsx
@@ -21,7 +21,7 @@ import DeletePrNotice from './DeletePrNotice';
 type Props = {
   workspaceName: string;
   taskId: string;
-  workspacePath: string;
+  taskPath: string;
   onConfirm: () => void | Promise<void | boolean>;
   className?: string;
   'aria-label'?: string;
@@ -31,7 +31,7 @@ type Props = {
 export const WorkspaceDeleteButton: React.FC<Props> = ({
   workspaceName,
   taskId,
-  workspacePath,
+  taskPath,
   onConfirm,
   className,
   'aria-label': ariaLabel = 'Delete Task',
@@ -40,8 +40,8 @@ export const WorkspaceDeleteButton: React.FC<Props> = ({
   const [open, setOpen] = React.useState(false);
   const [acknowledge, setAcknowledge] = React.useState(false);
   const targets = useMemo(
-    () => [{ id: taskId, name: workspaceName, path: workspacePath }],
-    [taskId, workspaceName, workspacePath]
+    () => [{ id: taskId, name: workspaceName, path: taskPath }],
+    [taskId, workspaceName, taskPath]
   );
   const { risks, loading, hasData } = useDeleteRisks(targets, open);
   const status = risks[taskId] || {
diff --git a/src/renderer/components/TaskItem.tsx b/src/renderer/components/TaskItem.tsx
index 7cf4d1db..994e58f5 100644
--- a/src/renderer/components/TaskItem.tsx
+++ b/src/renderer/components/TaskItem.tsx
@@ -52,7 +52,7 @@ export const TaskItem: React.FC<TaskItemProps> = ({
           <TaskDeleteButton
             workspaceName={task.name}
             taskId={task.id}
-            workspacePath={task.path}
+            taskPath={task.path}
             onConfirm={async () => {
               try {
                 setIsDeleting(true);
diff --git a/src/renderer/components/TaskPorts.tsx b/src/renderer/components/TaskPorts.tsx
index b7df210a..b12abc21 100644
--- a/src/renderer/components/TaskPorts.tsx
+++ b/src/renderer/components/TaskPorts.tsx
@@ -7,7 +7,7 @@ import { useBrowser } from '@/providers/BrowserProvider';
 
 interface Props {
   taskId: string;
-  workspacePath?: string;
+  taskPath?: string;
   ports: Array<RunnerPortMapping & { url?: string }>;
   previewUrl?: string;
   previewService?: string;
@@ -15,7 +15,7 @@ interface Props {
 
 const WorkspacePorts: React.FC<Props> = ({
   taskId,
-  workspacePath,
+  taskPath,
   ports,
   previewUrl,
   previewService,
@@ -38,7 +38,7 @@ const WorkspacePorts: React.FC<Props> = ({
           'compose.yaml',
         ];
         for (const file of candidates) {
-          const res = await api?.fsRead?.(workspacePath || '', file, 1);
+          const res = await api?.fsRead?.(taskPath || '', file, 1);
           if (!cancelled && res?.success) {
             setHasCompose(true);
             return;
@@ -52,7 +52,7 @@ const WorkspacePorts: React.FC<Props> = ({
     return () => {
       cancelled = true;
     };
-  }, [workspacePath]);
+  }, [taskPath]);
 
   const norm = (s: string) => s.toLowerCase();
   const sorted = [...(ports ?? [])].sort((a, b) => {
@@ -78,7 +78,7 @@ const WorkspacePorts: React.FC<Props> = ({
           const res = await api.resolveServiceIcon({
             service: name,
             allowNetwork: true,
-            workspacePath,
+            taskPath,
           });
           if (!cancelled && res?.ok && typeof res.dataUrl === 'string') {
             setSrc(res.dataUrl);
@@ -88,7 +88,7 @@ const WorkspacePorts: React.FC<Props> = ({
       return () => {
         cancelled = true;
       };
-    }, [name, workspacePath]);
+    }, [name, taskPath]);
     if (src) {
       return <img src={src} alt="" className="h-3.5 w-3.5 rounded-sm" />;
     }
@@ -234,7 +234,7 @@ const WorkspacePorts: React.FC<Props> = ({
                     const api: any = (window as any).electronAPI;
                     const content = `services:\n  web:\n    image: node:20\n    working_dir: /workspace\n    volumes:\n      - ./:/workspace\n    environment:\n      - HOST=0.0.0.0\n      - PORT=3000\n    command: bash -lc \"if [ -f package-lock.json ]; then npm ci; else npm install --no-package-lock; fi && npm run dev\"\n    expose:\n      - \"3000\"\n`;
                     const res = await api.fsWriteFile(
-                      workspacePath || '',
+                      taskPath || '',
                       'docker-compose.yml',
                       content,
                       false
diff --git a/src/renderer/components/kanban/KanbanBoard.tsx b/src/renderer/components/kanban/KanbanBoard.tsx
index c1394b93..c80bb0f1 100644
--- a/src/renderer/components/kanban/KanbanBoard.tsx
+++ b/src/renderer/components/kanban/KanbanBoard.tsx
@@ -175,7 +175,7 @@ const KanbanBoard: React.FC<{
         try {
           let hasPr = false;
           for (const p of paths) {
-            const res = await (window as any).electronAPI?.getPrStatus?.({ workspacePath: p });
+            const res = await (window as any).electronAPI?.getPrStatus?.({ taskPath: p });
             if (res?.success && res?.pr) {
               hasPr = true;
               break;
@@ -225,7 +225,7 @@ const KanbanBoard: React.FC<{
         try {
           let ahead = 0;
           for (const p of paths) {
-            const res = await (window as any).electronAPI?.getBranchStatus?.({ workspacePath: p });
+            const res = await (window as any).electronAPI?.getBranchStatus?.({ taskPath: p });
             if (res?.success) {
               const a = Number(res?.ahead ?? 0);
               if (a > 0) {
diff --git a/src/renderer/components/kanban/KanbanCard.tsx b/src/renderer/components/kanban/KanbanCard.tsx
index 6223b377..8078ae3a 100644
--- a/src/renderer/components/kanban/KanbanCard.tsx
+++ b/src/renderer/components/kanban/KanbanCard.tsx
@@ -44,7 +44,7 @@ const KanbanCard: React.FC<{
       adminProvider={adminProvider}
       side="top"
       delay={150}
-      workspacePath={ws.path}
+      taskPath={ws.path}
       workspaceName={ws.name}
     >
       <div
diff --git a/src/renderer/components/kanban/ProviderTooltip.tsx b/src/renderer/components/kanban/ProviderTooltip.tsx
index f15d2580..904fc7b4 100644
--- a/src/renderer/components/kanban/ProviderTooltip.tsx
+++ b/src/renderer/components/kanban/ProviderTooltip.tsx
@@ -10,7 +10,7 @@ type ProviderTooltipProps = {
   side?: 'top' | 'bottom' | 'left' | 'right';
   delay?: number;
   children: React.ReactNode;
-  workspacePath?: string;
+  taskPath?: string;
   workspaceName?: string;
 };
 
@@ -20,7 +20,7 @@ export const ProviderTooltip: React.FC<ProviderTooltipProps> = ({
   side = 'top',
   delay = 150,
   children,
-  workspacePath,
+  taskPath,
   workspaceName,
 }) => {
   const items = React.useMemo(() => {
@@ -66,9 +66,9 @@ export const ProviderTooltip: React.FC<ProviderTooltipProps> = ({
     let cancelled = false;
     const fetchSummary = async () => {
       if (!open) return;
-      if (!workspacePath) return;
+      if (!taskPath) return;
       try {
-        const res = await (window as any).electronAPI?.getGitStatus?.(workspacePath);
+        const res = await (window as any).electronAPI?.getGitStatus?.(taskPath);
         if (!res?.success || !Array.isArray(res?.changes)) {
           if (!cancelled) setDiffSummary(null);
           return;
@@ -98,7 +98,7 @@ export const ProviderTooltip: React.FC<ProviderTooltipProps> = ({
     return () => {
       cancelled = true;
     };
-  }, [open, workspacePath]);
+  }, [open, taskPath]);
 
   if (!items || items.length === 0) return <>{children}</>;
 
@@ -141,7 +141,7 @@ export const ProviderTooltip: React.FC<ProviderTooltipProps> = ({
             </div>
           ) : null}
 
-          {workspacePath && diffSummary ? (
+          {taskPath && diffSummary ? (
             <div className="mt-2 border-t border-border/60 pt-1">
               <div className="mb-1 font-medium text-foreground">Changes</div>
               {diffSummary.files > 0 ? (
diff --git a/src/renderer/components/titlebar/BrowserToggleButton.tsx b/src/renderer/components/titlebar/BrowserToggleButton.tsx
index 357fae13..5397e660 100644
--- a/src/renderer/components/titlebar/BrowserToggleButton.tsx
+++ b/src/renderer/components/titlebar/BrowserToggleButton.tsx
@@ -16,13 +16,13 @@ import { isReachable, isAppPort, FALLBACK_DELAY_MS, SPINNER_MAX_MS } from '@/lib
 interface Props {
   defaultUrl?: string;
   taskId?: string | null;
-  workspacePath?: string | null;
+  taskPath?: string | null;
   parentProjectPath?: string | null;
 }
 
 const BrowserToggleButton: React.FC<Props> = ({
   taskId,
-  workspacePath,
+  taskPath,
   parentProjectPath,
 }) => {
   const browser = useBrowser();
@@ -85,7 +85,7 @@ const BrowserToggleButton: React.FC<Props> = ({
 
   const handleClick = React.useCallback(async () => {
     const id = (taskId || '').trim();
-    const wp = (workspacePath || '').trim();
+    const wp = (taskPath || '').trim();
     const appPort = Number(window.location.port || 0);
     // Open pane immediately with no URL; we will navigate when ready
     browser.showSpinner();
@@ -121,7 +121,7 @@ const BrowserToggleButton: React.FC<Props> = ({
         if (!installed && (await needsInstall(wp))) {
           await (window as any).electronAPI?.hostPreviewSetup?.({
             taskId: id,
-            workspacePath: wp,
+            taskPath: wp,
           });
           setInstalled(id, true);
         }
@@ -129,7 +129,7 @@ const BrowserToggleButton: React.FC<Props> = ({
         if (!running) {
           await (window as any).electronAPI?.hostPreviewStart?.({
             taskId: id,
-            workspacePath: wp,
+            taskPath: wp,
             parentProjectPath: (parentProjectPath || '').trim(),
           });
         }
@@ -153,7 +153,7 @@ const BrowserToggleButton: React.FC<Props> = ({
     }
     // Fallback: clear spinner after a grace period if nothing arrives
     setTimeout(() => browser.hideSpinner(), SPINNER_MAX_MS);
-  }, [browser, taskId, workspacePath, parentProjectPath]);
+  }, [browser, taskId, taskPath, parentProjectPath]);
 
   return (
     <TooltipProvider delayDuration={200}>
diff --git a/src/renderer/components/titlebar/Titlebar.tsx b/src/renderer/components/titlebar/Titlebar.tsx
index dc2a770f..a22ac854 100644
--- a/src/renderer/components/titlebar/Titlebar.tsx
+++ b/src/renderer/components/titlebar/Titlebar.tsx
@@ -22,7 +22,7 @@ interface TitlebarProps {
   githubUser?: GithubUser | null;
   defaultPreviewUrl?: string | null;
   taskId?: string | null;
-  workspacePath?: string | null;
+  taskPath?: string | null;
   projectPath?: string | null;
   isWorkspaceMultiAgent?: boolean;
   onToggleKanban?: () => void;
@@ -37,7 +37,7 @@ const Titlebar: React.FC<TitlebarProps> = ({
   githubUser,
   defaultPreviewUrl,
   taskId,
-  workspacePath,
+  taskPath,
   projectPath,
   isWorkspaceMultiAgent,
   onToggleKanban,
@@ -143,7 +143,7 @@ const Titlebar: React.FC<TitlebarProps> = ({
             <BrowserToggleButton
               defaultUrl={defaultPreviewUrl || undefined}
               taskId={taskId}
-              workspacePath={workspacePath}
+              taskPath={taskPath}
               parentProjectPath={projectPath}
             />
           ) : null}
diff --git a/src/renderer/hooks/useCreatePR.tsx b/src/renderer/hooks/useCreatePR.tsx
index 2c88fa02..92fec60a 100644
--- a/src/renderer/hooks/useCreatePR.tsx
+++ b/src/renderer/hooks/useCreatePR.tsx
@@ -4,7 +4,7 @@ import { ToastAction } from '../components/ui/toast';
 import { ArrowUpRight } from 'lucide-react';
 import githubLogo from '../../assets/images/github.png';
 type CreatePROptions = {
-  workspacePath: string;
+  taskPath: string;
   commitMessage?: string;
   createBranchIfOnDefault?: boolean;
   branchPrefix?: string;
@@ -26,7 +26,7 @@ export function useCreatePR() {
 
   const createPR = async (opts: CreatePROptions) => {
     const {
-      workspacePath,
+      taskPath,
       commitMessage = 'chore: apply workspace changes',
       createBranchIfOnDefault = true,
       branchPrefix = 'orch',
@@ -45,12 +45,12 @@ export function useCreatePR() {
       }
 
       const inferredTitle =
-        prOptions?.title || workspacePath.split(/[/\\]/).filter(Boolean).pop() || 'Task';
+        prOptions?.title || taskPath.split(/[/\\]/).filter(Boolean).pop() || 'Task';
 
       let finalPrOptions = { ...(prOptions || {}), title: inferredTitle };
 
       const commitRes = await api.gitCommitAndPush({
-        workspacePath,
+        taskPath,
         commitMessage,
         createBranchIfOnDefault,
         branchPrefix,
@@ -66,7 +66,7 @@ export function useCreatePR() {
       }
 
       const res = await api.createPullRequest({
-        workspacePath,
+        taskPath,
         fill: true,
         ...finalPrOptions,
       });
diff --git a/src/renderer/hooks/useDeleteRisks.ts b/src/renderer/hooks/useDeleteRisks.ts
index 363f2aa9..b4d6502a 100644
--- a/src/renderer/hooks/useDeleteRisks.ts
+++ b/src/renderer/hooks/useDeleteRisks.ts
@@ -42,7 +42,7 @@ export function useDeleteRisks(workspaces: WorkspaceRef[], enabled: boolean) {
           const [statusRes, infoRes, prRes] = await Promise.allSettled([
             (window as any).electronAPI?.getGitStatus?.(ws.path),
             (window as any).electronAPI?.getGitInfo?.(ws.path),
-            (window as any).electronAPI?.getPrStatus?.({ workspacePath: ws.path }),
+            (window as any).electronAPI?.getPrStatus?.({ taskPath: ws.path }),
           ]);
 
           let staged = 0;
diff --git a/src/renderer/hooks/useFileChanges.ts b/src/renderer/hooks/useFileChanges.ts
index 155174bb..e818da73 100644
--- a/src/renderer/hooks/useFileChanges.ts
+++ b/src/renderer/hooks/useFileChanges.ts
@@ -9,14 +9,14 @@ export interface FileChange {
   diff?: string;
 }
 
-export function useFileChanges(workspacePath: string) {
+export function useFileChanges(taskPath: string) {
   const [fileChanges, setFileChanges] = useState<FileChange[]>([]);
   const [isLoading, setIsLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
 
   useEffect(() => {
     const fetchFileChanges = async (isInitialLoad = false) => {
-      if (!workspacePath) return;
+      if (!taskPath) return;
 
       if (isInitialLoad) {
         setIsLoading(true);
@@ -25,7 +25,7 @@ export function useFileChanges(workspacePath: string) {
 
       try {
         // Call main process to get git status
-        const result = await window.electronAPI.getGitStatus(workspacePath);
+        const result = await window.electronAPI.getGitStatus(taskPath);
 
         if (result?.success && result.changes && result.changes.length > 0) {
           const changes: FileChange[] = result.changes
@@ -71,12 +71,12 @@ export function useFileChanges(workspacePath: string) {
     const interval = setInterval(() => fetchFileChanges(false), 5000);
 
     return () => clearInterval(interval);
-  }, [workspacePath]);
+  }, [taskPath]);
 
   const refreshChanges = async () => {
     setIsLoading(true);
     try {
-      const result = await window.electronAPI.getGitStatus(workspacePath);
+      const result = await window.electronAPI.getGitStatus(taskPath);
       if (result?.success && result.changes && result.changes.length > 0) {
         const changes: FileChange[] = result.changes
           .map(
diff --git a/src/renderer/hooks/useFileDiff.ts b/src/renderer/hooks/useFileDiff.ts
index 9fabf71a..c73858db 100644
--- a/src/renderer/hooks/useFileDiff.ts
+++ b/src/renderer/hooks/useFileDiff.ts
@@ -3,7 +3,7 @@ import { useEffect, useState } from 'react';
 export type DiffLine = { left?: string; right?: string; type: 'context' | 'add' | 'del' };
 
 export function useFileDiff(
-  workspacePath: string | undefined,
+  taskPath: string | undefined,
   filePath: string | undefined,
   refreshKey: number = 0
 ) {
@@ -14,11 +14,11 @@ export function useFileDiff(
   useEffect(() => {
     let cancelled = false;
     const run = async () => {
-      if (!workspacePath || !filePath) return;
+      if (!taskPath || !filePath) return;
       setLoading(true);
       setError(null);
       try {
-        const res = await window.electronAPI.getFileDiff({ workspacePath, filePath });
+        const res = await window.electronAPI.getFileDiff({ taskPath, filePath });
         if (!cancelled) {
           if (res?.success && res.diff) setLines(res.diff.lines);
           else setError(res?.error || 'Failed to load diff');
@@ -33,7 +33,7 @@ export function useFileDiff(
     return () => {
       cancelled = true;
     };
-  }, [workspacePath, filePath, refreshKey]);
+  }, [taskPath, filePath, refreshKey]);
 
   return { lines, loading, error };
 }
diff --git a/src/renderer/hooks/usePlanActivation.ts b/src/renderer/hooks/usePlanActivation.ts
index a2e322c4..7c21e7da 100644
--- a/src/renderer/hooks/usePlanActivation.ts
+++ b/src/renderer/hooks/usePlanActivation.ts
@@ -11,9 +11,9 @@ export function usePlanActivationTerminal(opts: {
   enabled: boolean;
   providerId: string;
   taskId: string;
-  workspacePath: string;
+  taskPath: string;
 }) {
-  const { enabled, providerId, taskId, workspacePath } = opts;
+  const { enabled, providerId, taskId, taskPath } = opts;
 
   useEffect(() => {
     if (!enabled) return;
@@ -35,7 +35,7 @@ export function usePlanActivationTerminal(opts: {
         try {
           localStorage.setItem(onceKey, '1');
         } catch {}
-        await logPlanEvent(workspacePath, `Sent native plan command: ${cmd}`);
+        await logPlanEvent(taskPath, `Sent native plan command: ${cmd}`);
       } catch {}
     };
 
diff --git a/src/renderer/hooks/usePlanMode.ts b/src/renderer/hooks/usePlanMode.ts
index 1aaa1b37..a6303ede 100644
--- a/src/renderer/hooks/usePlanMode.ts
+++ b/src/renderer/hooks/usePlanMode.ts
@@ -3,7 +3,7 @@ import { PLANNING_MD } from '@/lib/planRules';
 import { log } from '@/lib/logger';
 import { logPlanEvent } from '@/lib/planLogs';
 
-export function usePlanMode(taskId: string, workspacePath: string) {
+export function usePlanMode(taskId: string, taskPath: string) {
   const key = useMemo(() => `planMode:${taskId}`, [taskId]);
   const [enabled, setEnabled] = useState<boolean>(() => {
     try {
@@ -25,9 +25,9 @@ export function usePlanMode(taskId: string, workspacePath: string) {
     try {
       // Hidden policy file in .emdash/
       const hiddenRel = '.emdash/planning.md';
-      log.info('[plan] writing policy (hidden)', { workspacePath, hiddenRel });
+      log.info('[plan] writing policy (hidden)', { taskPath, hiddenRel });
       const resHidden = await (window as any).electronAPI.fsWriteFile(
-        workspacePath,
+        taskPath,
         hiddenRel,
         PLANNING_MD,
         true
@@ -38,11 +38,11 @@ export function usePlanMode(taskId: string, workspacePath: string) {
 
       // Root-level helper for agents that don't read hidden dirs
       const rootRel = 'PLANNING.md';
-      log.info('[plan] writing policy (root helper)', { workspacePath, rootRel });
+      log.info('[plan] writing policy (root helper)', { taskPath, rootRel });
       const rootHeader = '# Plan Mode (Read-only)\n\n';
       const rootBody = `${rootHeader}${PLANNING_MD}`;
       const resRoot = await (window as any).electronAPI.fsWriteFile(
-        workspacePath,
+        taskPath,
         rootRel,
         rootBody,
         true
@@ -50,12 +50,12 @@ export function usePlanMode(taskId: string, workspacePath: string) {
       if (!resRoot?.success) {
         log.warn('[plan] failed to write root PLANNING.md', resRoot?.error);
       }
-      await logPlanEvent(workspacePath, 'planning.md written (hidden + root helper)');
+      await logPlanEvent(taskPath, 'planning.md written (hidden + root helper)');
 
       // Root-level helper only for non-worktree repos and only if it doesn't exist.
       let wroteRootHelper = false;
       try {
-        const gitRef = await (window as any).electronAPI.fsRead(workspacePath, '.git', 1024);
+        const gitRef = await (window as any).electronAPI.fsRead(taskPath, '.git', 1024);
         const isWorktree = !!(
           gitRef?.success &&
           typeof gitRef.content === 'string' &&
@@ -65,15 +65,15 @@ export function usePlanMode(taskId: string, workspacePath: string) {
           const rootRel = 'PLANNING.md';
           let exists = false;
           try {
-            const readTry = await (window as any).electronAPI.fsRead?.(workspacePath, rootRel, 1);
+            const readTry = await (window as any).electronAPI.fsRead?.(taskPath, rootRel, 1);
             exists = !!readTry?.success;
           } catch {}
           if (!exists) {
-            log.info('[plan] writing policy (root helper)', { workspacePath, rootRel });
+            log.info('[plan] writing policy (root helper)', { taskPath, rootRel });
             const rootHeader = '# Plan Mode (Read‑only)\n\n';
             const rootBody = `${rootHeader}${PLANNING_MD}`;
             const resRoot = await (window as any).electronAPI.fsWriteFile(
-              workspacePath,
+              taskPath,
               rootRel,
               rootBody,
               true
@@ -92,25 +92,25 @@ export function usePlanMode(taskId: string, workspacePath: string) {
         const metaRel = '.emdash/planning.meta.json';
         const meta = { wroteRootHelper };
         await (window as any).electronAPI.fsWriteFile(
-          workspacePath,
+          taskPath,
           metaRel,
           JSON.stringify(meta),
           true
         );
       } catch {}
 
-      await logPlanEvent(workspacePath, 'planning.md written (hidden; root helper maybe)');
+      await logPlanEvent(taskPath, 'planning.md written (hidden; root helper maybe)');
     } catch (e) {
       log.warn('[plan] failed to write planning.md', e);
     }
-  }, [workspacePath]);
+  }, [taskPath]);
 
   const ensureGitExclude = useCallback(async () => {
     try {
       // For worktrees, we cannot safely write to the external gitdir from renderer; rely on
       // commit-time exclusions and UI filtering. For normal repos, update .git/info/exclude.
       try {
-        const gitRef = await window.electronAPI.fsRead(workspacePath, '.git', 1024);
+        const gitRef = await window.electronAPI.fsRead(taskPath, '.git', 1024);
         if (gitRef?.success && typeof gitRef.content === 'string') {
           const txt = gitRef.content.trim();
           if (/^gitdir:\s*/i.test(txt)) {
@@ -123,7 +123,7 @@ export function usePlanMode(taskId: string, workspacePath: string) {
       const rel = '.git/info/exclude';
       let current = '';
       try {
-        const read = await window.electronAPI.fsRead(workspacePath, rel, 32 * 1024);
+        const read = await window.electronAPI.fsRead(taskPath, rel, 32 * 1024);
         if (read?.success && typeof read.content === 'string') current = read.content;
       } catch {}
       const lines: string[] = [];
@@ -133,44 +133,44 @@ export function usePlanMode(taskId: string, workspacePath: string) {
       if (lines.length === 0) return;
       const next = `${current.trimEnd()}\n# emdash plan mode\n${lines.join('\n')}\n`;
       log.info('[plan] appending .emdash/ to git exclude');
-      await (window as any).electronAPI.fsWriteFile(workspacePath, rel, next, true);
-      await logPlanEvent(workspacePath, 'updated .git/info/exclude with .emdash/');
+      await (window as any).electronAPI.fsWriteFile(taskPath, rel, next, true);
+      await logPlanEvent(taskPath, 'updated .git/info/exclude with .emdash/');
     } catch (e) {
       log.warn('[plan] failed to update git exclude', e);
     }
-  }, [workspacePath]);
+  }, [taskPath]);
 
   const removePlanFile = useCallback(async () => {
     try {
       const hiddenRel = '.emdash/planning.md';
-      await (window as any).electronAPI.fsRemove(workspacePath, hiddenRel);
+      await (window as any).electronAPI.fsRemove(taskPath, hiddenRel);
       // Only remove root helper if we created it
       try {
         const metaRel = '.emdash/planning.meta.json';
-        const metaRead = await (window as any).electronAPI.fsRead?.(workspacePath, metaRel, 4096);
+        const metaRead = await (window as any).electronAPI.fsRead?.(taskPath, metaRel, 4096);
         const meta =
           metaRead?.success && typeof metaRead.content === 'string'
             ? JSON.parse(metaRead.content)
             : {};
         if (meta?.wroteRootHelper) {
           const rootRel = 'PLANNING.md';
-          await (window as any).electronAPI.fsRemove(workspacePath, rootRel);
+          await (window as any).electronAPI.fsRemove(taskPath, rootRel);
         }
         try {
-          await (window as any).electronAPI.fsRemove(workspacePath, metaRel);
+          await (window as any).electronAPI.fsRemove(taskPath, metaRel);
         } catch {}
       } catch {}
     } catch (e) {
       // ignore
     }
-  }, [workspacePath]);
+  }, [taskPath]);
 
   // Side effects on enable/disable
   useEffect(() => {
     (async () => {
       if (enabled) {
-        log.info('[plan] enabled', { taskId, workspacePath });
-        await logPlanEvent(workspacePath, 'Plan Mode enabled');
+        log.info('[plan] enabled', { taskId, taskPath });
+        await logPlanEvent(taskPath, 'Plan Mode enabled');
         void (async () => {
           const { captureTelemetry } = await import('../lib/telemetryClient');
           captureTelemetry('plan_mode_enabled');
@@ -178,11 +178,11 @@ export function usePlanMode(taskId: string, workspacePath: string) {
         ensureGitExclude();
         await ensurePlanFile();
         try {
-          const lock = await (window as any).electronAPI.planApplyLock(workspacePath);
+          const lock = await (window as any).electronAPI.planApplyLock(taskPath);
           if (!lock?.success) log.warn('[plan] failed to apply lock', lock?.error);
           else
             await logPlanEvent(
-              workspacePath,
+              taskPath,
               `Applied read-only lock (changed=${lock.changed ?? 0})`
             );
         } catch (e) {
@@ -195,25 +195,25 @@ export function usePlanMode(taskId: string, workspacePath: string) {
           const hiddenRel = '.emdash/planning.md';
           const lockRel = '.emdash/.planlock.json';
           const metaRel = '.emdash/planning.meta.json';
-          const a = await (window as any).electronAPI.fsRead?.(workspacePath, hiddenRel, 1);
-          const b = await (window as any).electronAPI.fsRead?.(workspacePath, lockRel, 1);
-          const c = await (window as any).electronAPI.fsRead?.(workspacePath, metaRel, 1);
+          const a = await (window as any).electronAPI.fsRead?.(taskPath, hiddenRel, 1);
+          const b = await (window as any).electronAPI.fsRead?.(taskPath, lockRel, 1);
+          const c = await (window as any).electronAPI.fsRead?.(taskPath, metaRel, 1);
           wasActive = !!(a?.success || b?.success || c?.success);
         } catch {}
 
         if (wasActive) {
-          log.info('[plan] disabled', { taskId, workspacePath });
-          await logPlanEvent(workspacePath, 'Plan Mode disabled');
+          log.info('[plan] disabled', { taskId, taskPath });
+          await logPlanEvent(taskPath, 'Plan Mode disabled');
           void (async () => {
             const { captureTelemetry } = await import('../lib/telemetryClient');
             captureTelemetry('plan_mode_disabled');
           })();
           try {
-            const unlock = await (window as any).electronAPI.planReleaseLock(workspacePath);
+            const unlock = await (window as any).electronAPI.planReleaseLock(taskPath);
             if (!unlock?.success) log.warn('[plan] failed to release lock', unlock?.error);
             else
               await logPlanEvent(
-                workspacePath,
+                taskPath,
                 `Released read-only lock (restored=${unlock.restored ?? 0})`
               );
           } catch (e) {
@@ -223,7 +223,7 @@ export function usePlanMode(taskId: string, workspacePath: string) {
         }
       }
     })();
-  }, [enabled, ensureGitExclude, ensurePlanFile, removePlanFile, taskId, workspacePath]);
+  }, [enabled, ensureGitExclude, ensurePlanFile, removePlanFile, taskId, taskPath]);
 
   const toggle = useCallback(() => setEnabled((v) => !v), []);
 
diff --git a/src/renderer/hooks/usePrStatus.ts b/src/renderer/hooks/usePrStatus.ts
index 78f7d054..0b74ee59 100644
--- a/src/renderer/hooks/usePrStatus.ts
+++ b/src/renderer/hooks/usePrStatus.ts
@@ -14,17 +14,17 @@ export type PrStatus = {
   changedFiles?: number;
 };
 
-export function usePrStatus(workspacePath?: string) {
+export function usePrStatus(taskPath?: string) {
   const [pr, setPr] = useState<PrStatus | null>(null);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
 
   const refresh = async () => {
-    if (!workspacePath) return;
+    if (!taskPath) return;
     setLoading(true);
     setError(null);
     try {
-      const res = await window.electronAPI.getPrStatus({ workspacePath });
+      const res = await window.electronAPI.getPrStatus({ taskPath });
       if (res?.success) {
         setPr((res.pr as any) || null);
       } else {
@@ -40,7 +40,7 @@ export function usePrStatus(workspacePath?: string) {
   useEffect(() => {
     refresh();
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [workspacePath]);
+  }, [taskPath]);
 
   return { pr, loading, error, refresh };
 }
diff --git a/src/renderer/lib/attachments.ts b/src/renderer/lib/attachments.ts
index 13aa737d..d90b5979 100644
--- a/src/renderer/lib/attachments.ts
+++ b/src/renderer/lib/attachments.ts
@@ -66,13 +66,13 @@ export async function buildAttachmentsSection(
   return `\n\n---\nAttached files (from workspace):\n\n${parts.join('\n\n')}\n`;
 }
 
-export function buildImageAttachmentsSection(workspacePath: string, relPaths: string[]): string {
+export function buildImageAttachmentsSection(taskPath: string, relPaths: string[]): string {
   if (!relPaths || relPaths.length === 0) return '';
   const lines: string[] = [];
   for (const rel of relPaths) {
     const name = rel.split(/[\\/]/).pop() || 'image';
-    const sep = workspacePath.endsWith('/') ? '' : '/';
-    const absPath = (workspacePath + sep + rel).replace(/\\/g, '/');
+    const sep = taskPath.endsWith('/') ? '' : '/';
+    const absPath = (taskPath + sep + rel).replace(/\\/g, '/');
     // Markdown image referencing a file URL; many CLIs that support images accept this pattern
     const url = `file://${absPath}`;
     lines.push(`![${name}](${url})`);
diff --git a/src/renderer/lib/containerRuns.ts b/src/renderer/lib/containerRuns.ts
index 38d6ef8f..10e1aa5b 100644
--- a/src/renderer/lib/containerRuns.ts
+++ b/src/renderer/lib/containerRuns.ts
@@ -16,7 +16,7 @@ type WorkspaceListener = (state: ContainerRunState) => void;
 
 interface StartRunArgs {
   taskId: string;
-  workspacePath: string;
+  taskPath: string;
   runId?: string;
   mode?: RunnerMode;
 }
@@ -211,17 +211,17 @@ export async function startContainerRun(args: StartRunArgs) {
   ensureSubscribed();
   const api = (window as any).electronAPI;
   const taskId = clean(args.taskId);
-  const workspacePath = clean(args.workspacePath);
+  const taskPath = clean(args.taskPath);
   const runId = clean(args.runId);
   const mode = args.mode;
   const payload: Record<string, any> = {};
   if (taskId) payload.taskId = taskId;
-  if (workspacePath) payload.workspacePath = workspacePath;
+  if (taskPath) payload.taskPath = taskPath;
   if (runId) payload.runId = runId;
   if (mode === 'container' || mode === 'host') payload.mode = mode;
 
-  if (!taskId || !workspacePath) {
-    throw new Error('taskId and workspacePath are required to start a container run');
+  if (!taskId || !taskPath) {
+    throw new Error('taskId and taskPath are required to start a container run');
   }
 
   if (!api || typeof api.startContainerRun !== 'function') {
diff --git a/src/renderer/lib/planLogs.ts b/src/renderer/lib/planLogs.ts
index bb75637f..0c45c153 100644
--- a/src/renderer/lib/planLogs.ts
+++ b/src/renderer/lib/planLogs.ts
@@ -1,8 +1,8 @@
-export async function logPlanEvent(workspacePath: string, message: string) {
+export async function logPlanEvent(taskPath: string, message: string) {
   try {
     const ts = new Date().toISOString();
     const line = `[${ts}] ${message}\n`;
-    const fp = `${workspacePath}/.emdash/plan.log`;
+    const fp = `${taskPath}/.emdash/plan.log`;
     await (window as any).electronAPI.debugAppendLog(fp, line, { reset: false });
   } catch {}
 }
diff --git a/src/renderer/lib/quickPreview.ts b/src/renderer/lib/quickPreview.ts
index b22aef5d..461c7f15 100644
--- a/src/renderer/lib/quickPreview.ts
+++ b/src/renderer/lib/quickPreview.ts
@@ -8,22 +8,22 @@ declare const window: Window & {
   electronAPI: any;
 };
 
-export async function isNodeProject(workspacePath?: string): Promise<boolean> {
-  if (!workspacePath) return false;
+export async function isNodeProject(taskPath?: string): Promise<boolean> {
+  if (!taskPath) return false;
   try {
-    const res = await window.electronAPI.fsRead(workspacePath, 'package.json', 64 * 1024);
+    const res = await window.electronAPI.fsRead(taskPath, 'package.json', 64 * 1024);
     return !!(res?.success && typeof res.content === 'string' && res.content.includes('{'));
   } catch {
     return false;
   }
 }
 
-export async function ensureCompose(workspacePath?: string): Promise<boolean> {
-  if (!workspacePath) return false;
+export async function ensureCompose(taskPath?: string): Promise<boolean> {
+  if (!taskPath) return false;
   try {
     const candidates = ['docker-compose.yml', 'docker-compose.yaml', 'compose.yml', 'compose.yaml'];
     for (const file of candidates) {
-      const res = await window.electronAPI.fsRead(workspacePath, file, 1);
+      const res = await window.electronAPI.fsRead(taskPath, file, 1);
       if (res?.success) return true;
     }
   } catch {}
@@ -31,7 +31,7 @@ export async function ensureCompose(workspacePath?: string): Promise<boolean> {
   const content = `services:\n  web:\n    image: node:20\n    working_dir: /workspace\n    volumes:\n      - ./:/workspace\n    environment:\n      - HOST=0.0.0.0\n      - PORT=3000\n    command: bash -lc \"if [ -f package-lock.json ]; then npm ci; else npm install --no-package-lock; fi && npm run dev\"\n    expose:\n      - \"3000\"\n      - \"5173\"\n      - \"8080\"\n      - \"8000\"\n`;
   try {
     const res = await window.electronAPI.fsWriteFile(
-      workspacePath,
+      taskPath,
       'docker-compose.yml',
       content,
       false
@@ -44,15 +44,15 @@ export async function ensureCompose(workspacePath?: string): Promise<boolean> {
 
 export async function quickStartPreview(args: {
   taskId: string;
-  workspacePath: string;
+  taskPath: string;
   onPreviewUrl?: (url: string) => void;
 }): Promise<{ ok: boolean; error?: string }> {
-  const { taskId, workspacePath, onPreviewUrl } = args;
+  const { taskId, taskPath, onPreviewUrl } = args;
   try {
-    const node = await isNodeProject(workspacePath);
+    const node = await isNodeProject(taskPath);
     if (!node) return { ok: false, error: 'Not a Node.js project (no package.json).' };
-    await ensureCompose(workspacePath);
-    await startContainerRun({ taskId, workspacePath, mode: 'container' });
+    await ensureCompose(taskPath);
+    await startContainerRun({ taskId, taskPath, mode: 'container' });
     // If already have a preview, use it immediately
     const existing = getContainerRunState(taskId);
     if (existing?.previewUrl && onPreviewUrl) onPreviewUrl(existing.previewUrl);
diff --git a/src/renderer/lib/taskTerminalsStore.ts b/src/renderer/lib/taskTerminalsStore.ts
index 95e5dc29..ef341da4 100644
--- a/src/renderer/lib/taskTerminalsStore.ts
+++ b/src/renderer/lib/taskTerminalsStore.ts
@@ -128,12 +128,12 @@ function makeTerminalId(taskId: string): string {
   return `${taskId}::term::${Date.now().toString(16)}::${rnd}`;
 }
 
-function createDefaultState(taskId: string, workspacePath?: string): TaskTerminalsState {
+function createDefaultState(taskId: string, taskPath?: string): TaskTerminalsState {
   const terminalId = makeTerminalId(taskId);
   const firstTerminal: TaskTerminal = {
     id: terminalId,
     title: 'Terminal 1',
-    cwd: workspacePath,
+    cwd: taskPath,
     createdAt: Date.now(),
   };
   return {
@@ -160,7 +160,7 @@ function ensureSnapshot(taskId: string, state: TaskTerminalsState) {
 
 function ensureWorkspaceState(
   taskId: string,
-  workspacePath?: string
+  taskPath?: string
 ): TaskTerminalsState {
   let state = workspaceStates.get(taskId);
   if (state) {
@@ -168,7 +168,7 @@ function ensureWorkspaceState(
     return state;
   }
 
-  state = loadFromStorage(taskId) ?? createDefaultState(taskId, workspacePath);
+  state = loadFromStorage(taskId) ?? createDefaultState(taskId, taskPath);
   workspaceStates.set(taskId, state);
   ensureSnapshot(taskId, state);
   return state;
@@ -188,15 +188,15 @@ function emit(taskId: string) {
 
 function updateWorkspaceState(
   taskId: string,
-  workspacePath: string | undefined,
+  taskPath: string | undefined,
   mutate: (draft: TaskTerminalsState) => void
 ) {
-  const current = ensureWorkspaceState(taskId, workspacePath);
+  const current = ensureWorkspaceState(taskId, taskPath);
   const draft = cloneState(current);
   mutate(draft);
   // Ensure state remains valid
   if (!draft.terminals.length) {
-    const fallback = createDefaultState(taskId, workspacePath);
+    const fallback = createDefaultState(taskId, taskPath);
     workspaceStates.set(taskId, fallback);
     ensureSnapshot(taskId, fallback);
     saveToStorage(taskId, fallback);
@@ -213,21 +213,21 @@ function updateWorkspaceState(
   emit(taskId);
 }
 
-function getSnapshot(taskId: string | null, workspacePath?: string): WorkspaceSnapshot {
+function getSnapshot(taskId: string | null, taskPath?: string): WorkspaceSnapshot {
   if (!taskId) return EMPTY_SNAPSHOT;
-  const state = ensureWorkspaceState(taskId, workspacePath);
+  const state = ensureWorkspaceState(taskId, taskPath);
   return ensureSnapshot(taskId, state);
 }
 
 function subscribe(
   taskId: string | null,
-  workspacePath: string | undefined,
+  taskPath: string | undefined,
   listener: () => void
 ): () => void {
   if (!taskId) {
     return () => undefined;
   }
-  ensureWorkspaceState(taskId, workspacePath);
+  ensureWorkspaceState(taskId, taskPath);
   let set = workspaceListeners.get(taskId);
   if (!set) {
     set = new Set();
@@ -244,8 +244,8 @@ function subscribe(
   };
 }
 
-function createTerminal(taskId: string, workspacePath?: string) {
-  updateWorkspaceState(taskId, workspacePath, (draft) => {
+function createTerminal(taskId: string, taskPath?: string) {
+  updateWorkspaceState(taskId, taskPath, (draft) => {
     const nextIndex = draft.counter + 1;
     const id = makeTerminalId(taskId);
     draft.counter = nextIndex;
@@ -255,30 +255,30 @@ function createTerminal(taskId: string, workspacePath?: string) {
       {
         id,
         title: `Terminal ${nextIndex}`,
-        cwd: workspacePath,
+        cwd: taskPath,
         createdAt: Date.now(),
       },
     ];
   });
 }
 
-function setActive(taskId: string, terminalId: string, workspacePath?: string) {
-  updateWorkspaceState(taskId, workspacePath, (draft) => {
+function setActive(taskId: string, terminalId: string, taskPath?: string) {
+  updateWorkspaceState(taskId, taskPath, (draft) => {
     if (draft.terminals.some((terminal) => terminal.id === terminalId)) {
       draft.activeId = terminalId;
     }
   });
 }
 
-function closeTerminal(taskId: string, terminalId: string, workspacePath?: string) {
-  const state = ensureWorkspaceState(taskId, workspacePath);
+function closeTerminal(taskId: string, terminalId: string, taskPath?: string) {
+  const state = ensureWorkspaceState(taskId, taskPath);
   if (state.terminals.length <= 1) {
     return;
   }
   const exists = state.terminals.some((terminal) => terminal.id === terminalId);
   if (!exists) return;
 
-  updateWorkspaceState(taskId, workspacePath, (draft) => {
+  updateWorkspaceState(taskId, taskPath, (draft) => {
     const idx = draft.terminals.findIndex((terminal) => terminal.id === terminalId);
     draft.terminals = draft.terminals.filter((terminal) => terminal.id !== terminalId);
     if (draft.activeId === terminalId) {
diff --git a/src/renderer/types/electron-api.d.ts b/src/renderer/types/electron-api.d.ts
index 03e5dddb..ad24fc88 100644
--- a/src/renderer/types/electron-api.d.ts
+++ b/src/renderer/types/electron-api.d.ts
@@ -208,7 +208,7 @@ declare global {
         rootPath?: string;
         error?: string;
       }>;
-      getGitStatus: (workspacePath: string) => Promise<{
+      getGitStatus: (taskPath: string) => Promise<{
         success: boolean;
         changes?: Array<{
           path: string;
@@ -220,7 +220,7 @@ declare global {
         }>;
         error?: string;
       }>;
-      getFileDiff: (args: { workspacePath: string; filePath: string }) => Promise<{
+      getFileDiff: (args: { taskPath: string; filePath: string }) => Promise<{
         success: boolean;
         diff?: {
           lines: Array<{
@@ -231,17 +231,17 @@ declare global {
         };
         error?: string;
       }>;
-      stageFile: (args: { workspacePath: string; filePath: string }) => Promise<{
+      stageFile: (args: { taskPath: string; filePath: string }) => Promise<{
         success: boolean;
         error?: string;
       }>;
-      revertFile: (args: { workspacePath: string; filePath: string }) => Promise<{
+      revertFile: (args: { taskPath: string; filePath: string }) => Promise<{
         success: boolean;
         action?: 'unstaged' | 'reverted';
         error?: string;
       }>;
       gitCommitAndPush: (args: {
-        workspacePath: string;
+        taskPath: string;
         commitMessage?: string;
         createBranchIfOnDefault?: boolean;
         branchPrefix?: string;
@@ -252,7 +252,7 @@ declare global {
         error?: string;
       }>;
       createPullRequest: (args: {
-        workspacePath: string;
+        taskPath: string;
         title?: string;
         body?: string;
         base?: string;
@@ -266,7 +266,7 @@ declare global {
         output?: string;
         error?: string;
       }>;
-      getPrStatus: (args: { workspacePath: string }) => Promise<{
+      getPrStatus: (args: { taskPath: string }) => Promise<{
         success: boolean;
         pr?: {
           number: number;
@@ -284,7 +284,7 @@ declare global {
         } | null;
         error?: string;
       }>;
-      getBranchStatus: (args: { workspacePath: string }) => Promise<{
+      getBranchStatus: (args: { taskPath: string }) => Promise<{
         success: boolean;
         branch?: string;
         defaultBranch?: string;
@@ -297,7 +297,7 @@ declare global {
         branches?: Array<{ ref: string; remote: string; branch: string; label: string }>;
         error?: string;
       }>;
-      loadContainerConfig: (workspacePath: string) => Promise<
+      loadContainerConfig: (taskPath: string) => Promise<
         | {
             ok: true;
             config: ResolvedContainerConfig;
@@ -321,7 +321,7 @@ declare global {
       >;
       startContainerRun: (args: {
         taskId: string;
-        workspacePath: string;
+        taskPath: string;
         runId?: string;
         mode?: RunnerMode;
       }) => Promise<
@@ -427,7 +427,7 @@ declare global {
       fsRemove: (root: string, relPath: string) => Promise<{ success: boolean; error?: string }>;
       // Attachments
       saveAttachment: (args: {
-        workspacePath: string;
+        taskPath: string;
         srcPath: string;
         subdir?: string;
       }) => Promise<{
@@ -704,7 +704,7 @@ export interface ElectronAPI {
     error?: string;
   }>;
   createPullRequest: (args: {
-    workspacePath: string;
+    taskPath: string;
     title?: string;
     body?: string;
     base?: string;
diff --git a/src/renderer/types/global.d.ts b/src/renderer/types/global.d.ts
index 26b4711a..cac20ddc 100644
--- a/src/renderer/types/global.d.ts
+++ b/src/renderer/types/global.d.ts
@@ -101,7 +101,7 @@ declare global {
         rootPath?: string;
         error?: string;
       }>;
-      getGitStatus: (workspacePath: string) => Promise<{
+      getGitStatus: (taskPath: string) => Promise<{
         success: boolean;
         changes?: Array<{
           path: string;
diff --git a/src/test/main/ContainerIpc.test.ts b/src/test/main/ContainerIpc.test.ts
index 2abbd1b2..0119adeb 100644
--- a/src/test/main/ContainerIpc.test.ts
+++ b/src/test/main/ContainerIpc.test.ts
@@ -115,7 +115,7 @@ describe('registerContainerIpc', () => {
       registerContainerIpc();
       const handler = getHandler('container:load-config');
 
-      const result = await handler({}, { workspacePath: '  /tmp/workspace  ' });
+      const result = await handler({}, { taskPath: '  /tmp/workspace  ' });
 
       expect(loadWorkspaceContainerConfigMock).toHaveBeenCalledWith('/tmp/workspace');
       expect(result).toEqual({
@@ -139,7 +139,7 @@ describe('registerContainerIpc', () => {
       registerContainerIpc();
       const handler = getHandler('container:load-config');
 
-      const result = await handler({}, { workspacePath: '/tmp/workspace' });
+      const result = await handler({}, { taskPath: '/tmp/workspace' });
 
       expect(result).toEqual({
         ok: false,
@@ -162,7 +162,7 @@ describe('registerContainerIpc', () => {
         ok: false,
         error: {
           code: 'INVALID_ARGUMENT',
-          message: '`workspacePath` must be a non-empty string',
+          message: '`taskPath` must be a non-empty string',
           configKey: null,
           configPath: null,
         },
@@ -176,7 +176,7 @@ describe('registerContainerIpc', () => {
       registerContainerIpc();
       const handler = getHandler('container:load-config');
 
-      const result = await handler({}, { workspacePath: '/tmp/workspace' });
+      const result = await handler({}, { taskPath: '/tmp/workspace' });
 
       expect(result).toEqual({
         ok: false,
@@ -211,12 +211,12 @@ describe('registerContainerIpc', () => {
 
       const result = await handler(
         {},
-        { taskId: ' ws-1 ', workspacePath: ' /tmp/workspace ' }
+        { taskId: ' ws-1 ', taskPath: ' /tmp/workspace ' }
       );
 
       expect(startRunMock).toHaveBeenCalledWith({
         taskId: 'ws-1',
-        workspacePath: '/tmp/workspace',
+        taskPath: '/tmp/workspace',
       });
       expect(result).toEqual({
         ok: true,
@@ -239,7 +239,7 @@ describe('registerContainerIpc', () => {
       registerContainerIpc();
       const handler = getHandler('container:start-run');
 
-      const result = await handler({}, { taskId: 'ws-1', workspacePath: '/tmp/workspace' });
+      const result = await handler({}, { taskId: 'ws-1', taskPath: '/tmp/workspace' });
 
       expect(result).toEqual({
         ok: false,
@@ -256,13 +256,13 @@ describe('registerContainerIpc', () => {
       registerContainerIpc();
       const handler = getHandler('container:start-run');
 
-      const result = await handler({}, { taskId: '', workspacePath: '' });
+      const result = await handler({}, { taskId: '', taskPath: '' });
 
       expect(result).toEqual({
         ok: false,
         error: {
           code: 'INVALID_ARGUMENT',
-          message: '`taskId` and `workspacePath` must be provided to start a container run',
+          message: '`taskId` and `taskPath` must be provided to start a container run',
           configKey: null,
           configPath: null,
         },
diff --git a/src/test/main/ContainerRunnerService.test.ts b/src/test/main/ContainerRunnerService.test.ts
index 7dc550f3..e8880e33 100644
--- a/src/test/main/ContainerRunnerService.test.ts
+++ b/src/test/main/ContainerRunnerService.test.ts
@@ -54,7 +54,7 @@ describe('ContainerRunnerService', () => {
 
     const result = await service.startMockRun({
       taskId: 'ws-1',
-      workspacePath: '/tmp/workspace',
+      taskPath: '/tmp/workspace',
       runId: 'run-123',
       now: () => 1700000000000,
     });
@@ -98,7 +98,7 @@ describe('ContainerRunnerService', () => {
 
     const result = await service.startMockRun({
       taskId: 'ws-1',
-      workspacePath: '/tmp/workspace',
+      taskPath: '/tmp/workspace',
     });
 
     expect(result).toEqual({
@@ -137,7 +137,7 @@ describe('ContainerRunnerService', () => {
 
     const result = await service.startMockRun({
       taskId: 'ws-1',
-      workspacePath: '/tmp/workspace',
+      taskPath: '/tmp/workspace',
       runId: 'run-err',
       now: () => 1700000000100,
     });
diff --git a/src/test/renderer/containerRuns.test.ts b/src/test/renderer/containerRuns.test.ts
index 90dad4c3..8616c4f6 100644
--- a/src/test/renderer/containerRuns.test.ts
+++ b/src/test/renderer/containerRuns.test.ts
@@ -68,12 +68,12 @@ describe('containerRuns renderer bridge', () => {
 
     const result = await startContainerRun({
       taskId: ' ws-1 ',
-      workspacePath: ' /tmp/workspace ',
+      taskPath: ' /tmp/workspace ',
     });
 
     expect(startRunMock).toHaveBeenCalledWith({
       taskId: 'ws-1',
-      workspacePath: '/tmp/workspace',
+      taskPath: '/tmp/workspace',
     });
     expect(result).toEqual({ ok: true, runId: 'run-1', sourcePath: null });
     expect(onRunEventMock).toHaveBeenCalledTimes(1);
@@ -149,11 +149,11 @@ describe('containerRuns renderer bridge', () => {
   it('re-registers listener after reset', async () => {
     startRunMock.mockResolvedValue({ ok: true, runId: 'run-3', sourcePath: null });
 
-    await startContainerRun({ taskId: 'ws-1', workspacePath: '/tmp/workspace' });
+    await startContainerRun({ taskId: 'ws-1', taskPath: '/tmp/workspace' });
     expect(onRunEventMock).toHaveBeenCalledTimes(1);
 
     resetContainerRunListeners();
-    await startContainerRun({ taskId: 'ws-1', workspacePath: '/tmp/workspace' });
+    await startContainerRun({ taskId: 'ws-1', taskPath: '/tmp/workspace' });
     expect(onRunEventMock).toHaveBeenCalledTimes(2);
   });
 });
diff --git a/src/types/electron-extra.d.ts b/src/types/electron-extra.d.ts
index 2569f4db..75fcea26 100644
--- a/src/types/electron-extra.d.ts
+++ b/src/types/electron-extra.d.ts
@@ -11,10 +11,10 @@ declare global {
       ) => Promise<{ success: boolean; error?: string }>;
       fsRemove: (root: string, relPath: string) => Promise<{ success: boolean; error?: string }>;
       planApplyLock: (
-        workspacePath: string
+        taskPath: string
       ) => Promise<{ success: boolean; changed?: number; error?: string }>;
       planReleaseLock: (
-        workspacePath: string
+        taskPath: string
       ) => Promise<{ success: boolean; restored?: number; error?: string }>;
       onPlanEvent: (
         listener: (data: {

From 9b71ee46988377eefdbe842b09c02fd557dc0cfb Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Fri, 12 Dec 2025 17:32:26 -0800
Subject: [PATCH 04/35] refactor: rename workspaceName to taskName

---
 src/main/ipc/githubIpc.ts                     | 16 +++++++--------
 src/main/preload.ts                           | 10 +++++-----
 src/main/services/LinearService.ts            |  8 ++++----
 src/main/services/WorktreeService.ts          | 12 +++++------
 src/main/services/worktreeIpc.ts              |  4 ++--
 src/renderer/App.tsx                          | 16 +++++++--------
 src/renderer/components/IntegrationsCard.tsx  |  4 ++--
 src/renderer/components/ProjectMainView.tsx   |  2 +-
 src/renderer/components/TaskDeleteButton.tsx  | 12 +++++------
 src/renderer/components/TaskItem.tsx          |  2 +-
 src/renderer/components/kanban/KanbanCard.tsx |  2 +-
 .../components/kanban/ProviderTooltip.tsx     | 10 +++++-----
 src/renderer/types/electron-api.d.ts          | 20 +++++++++----------
 src/renderer/types/global.d.ts                | 10 +++++-----
 14 files changed, 64 insertions(+), 64 deletions(-)

diff --git a/src/main/ipc/githubIpc.ts b/src/main/ipc/githubIpc.ts
index 6db26227..663fe321 100644
--- a/src/main/ipc/githubIpc.ts
+++ b/src/main/ipc/githubIpc.ts
@@ -260,7 +260,7 @@ export function registerGithubIpc() {
         projectId: string;
         prNumber: number;
         prTitle?: string;
-        workspaceName?: string;
+        taskName?: string;
         branchName?: string;
       }
     ) => {
@@ -271,9 +271,9 @@ export function registerGithubIpc() {
       }
 
       const defaultSlug = slugify(args.prTitle || `pr-${prNumber}`) || `pr-${prNumber}`;
-      const workspaceName =
-        args.workspaceName && args.workspaceName.trim().length > 0
-          ? args.workspaceName.trim()
+      const taskName =
+        args.taskName && args.taskName.trim().length > 0
+          ? args.taskName.trim()
           : `pr-${prNumber}-${defaultSlug}`;
       const branchName = args.branchName || `pr/${prNumber}`;
 
@@ -282,13 +282,13 @@ export function registerGithubIpc() {
         const existing = currentWorktrees.find((wt) => wt.branch === branchName);
 
         if (existing) {
-          return { success: true, worktree: existing, branchName, workspaceName: existing.name };
+          return { success: true, worktree: existing, branchName, taskName: existing.name };
         }
 
         await githubService.ensurePullRequestBranch(projectPath, prNumber, branchName);
 
         const worktreesDir = path.resolve(projectPath, '..', 'worktrees');
-        const slug = slugify(workspaceName) || `pr-${prNumber}`;
+        const slug = slugify(taskName) || `pr-${prNumber}`;
         let worktreePath = path.join(worktreesDir, slug);
 
         if (fs.existsSync(worktreePath)) {
@@ -297,13 +297,13 @@ export function registerGithubIpc() {
 
         const worktree = await worktreeService.createWorktreeFromBranch(
           projectPath,
-          workspaceName,
+          taskName,
           branchName,
           projectId,
           { worktreePath }
         );
 
-        return { success: true, worktree, branchName, workspaceName };
+        return { success: true, worktree, branchName, taskName };
       } catch (error) {
         log.error('Failed to create PR worktree:', error);
         const message =
diff --git a/src/main/preload.ts b/src/main/preload.ts
index 77931c9a..76a3ddac 100644
--- a/src/main/preload.ts
+++ b/src/main/preload.ts
@@ -85,7 +85,7 @@ contextBridge.exposeInMainWorld('electronAPI', {
   // Worktree management
   worktreeCreate: (args: {
     projectPath: string;
-    workspaceName: string;
+    taskName: string;
     projectId: string;
     autoApprove?: boolean;
   }) => ipcRenderer.invoke('worktree:create', args),
@@ -241,7 +241,7 @@ contextBridge.exposeInMainWorld('electronAPI', {
     projectId: string;
     prNumber: number;
     prTitle?: string;
-    workspaceName?: string;
+    taskName?: string;
     branchName?: string;
   }) => ipcRenderer.invoke('github:createPullRequestWorktree', args),
   githubLogout: () => ipcRenderer.invoke('github:logout'),
@@ -424,7 +424,7 @@ export interface ElectronAPI {
   // Worktree management
   worktreeCreate: (args: {
     projectPath: string;
-    workspaceName: string;
+    taskName: string;
     projectId: string;
     autoApprove?: boolean;
   }) => Promise<{ success: boolean; worktree?: any; error?: string }>;
@@ -608,13 +608,13 @@ export interface ElectronAPI {
     projectId: string;
     prNumber: number;
     prTitle?: string;
-    workspaceName?: string;
+    taskName?: string;
     branchName?: string;
   }) => Promise<{
     success: boolean;
     worktree?: any;
     branchName?: string;
-    workspaceName?: string;
+    taskName?: string;
     error?: string;
   }>;
   githubLogout: () => Promise<void>;
diff --git a/src/main/services/LinearService.ts b/src/main/services/LinearService.ts
index 1cb5311c..663c1b8e 100644
--- a/src/main/services/LinearService.ts
+++ b/src/main/services/LinearService.ts
@@ -13,7 +13,7 @@ export interface LinearViewer {
 
 export interface LinearConnectionStatus {
   connected: boolean;
-  workspaceName?: string;
+  taskName?: string;
   viewer?: LinearViewer;
   error?: string;
 }
@@ -29,7 +29,7 @@ export class LinearService {
 
   async saveToken(
     token: string
-  ): Promise<{ success: boolean; workspaceName?: string; error?: string }> {
+  ): Promise<{ success: boolean; taskName?: string; error?: string }> {
     try {
       const viewer = await this.fetchViewer(token);
       await this.storeToken(token);
@@ -39,7 +39,7 @@ export class LinearService {
       });
       return {
         success: true,
-        workspaceName: viewer?.organization?.name ?? viewer?.displayName ?? undefined,
+        taskName: viewer?.organization?.name ?? viewer?.displayName ?? undefined,
       };
     } catch (error) {
       const message =
@@ -78,7 +78,7 @@ export class LinearService {
       const viewer = await this.fetchViewer(token);
       return {
         connected: true,
-        workspaceName: viewer?.organization?.name ?? viewer?.displayName ?? undefined,
+        taskName: viewer?.organization?.name ?? viewer?.displayName ?? undefined,
         viewer,
       };
     } catch (error) {
diff --git a/src/main/services/WorktreeService.ts b/src/main/services/WorktreeService.ts
index 8356c1ee..c977be0b 100644
--- a/src/main/services/WorktreeService.ts
+++ b/src/main/services/WorktreeService.ts
@@ -49,12 +49,12 @@ export class WorktreeService {
    */
   async createWorktree(
     projectPath: string,
-    workspaceName: string,
+    taskName: string,
     projectId: string,
     autoApprove?: boolean
   ): Promise<WorktreeInfo> {
     try {
-      const sluggedName = this.slugify(workspaceName);
+      const sluggedName = this.slugify(taskName);
       const timestamp = Date.now();
       const { getAppSettings } = await import('../settings');
       const settings = getAppSettings();
@@ -113,7 +113,7 @@ export class WorktreeService {
 
       const worktreeInfo: WorktreeInfo = {
         id: worktreeId,
-        name: workspaceName,
+        name: taskName,
         branch: branchName,
         path: worktreePath,
         projectId,
@@ -123,7 +123,7 @@ export class WorktreeService {
 
       this.worktrees.set(worktreeInfo.id, worktreeInfo);
 
-      log.info(`Created worktree: ${workspaceName} -> ${branchName}`);
+      log.info(`Created worktree: ${taskName} -> ${branchName}`);
 
       // Push the new branch to origin and set upstream so PRs work out of the box
       if (settings?.repository?.pushOnCreate !== false) {
@@ -768,12 +768,12 @@ export class WorktreeService {
 
   async createWorktreeFromBranch(
     projectPath: string,
-    workspaceName: string,
+    taskName: string,
     branchName: string,
     projectId: string,
     options?: { worktreePath?: string }
   ): Promise<WorktreeInfo> {
-    const normalizedName = workspaceName || branchName.replace(/\//g, '-');
+    const normalizedName = taskName || branchName.replace(/\//g, '-');
     const sluggedName = this.slugify(normalizedName) || 'workspace';
     const targetPath =
       options?.worktreePath ||
diff --git a/src/main/services/worktreeIpc.ts b/src/main/services/worktreeIpc.ts
index 83f0002e..237b96e0 100644
--- a/src/main/services/worktreeIpc.ts
+++ b/src/main/services/worktreeIpc.ts
@@ -9,7 +9,7 @@ export function registerWorktreeIpc(): void {
       event,
       args: {
         projectPath: string;
-        workspaceName: string;
+        taskName: string;
         projectId: string;
         autoApprove?: boolean;
       }
@@ -17,7 +17,7 @@ export function registerWorktreeIpc(): void {
       try {
         const worktree = await worktreeService.createWorktree(
           args.projectPath,
-          args.workspaceName,
+          args.taskName,
           args.projectId,
           args.autoApprove
         );
diff --git a/src/renderer/App.tsx b/src/renderer/App.tsx
index 957bb226..767a38b2 100644
--- a/src/renderer/App.tsx
+++ b/src/renderer/App.tsx
@@ -703,7 +703,7 @@ const AppContent: React.FC = () => {
   };
 
   const handleCreateWorkspace = async (
-    workspaceName: string,
+    taskName: string,
     initialPrompt?: string,
     providerRuns: import('./types/chat').ProviderRun[] = [{ provider: 'claude', runs: 1 }],
     linkedLinearIssue: LinearIssueSummary | null = null,
@@ -840,10 +840,10 @@ const AppContent: React.FC = () => {
         for (const { provider, runs } of providerRuns) {
           for (let instanceIdx = 1; instanceIdx <= runs; instanceIdx++) {
             const instanceSuffix = runs > 1 ? `-${instanceIdx}` : '';
-            const variantName = `${workspaceName}-${provider.toLowerCase()}${instanceSuffix}`;
+            const variantName = `${taskName}-${provider.toLowerCase()}${instanceSuffix}`;
             const worktreeResult = await window.electronAPI.worktreeCreate({
               projectPath: selectedProject.path,
-              workspaceName: variantName,
+              taskName: variantName,
               projectId: selectedProject.id,
               autoApprove,
             });
@@ -855,7 +855,7 @@ const AppContent: React.FC = () => {
             }
             const worktree = worktreeResult.worktree;
             variants.push({
-              id: `${workspaceName}-${provider.toLowerCase()}${instanceSuffix}`,
+              id: `${taskName}-${provider.toLowerCase()}${instanceSuffix}`,
               provider: provider,
               name: variantName,
               branch: worktree.branch,
@@ -876,11 +876,11 @@ const AppContent: React.FC = () => {
           },
         };
 
-        const groupId = `ws-${workspaceName}-${Date.now()}`;
+        const groupId = `ws-${taskName}-${Date.now()}`;
         newWorkspace = {
           id: groupId,
           projectId: selectedProject.id,
-          name: workspaceName,
+          name: taskName,
           branch: variants[0]?.branch || selectedProject.gitInfo.branch || 'main',
           path: variants[0]?.path || selectedProject.path,
           status: 'idle',
@@ -904,7 +904,7 @@ const AppContent: React.FC = () => {
         // Create worktree
         const worktreeResult = await window.electronAPI.worktreeCreate({
           projectPath: selectedProject.path,
-          workspaceName,
+          taskName,
           projectId: selectedProject.id,
           autoApprove,
         });
@@ -918,7 +918,7 @@ const AppContent: React.FC = () => {
         newWorkspace = {
           id: worktree.id,
           projectId: selectedProject.id,
-          name: workspaceName,
+          name: taskName,
           branch: worktree.branch,
           path: worktree.path,
           status: 'idle',
diff --git a/src/renderer/components/IntegrationsCard.tsx b/src/renderer/components/IntegrationsCard.tsx
index 1a10214a..4691347f 100644
--- a/src/renderer/components/IntegrationsCard.tsx
+++ b/src/renderer/components/IntegrationsCard.tsx
@@ -75,7 +75,7 @@ const IntegrationsCard: React.FC = () => {
         ...prev,
         checking: false,
         connected: !!status?.connected,
-        detail: status?.workspaceName ?? null,
+        detail: status?.taskName ?? null,
         error: status?.connected ? null : null,
       }));
     } catch (error) {
@@ -148,7 +148,7 @@ const IntegrationsCard: React.FC = () => {
           checking: false,
           loading: false,
           connected: true,
-          detail: result?.workspaceName ?? null,
+          detail: result?.taskName ?? null,
           input: '',
           error: null,
         }));
diff --git a/src/renderer/components/ProjectMainView.tsx b/src/renderer/components/ProjectMainView.tsx
index 1ba8aa71..f7b1cf89 100644
--- a/src/renderer/components/ProjectMainView.tsx
+++ b/src/renderer/components/ProjectMainView.tsx
@@ -350,7 +350,7 @@ function WorkspaceRow({
             />
           ) : (
             <WorkspaceDeleteButton
-              workspaceName={ws.name}
+              taskName={ws.name}
               taskId={ws.id}
               taskPath={ws.path}
               onConfirm={async () => {
diff --git a/src/renderer/components/TaskDeleteButton.tsx b/src/renderer/components/TaskDeleteButton.tsx
index 5ee482a6..666a2552 100644
--- a/src/renderer/components/TaskDeleteButton.tsx
+++ b/src/renderer/components/TaskDeleteButton.tsx
@@ -19,7 +19,7 @@ import { useDeleteRisks } from '../hooks/useDeleteRisks';
 import DeletePrNotice from './DeletePrNotice';
 
 type Props = {
-  workspaceName: string;
+  taskName: string;
   taskId: string;
   taskPath: string;
   onConfirm: () => void | Promise<void | boolean>;
@@ -29,7 +29,7 @@ type Props = {
 };
 
 export const WorkspaceDeleteButton: React.FC<Props> = ({
-  workspaceName,
+  taskName,
   taskId,
   taskPath,
   onConfirm,
@@ -40,8 +40,8 @@ export const WorkspaceDeleteButton: React.FC<Props> = ({
   const [open, setOpen] = React.useState(false);
   const [acknowledge, setAcknowledge] = React.useState(false);
   const targets = useMemo(
-    () => [{ id: taskId, name: workspaceName, path: taskPath }],
-    [taskId, workspaceName, taskPath]
+    () => [{ id: taskId, name: taskName, path: taskPath }],
+    [taskId, taskName, taskPath]
   );
   const { risks, loading, hasData } = useDeleteRisks(targets, open);
   const status = risks[taskId] || {
@@ -122,7 +122,7 @@ export const WorkspaceDeleteButton: React.FC<Props> = ({
                 <p className="font-medium">Unmerged or unpushed work detected</p>
                 <div className="flex items-center gap-2 rounded-md bg-amber-50/80 px-2 py-1 text-amber-900 dark:bg-amber-500/10 dark:text-amber-50">
                   <Folder className="h-4 w-4 fill-amber-700 text-amber-700" />
-                  <span className="font-medium">{workspaceName}</span>
+                  <span className="font-medium">{taskName}</span>
                   <span className="text-muted-foreground">—</span>
                   <span>
                     {[
@@ -149,7 +149,7 @@ export const WorkspaceDeleteButton: React.FC<Props> = ({
                   </span>
                 </div>
                 {status.pr ? (
-                  <DeletePrNotice workspaces={[{ name: workspaceName, pr: status.pr }]} />
+                  <DeletePrNotice workspaces={[{ name: taskName, pr: status.pr }]} />
                 ) : null}
               </motion.div>
             ) : null}
diff --git a/src/renderer/components/TaskItem.tsx b/src/renderer/components/TaskItem.tsx
index 994e58f5..93c83bfa 100644
--- a/src/renderer/components/TaskItem.tsx
+++ b/src/renderer/components/TaskItem.tsx
@@ -50,7 +50,7 @@ export const TaskItem: React.FC<TaskItemProps> = ({
       <div className="relative flex flex-shrink-0 items-center pl-6">
         {showDelete && onDelete ? (
           <TaskDeleteButton
-            workspaceName={task.name}
+            taskName={task.name}
             taskId={task.id}
             taskPath={task.path}
             onConfirm={async () => {
diff --git a/src/renderer/components/kanban/KanbanCard.tsx b/src/renderer/components/kanban/KanbanCard.tsx
index 8078ae3a..0624743f 100644
--- a/src/renderer/components/kanban/KanbanCard.tsx
+++ b/src/renderer/components/kanban/KanbanCard.tsx
@@ -45,7 +45,7 @@ const KanbanCard: React.FC<{
       side="top"
       delay={150}
       taskPath={ws.path}
-      workspaceName={ws.name}
+      taskName={ws.name}
     >
       <div
         role="button"
diff --git a/src/renderer/components/kanban/ProviderTooltip.tsx b/src/renderer/components/kanban/ProviderTooltip.tsx
index 904fc7b4..4cfabdc2 100644
--- a/src/renderer/components/kanban/ProviderTooltip.tsx
+++ b/src/renderer/components/kanban/ProviderTooltip.tsx
@@ -11,7 +11,7 @@ type ProviderTooltipProps = {
   delay?: number;
   children: React.ReactNode;
   taskPath?: string;
-  workspaceName?: string;
+  taskName?: string;
 };
 
 export const ProviderTooltip: React.FC<ProviderTooltipProps> = ({
@@ -21,7 +21,7 @@ export const ProviderTooltip: React.FC<ProviderTooltipProps> = ({
   delay = 150,
   children,
   taskPath,
-  workspaceName,
+  taskName,
 }) => {
   const items = React.useMemo(() => {
     const seen = new Set<string>();
@@ -110,11 +110,11 @@ export const ProviderTooltip: React.FC<ProviderTooltipProps> = ({
           side={side}
           className="max-w-xs rounded-md border border-border bg-background p-2 text-xs shadow-sm"
         >
-          {workspaceName ? (
+          {taskName ? (
             <div className="mb-1 flex items-center gap-1.5 text-[13px] font-semibold leading-tight text-foreground">
               <GitBranch className="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
-              <span className="truncate" title={workspaceName}>
-                {workspaceName}
+              <span className="truncate" title={taskName}>
+                {taskName}
               </span>
             </div>
           ) : null}
diff --git a/src/renderer/types/electron-api.d.ts b/src/renderer/types/electron-api.d.ts
index ad24fc88..6cd60bcd 100644
--- a/src/renderer/types/electron-api.d.ts
+++ b/src/renderer/types/electron-api.d.ts
@@ -151,7 +151,7 @@ declare global {
       // Worktree management
       worktreeCreate: (args: {
         projectPath: string;
-        workspaceName: string;
+        taskName: string;
         projectId: string;
         autoApprove?: boolean;
       }) => Promise<{ success: boolean; worktree?: any; error?: string }>;
@@ -493,25 +493,25 @@ declare global {
         projectId: string;
         prNumber: number;
         prTitle?: string;
-        workspaceName?: string;
+        taskName?: string;
         branchName?: string;
       }) => Promise<{
         success: boolean;
         worktree?: any;
         branchName?: string;
-        workspaceName?: string;
+        taskName?: string;
         error?: string;
       }>;
       githubLogout: () => Promise<void>;
       // Linear integration
       linearCheckConnection?: () => Promise<{
         connected: boolean;
-        workspaceName?: string;
+        taskName?: string;
         error?: string;
       }>;
       linearSaveToken?: (token: string) => Promise<{
         success: boolean;
-        workspaceName?: string;
+        taskName?: string;
         error?: string;
       }>;
       linearClearToken?: () => Promise<{
@@ -642,7 +642,7 @@ export interface ElectronAPI {
   // Worktree management
   worktreeCreate: (args: {
     projectPath: string;
-    workspaceName: string;
+    taskName: string;
     projectId: string;
     autoApprove?: boolean;
   }) => Promise<{ success: boolean; worktree?: any; error?: string }>;
@@ -842,13 +842,13 @@ export interface ElectronAPI {
     projectId: string;
     prNumber: number;
     prTitle?: string;
-    workspaceName?: string;
+    taskName?: string;
     branchName?: string;
   }) => Promise<{
     success: boolean;
     worktree?: any;
     branchName?: string;
-    workspaceName?: string;
+    taskName?: string;
     error?: string;
   }>;
   githubLogout: () => Promise<void>;
@@ -870,12 +870,12 @@ export interface ElectronAPI {
   // Linear integration
   linearCheckConnection?: () => Promise<{
     connected: boolean;
-    workspaceName?: string;
+    taskName?: string;
     error?: string;
   }>;
   linearSaveToken?: (token: string) => Promise<{
     success: boolean;
-    workspaceName?: string;
+    taskName?: string;
     error?: string;
   }>;
   linearClearToken?: () => Promise<{
diff --git a/src/renderer/types/global.d.ts b/src/renderer/types/global.d.ts
index cac20ddc..709c7411 100644
--- a/src/renderer/types/global.d.ts
+++ b/src/renderer/types/global.d.ts
@@ -47,7 +47,7 @@ declare global {
       // Worktree management
       worktreeCreate: (args: {
         projectPath: string;
-        workspaceName: string;
+        taskName: string;
         projectId: string;
         autoApprove?: boolean;
       }) => Promise<{ success: boolean; worktree?: any; error?: string }>;
@@ -164,13 +164,13 @@ declare global {
         projectId: string;
         prNumber: number;
         prTitle?: string;
-        workspaceName?: string;
+        taskName?: string;
         branchName?: string;
       }) => Promise<{
         success: boolean;
         worktree?: any;
         branchName?: string;
-        workspaceName?: string;
+        taskName?: string;
         error?: string;
       }>;
       githubLogout: () => Promise<void>;
@@ -178,11 +178,11 @@ declare global {
       updateSettings: (settings: any) => Promise<void>;
       linearCheckConnection?: () => Promise<{
         connected: boolean;
-        workspaceName?: string;
+        taskName?: string;
       }>;
       linearSaveToken?: (token: string) => Promise<{
         success: boolean;
-        workspaceName?: string;
+        taskName?: string;
         error?: string;
       }>;
       linearClearToken?: () => Promise<{

From ef7f8d5f158cc3c1dd9a0c8781c64eee1993b7ff Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Fri, 12 Dec 2025 17:33:06 -0800
Subject: [PATCH 05/35] refactor: rename workspaceMetadata to taskMetadata

---
 src/renderer/App.tsx | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/renderer/App.tsx b/src/renderer/App.tsx
index 767a38b2..fbb6024f 100644
--- a/src/renderer/App.tsx
+++ b/src/renderer/App.tsx
@@ -809,7 +809,7 @@ const AppContent: React.FC = () => {
         preparedPrompt = parts.join('\n');
       }
 
-      const workspaceMetadata: TaskMetadata | null =
+      const taskMetadata: TaskMetadata | null =
         linkedLinearIssue || linkedJiraIssue || linkedGithubIssue || preparedPrompt || autoApprove
           ? {
               linearIssue: linkedLinearIssue ?? null,
@@ -866,7 +866,7 @@ const AppContent: React.FC = () => {
         }
 
         const multiMeta: TaskMetadata = {
-          ...(workspaceMetadata || {}),
+          ...(taskMetadata || {}),
           multiAgent: {
             enabled: true,
             maxProviders: 4,
@@ -923,13 +923,13 @@ const AppContent: React.FC = () => {
           path: worktree.path,
           status: 'idle',
           agentId: primaryProvider,
-          metadata: workspaceMetadata,
+          metadata: taskMetadata,
         };
 
         const saveResult = await window.electronAPI.saveWorkspace({
           ...newWorkspace,
           agentId: primaryProvider,
-          metadata: workspaceMetadata,
+          metadata: taskMetadata,
         });
         if (!saveResult?.success) {
           const { log } = await import('./lib/logger');
@@ -941,14 +941,14 @@ const AppContent: React.FC = () => {
       }
 
       {
-        if (workspaceMetadata?.linearIssue) {
+        if (taskMetadata?.linearIssue) {
           try {
             const convoResult = await window.electronAPI.getOrCreateDefaultConversation(
               newWorkspace.id
             );
 
             if (convoResult?.success && convoResult.conversation?.id) {
-              const issue = workspaceMetadata.linearIssue;
+              const issue = taskMetadata.linearIssue;
               const detailParts: string[] = [];
               const stateName = issue.state?.name?.trim();
               const assigneeName =
@@ -993,14 +993,14 @@ const AppContent: React.FC = () => {
             log.error('Failed to seed workspace with Linear issue context:', seedError as any);
           }
         }
-        if (workspaceMetadata?.githubIssue) {
+        if (taskMetadata?.githubIssue) {
           try {
             const convoResult = await window.electronAPI.getOrCreateDefaultConversation(
               newWorkspace.id
             );
 
             if (convoResult?.success && convoResult.conversation?.id) {
-              const issue = workspaceMetadata.githubIssue;
+              const issue = taskMetadata.githubIssue;
               const detailParts: string[] = [];
               const stateName = issue.state?.toString()?.trim();
               const assignees = Array.isArray(issue.assignees)
@@ -1051,14 +1051,14 @@ const AppContent: React.FC = () => {
             log.error('Failed to seed workspace with GitHub issue context:', seedError as any);
           }
         }
-        if (workspaceMetadata?.jiraIssue) {
+        if (taskMetadata?.jiraIssue) {
           try {
             const convoResult = await window.electronAPI.getOrCreateDefaultConversation(
               newWorkspace.id
             );
 
             if (convoResult?.success && convoResult.conversation?.id) {
-              const issue: any = workspaceMetadata.jiraIssue;
+              const issue: any = taskMetadata.jiraIssue;
               const lines: string[] = [];
               const line1 =
                 `Linked Jira issue: ${issue.key || ''}${issue.summary ? ` — ${issue.summary}` : ''}`.trim();
@@ -1114,7 +1114,7 @@ const AppContent: React.FC = () => {
         const isMultiAgent = (newWorkspace.metadata as any)?.multiAgent?.enabled;
         captureTelemetry('workspace_created', {
           provider: isMultiAgent ? 'multi' : (newWorkspace.agentId as string) || 'codex',
-          has_initial_prompt: !!workspaceMetadata?.initialPrompt,
+          has_initial_prompt: !!taskMetadata?.initialPrompt,
         });
 
         // Set the active workspace and its provider (none if multi-agent)

From 5a6b63dff930ac158da1f3081cc4a9c1810c0750 Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Fri, 12 Dec 2025 17:34:49 -0800
Subject: [PATCH 06/35] refactor: rename workspace handler functions to task

---
 src/renderer/App.tsx                          | 32 +++++++++----------
 src/renderer/components/CommandPalette.tsx    | 10 +++---
 .../components/CommandPaletteWrapper.tsx      |  8 ++---
 src/renderer/components/TaskModal.tsx         |  6 ++--
 .../components/kanban/KanbanBoard.tsx         | 20 ++++++------
 5 files changed, 38 insertions(+), 38 deletions(-)

diff --git a/src/renderer/App.tsx b/src/renderer/App.tsx
index fbb6024f..386e27c3 100644
--- a/src/renderer/App.tsx
+++ b/src/renderer/App.tsx
@@ -702,7 +702,7 @@ const AppContent: React.FC = () => {
     }
   };
 
-  const handleCreateWorkspace = async (
+  const handleCreateTask = async (
     taskName: string,
     initialPrompt?: string,
     providerRuns: import('./types/chat').ProviderRun[] = [{ provider: 'claude', runs: 1 }],
@@ -1152,7 +1152,7 @@ const AppContent: React.FC = () => {
     activateProjectView(project);
   };
 
-  const handleSelectWorkspace = (workspace: Task) => {
+  const handleSelectTask = (workspace: Task) => {
     setActiveWorkspace(workspace);
     // Load provider from workspace.agentId if it exists, otherwise default to null
     // This ensures the selected provider persists across app restarts
@@ -1164,7 +1164,7 @@ const AppContent: React.FC = () => {
     }
   };
 
-  const handleStartCreateWorkspaceFromSidebar = useCallback(
+  const handleStartCreateTaskFromSidebar = useCallback(
     (project: Project) => {
       const targetProject = projects.find((p) => p.id === project.id) || project;
       activateProjectView(targetProject);
@@ -1197,7 +1197,7 @@ const AppContent: React.FC = () => {
     }
   };
 
-  const handleDeleteWorkspace = async (
+  const handleDeleteTask = async (
     targetProject: Project,
     workspace: Task,
     options?: { silent?: boolean }
@@ -1326,7 +1326,7 @@ const AppContent: React.FC = () => {
           if (wasActive) {
             const restored = refreshedWorkspaces.find((w) => w.id === workspace.id);
             if (restored) {
-              handleSelectWorkspace(restored);
+              handleSelectTask(restored);
             }
           }
         } catch (refreshError) {
@@ -1352,7 +1352,7 @@ const AppContent: React.FC = () => {
           });
 
           if (wasActive) {
-            handleSelectWorkspace(workspaceSnapshot);
+            handleSelectTask(workspaceSnapshot);
           }
         }
         return false;
@@ -1486,11 +1486,11 @@ const AppContent: React.FC = () => {
         <div className="flex min-h-0 flex-1 flex-col overflow-hidden">
           <KanbanBoard
             project={selectedProject}
-            onOpenWorkspace={(ws: any) => {
-              handleSelectWorkspace(ws);
+            onOpenTask={(ws: any) => {
+              handleSelectTask(ws);
               setShowKanban(false);
             }}
-            onCreateWorkspace={() => setShowTaskModal(true)}
+            onCreateTask={() => setShowTaskModal(true)}
           />
         </div>
       );
@@ -1579,8 +1579,8 @@ const AppContent: React.FC = () => {
               project={selectedProject}
               onCreateTask={() => setShowTaskModal(true)}
               activeTask={activeTask}
-              onSelectTask={handleSelectWorkspace}
-              onDeleteTask={handleDeleteWorkspace}
+              onSelectTask={handleSelectTask}
+              onDeleteTask={handleDeleteTask}
               isCreatingTask={isCreatingTask}
               onDeleteProject={handleDeleteProject}
             />
@@ -1692,7 +1692,7 @@ const AppContent: React.FC = () => {
                     onSelectProject={handleSelectProject}
                     onGoHome={handleGoHome}
                     onOpenProject={handleOpenProject}
-                    onSelectTask={handleSelectWorkspace}
+                    onSelectTask={handleSelectTask}
                     activeTask={activeTask || undefined}
                     onReorderProjects={handleReorderProjects}
                     onReorderProjectsFull={handleReorderProjectsFull}
@@ -1703,9 +1703,9 @@ const AppContent: React.FC = () => {
                     githubLoading={githubLoading}
                     githubStatusMessage={githubStatusMessage}
                     onSidebarContextChange={handleSidebarContextChange}
-                    onCreateTaskForProject={handleStartCreateWorkspaceFromSidebar}
+                    onCreateTaskForProject={handleStartCreateTaskFromSidebar}
                     isCreatingTask={isCreatingTask}
-                    onDeleteTask={handleDeleteWorkspace}
+                    onDeleteTask={handleDeleteTask}
                     onDeleteProject={handleDeleteProject}
                     isHomeView={showHomeView}
                   />
@@ -1748,7 +1748,7 @@ const AppContent: React.FC = () => {
               onClose={handleCloseCommandPalette}
               projects={projects}
               handleSelectProject={handleSelectProject}
-              handleSelectWorkspace={handleSelectWorkspace}
+              handleSelectTask={handleSelectTask}
               handleGoHome={handleGoHome}
               handleOpenProject={handleOpenProject}
               handleOpenSettings={handleOpenSettings}
@@ -1756,7 +1756,7 @@ const AppContent: React.FC = () => {
             <TaskModal
               isOpen={showTaskModal}
               onClose={() => setShowTaskModal(false)}
-              onCreateWorkspace={handleCreateWorkspace}
+              onCreateTask={handleCreateTask}
               projectName={selectedProject?.name || ''}
               defaultBranch={selectedProject?.gitInfo.branch || 'main'}
               existingNames={(selectedProject?.workspaces || []).map((w) => w.name)}
diff --git a/src/renderer/components/CommandPalette.tsx b/src/renderer/components/CommandPalette.tsx
index aacb0b1a..387a37d3 100644
--- a/src/renderer/components/CommandPalette.tsx
+++ b/src/renderer/components/CommandPalette.tsx
@@ -33,7 +33,7 @@ interface CommandPaletteProps {
     }>;
   }>;
   onSelectProject?: (projectId: string) => void;
-  onSelectWorkspace?: (projectId: string, taskId: string) => void;
+  onSelectTask?: (projectId: string, taskId: string) => void;
   onOpenSettings?: () => void;
   onToggleLeftSidebar?: () => void;
   onToggleRightSidebar?: () => void;
@@ -61,7 +61,7 @@ const CommandPalette: React.FC<CommandPaletteProps> = ({
   onClose,
   projects = [],
   onSelectProject,
-  onSelectWorkspace,
+  onSelectTask,
   onOpenSettings,
   onToggleLeftSidebar,
   onToggleRightSidebar,
@@ -209,7 +209,7 @@ const CommandPalette: React.FC<CommandPaletteProps> = ({
       }
 
       // Workspace commands
-      if (project.workspaces && onSelectWorkspace) {
+      if (project.workspaces && onSelectTask) {
         project.workspaces.forEach((workspace) => {
           items.push({
             id: `workspace-${project.id}-${workspace.id}`,
@@ -223,7 +223,7 @@ const CommandPalette: React.FC<CommandPaletteProps> = ({
               workspace.branch.toLowerCase(),
               project.name.toLowerCase(),
             ],
-            onSelect: () => runCommand(() => onSelectWorkspace(project.id, workspace.id)),
+            onSelect: () => runCommand(() => onSelectTask(project.id, workspace.id)),
           });
         });
       }
@@ -236,7 +236,7 @@ const CommandPalette: React.FC<CommandPaletteProps> = ({
     onOpenProject,
     onOpenSettings,
     onSelectProject,
-    onSelectWorkspace,
+    onSelectTask,
     onToggleLeftSidebar,
     onToggleRightSidebar,
     onToggleTheme,
diff --git a/src/renderer/components/CommandPaletteWrapper.tsx b/src/renderer/components/CommandPaletteWrapper.tsx
index 24746584..84317f0b 100644
--- a/src/renderer/components/CommandPaletteWrapper.tsx
+++ b/src/renderer/components/CommandPaletteWrapper.tsx
@@ -10,7 +10,7 @@ export interface CommandPaletteWrapperProps {
   onClose: () => void;
   projects: Project[];
   handleSelectProject: (project: Project) => void;
-  handleSelectWorkspace: (workspace: Task) => void;
+  handleSelectTask: (workspace: Task) => void;
   handleGoHome: () => void;
   handleOpenProject: () => void;
   handleOpenSettings: () => void;
@@ -21,7 +21,7 @@ const CommandPaletteWrapper: React.FC<CommandPaletteWrapperProps> = ({
   onClose,
   projects,
   handleSelectProject,
-  handleSelectWorkspace,
+  handleSelectTask,
   handleGoHome,
   handleOpenProject,
   handleOpenSettings,
@@ -39,12 +39,12 @@ const CommandPaletteWrapper: React.FC<CommandPaletteWrapperProps> = ({
         const project = projects.find((p) => p.id === projectId);
         if (project) handleSelectProject(project);
       }}
-      onSelectWorkspace={(projectId, taskId) => {
+      onSelectTask={(projectId, taskId) => {
         const project = projects.find((p) => p.id === projectId);
         const workspace = project?.workspaces?.find((w: Task) => w.id === taskId);
         if (project && workspace) {
           handleSelectProject(project);
-          handleSelectWorkspace(workspace);
+          handleSelectTask(workspace);
         }
       }}
       onOpenSettings={handleOpenSettings}
diff --git a/src/renderer/components/TaskModal.tsx b/src/renderer/components/TaskModal.tsx
index 29e921eb..2c8a3d9e 100644
--- a/src/renderer/components/TaskModal.tsx
+++ b/src/renderer/components/TaskModal.tsx
@@ -36,7 +36,7 @@ import { useGithubAuth } from '../hooks/useGithubAuth';
 interface TaskModalProps {
   isOpen: boolean;
   onClose: () => void;
-  onCreateWorkspace: (
+  onCreateTask: (
     name: string,
     initialPrompt?: string,
     providerRuns?: ProviderRun[],
@@ -54,7 +54,7 @@ interface TaskModalProps {
 const TaskModal: React.FC<TaskModalProps> = ({
   isOpen,
   onClose,
-  onCreateWorkspace,
+  onCreateTask,
   projectName,
   defaultBranch,
   existingNames = [],
@@ -410,7 +410,7 @@ const TaskModal: React.FC<TaskModalProps> = ({
                     setIsCreating(true);
                     (async () => {
                       try {
-                        await onCreateWorkspace(
+                        await onCreateTask(
                           normalizeTaskName(taskName),
                           showAdvanced ? initialPrompt.trim() || undefined : undefined,
                           providerRuns,
diff --git a/src/renderer/components/kanban/KanbanBoard.tsx b/src/renderer/components/kanban/KanbanBoard.tsx
index c80bb0f1..bf594caa 100644
--- a/src/renderer/components/kanban/KanbanBoard.tsx
+++ b/src/renderer/components/kanban/KanbanBoard.tsx
@@ -22,9 +22,9 @@ const titles: Record<KanbanStatus, string> = {
 
 const KanbanBoard: React.FC<{
   project: Project;
-  onOpenWorkspace?: (ws: Task) => void;
-  onCreateWorkspace?: () => void;
-}> = ({ project, onOpenWorkspace, onCreateWorkspace }) => {
+  onOpenTask?: (ws: Task) => void;
+  onCreateTask?: () => void;
+}> = ({ project, onOpenTask, onCreateTask }) => {
   const [statusMap, setStatusMap] = React.useState<Record<string, KanbanStatus>>({});
 
   React.useEffect(() => {
@@ -281,12 +281,12 @@ const KanbanBoard: React.FC<{
           count={byStatus[s].length}
           onDropCard={(id) => handleDrop(s, id)}
           action={
-            s === 'todo' && onCreateWorkspace ? (
+            s === 'todo' && onCreateTask ? (
               <Button
                 variant="ghost"
                 size="icon"
                 className="h-8 w-8 rounded-md border border-border/60 bg-muted text-foreground shadow-sm hover:bg-muted/80"
-                onClick={onCreateWorkspace}
+                onClick={onCreateTask}
                 aria-label="Start New Task"
               >
                 <Plus className="h-4 w-4" aria-hidden="true" />
@@ -295,7 +295,7 @@ const KanbanBoard: React.FC<{
           }
         >
           {byStatus[s].length === 0 ? (
-            s === 'todo' && !hasAny && onCreateWorkspace ? (
+            s === 'todo' && !hasAny && onCreateTask ? (
               <div className="flex h-full flex-col">
                 <div className="rounded-lg border border-dashed border-border/70 bg-muted/20 p-4 text-center text-sm text-muted-foreground">
                   <div className="mx-auto mb-2 inline-flex h-7 w-7 items-center justify-center rounded-full border border-dashed border-border/60 bg-background/60">
@@ -304,7 +304,7 @@ const KanbanBoard: React.FC<{
                   <span className="ml-2">No items</span>
                 </div>
                 <div className="flex flex-1 items-center justify-center">
-                  <Button variant="default" size="sm" onClick={onCreateWorkspace}>
+                  <Button variant="default" size="sm" onClick={onCreateTask}>
                     <Plus className="mr-1.5 h-3.5 w-3.5" />
                     Start New Task
                   </Button>
@@ -321,14 +321,14 @@ const KanbanBoard: React.FC<{
           ) : (
             <>
               {byStatus[s].map((ws) => (
-                <KanbanCard key={ws.id} ws={ws} onOpen={onOpenWorkspace} />
+                <KanbanCard key={ws.id} ws={ws} onOpen={onOpenTask} />
               ))}
-              {s === 'todo' && onCreateWorkspace ? (
+              {s === 'todo' && onCreateTask ? (
                 <Button
                   variant="ghost"
                   size="sm"
                   className="mt-1 w-full justify-center text-xs font-medium"
-                  onClick={onCreateWorkspace}
+                  onClick={onCreateTask}
                 >
                   <Plus className="mr-1.5 h-3.5 w-3.5" />
                   Start New Task

From 92f8eece76db69e68470f65eee64b751d25573e3 Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Fri, 12 Dec 2025 17:38:19 -0800
Subject: [PATCH 07/35] refactor: rename workspace state variables to task

---
 src/renderer/App.tsx                   | 96 +++++++++++++-------------
 src/renderer/lib/taskTerminalsStore.ts |  8 +--
 2 files changed, 52 insertions(+), 52 deletions(-)

diff --git a/src/renderer/App.tsx b/src/renderer/App.tsx
index 386e27c3..80c64658 100644
--- a/src/renderer/App.tsx
+++ b/src/renderer/App.tsx
@@ -121,9 +121,9 @@ const AppContent: React.FC = () => {
   const [selectedProject, setSelectedProject] = useState<Project | null>(null);
   const [showTaskModal, setShowTaskModal] = useState<boolean>(false);
   const [showHomeView, setShowHomeView] = useState<boolean>(true);
-  const [isCreatingTask, setIsCreatingWorkspace] = useState<boolean>(false);
-  const [activeTask, setActiveWorkspace] = useState<Task | null>(null);
-  const [activeTaskProvider, setActiveWorkspaceProvider] = useState<Provider | null>(null);
+  const [isCreatingTask, setIsCreatingTask] = useState<boolean>(false);
+  const [activeTask, setActiveTask] = useState<Task | null>(null);
+  const [activeTaskProvider, setActiveTaskProvider] = useState<Provider | null>(null);
   const [installedProviders, setInstalledProviders] = useState<Record<string, boolean>>({});
   const [showSettings, setShowSettings] = useState<boolean>(false);
   const [showCommandPalette, setShowCommandPalette] = useState<boolean>(false);
@@ -323,7 +323,7 @@ const AppContent: React.FC = () => {
     })();
     setSelectedProject(project);
     setShowHomeView(false);
-    setActiveWorkspace(null);
+    setActiveTask(null);
   }, []);
 
   const handleRightSidebarCollapsedChange = useCallback((collapsed: boolean) => {
@@ -457,13 +457,13 @@ const AppContent: React.FC = () => {
         // Refresh GH status via hook
         checkStatus();
 
-        const projectsWithWorkspaces = await Promise.all(
+        const projectsWithTasks = await Promise.all(
           initialProjects.map(async (project) => {
             const workspaces = await window.electronAPI.getWorkspaces(project.id);
             return withRepoKey({ ...project, workspaces });
           })
         );
-        const ordered = applyProjectOrder(projectsWithWorkspaces);
+        const ordered = applyProjectOrder(projectsWithTasks);
         setProjects(ordered);
 
         // Prefer cached provider status (populated in the background)
@@ -713,7 +713,7 @@ const AppContent: React.FC = () => {
   ) => {
     if (!selectedProject) return;
 
-    setIsCreatingWorkspace(true);
+    setIsCreatingTask(true);
     try {
       let preparedPrompt: string | undefined = undefined;
       if (initialPrompt && initialPrompt.trim()) {
@@ -825,7 +825,7 @@ const AppContent: React.FC = () => {
       const isMultiAgent = totalRuns > 1;
       const primaryProvider = providerRuns[0]?.provider || 'claude';
 
-      let newWorkspace: Task;
+      let newTask: Task;
       if (isMultiAgent) {
         // Multi-agent workspace: create worktrees for each provider×runs combo
         const variants: Array<{
@@ -877,7 +877,7 @@ const AppContent: React.FC = () => {
         };
 
         const groupId = `ws-${taskName}-${Date.now()}`;
-        newWorkspace = {
+        newTask = {
           id: groupId,
           projectId: selectedProject.id,
           name: taskName,
@@ -889,7 +889,7 @@ const AppContent: React.FC = () => {
         };
 
         const saveResult = await window.electronAPI.saveWorkspace({
-          ...newWorkspace,
+          ...newTask,
           agentId: primaryProvider,
           metadata: multiMeta,
         });
@@ -897,7 +897,7 @@ const AppContent: React.FC = () => {
           const { log } = await import('./lib/logger');
           log.error('Failed to save multi-agent workspace:', saveResult?.error);
           toast({ title: 'Error', description: 'Failed to create multi-agent workspace.' });
-          setIsCreatingWorkspace(false);
+          setIsCreatingTask(false);
           return;
         }
       } else {
@@ -915,7 +915,7 @@ const AppContent: React.FC = () => {
 
         const worktree = worktreeResult.worktree;
 
-        newWorkspace = {
+        newTask = {
           id: worktree.id,
           projectId: selectedProject.id,
           name: taskName,
@@ -927,7 +927,7 @@ const AppContent: React.FC = () => {
         };
 
         const saveResult = await window.electronAPI.saveWorkspace({
-          ...newWorkspace,
+          ...newTask,
           agentId: primaryProvider,
           metadata: taskMetadata,
         });
@@ -935,7 +935,7 @@ const AppContent: React.FC = () => {
           const { log } = await import('./lib/logger');
           log.error('Failed to save workspace:', saveResult?.error);
           toast({ title: 'Error', description: 'Failed to create workspace.' });
-          setIsCreatingWorkspace(false);
+          setIsCreatingTask(false);
           return;
         }
       }
@@ -944,7 +944,7 @@ const AppContent: React.FC = () => {
         if (taskMetadata?.linearIssue) {
           try {
             const convoResult = await window.electronAPI.getOrCreateDefaultConversation(
-              newWorkspace.id
+              newTask.id
             );
 
             if (convoResult?.success && convoResult.conversation?.id) {
@@ -978,7 +978,7 @@ const AppContent: React.FC = () => {
               }
 
               await window.electronAPI.saveMessage({
-                id: `linear-context-${newWorkspace.id}`,
+                id: `linear-context-${newTask.id}`,
                 conversationId: convoResult.conversation.id,
                 content: lines.join('\n'),
                 sender: 'agent',
@@ -996,7 +996,7 @@ const AppContent: React.FC = () => {
         if (taskMetadata?.githubIssue) {
           try {
             const convoResult = await window.electronAPI.getOrCreateDefaultConversation(
-              newWorkspace.id
+              newTask.id
             );
 
             if (convoResult?.success && convoResult.conversation?.id) {
@@ -1036,7 +1036,7 @@ const AppContent: React.FC = () => {
               }
 
               await window.electronAPI.saveMessage({
-                id: `github-context-${newWorkspace.id}`,
+                id: `github-context-${newTask.id}`,
                 conversationId: convoResult.conversation.id,
                 content: lines.join('\n'),
                 sender: 'agent',
@@ -1054,7 +1054,7 @@ const AppContent: React.FC = () => {
         if (taskMetadata?.jiraIssue) {
           try {
             const convoResult = await window.electronAPI.getOrCreateDefaultConversation(
-              newWorkspace.id
+              newTask.id
             );
 
             if (convoResult?.success && convoResult.conversation?.id) {
@@ -1073,7 +1073,7 @@ const AppContent: React.FC = () => {
               if (issue.url) lines.push(`URL: ${issue.url}`);
 
               await window.electronAPI.saveMessage({
-                id: `jira-context-${newWorkspace.id}`,
+                id: `jira-context-${newTask.id}`,
                 conversationId: convoResult.conversation.id,
                 content: lines.join('\n'),
                 sender: 'agent',
@@ -1094,7 +1094,7 @@ const AppContent: React.FC = () => {
             project.id === selectedProject.id
               ? {
                   ...project,
-                  workspaces: [newWorkspace, ...(project.workspaces || [])],
+                  workspaces: [newTask, ...(project.workspaces || [])],
                 }
               : project
           )
@@ -1104,27 +1104,27 @@ const AppContent: React.FC = () => {
           prev
             ? {
                 ...prev,
-                workspaces: [newWorkspace, ...(prev.workspaces || [])],
+                workspaces: [newTask, ...(prev.workspaces || [])],
               }
             : null
         );
 
         // Track workspace creation
         const { captureTelemetry } = await import('./lib/telemetryClient');
-        const isMultiAgent = (newWorkspace.metadata as any)?.multiAgent?.enabled;
+        const isMultiAgent = (newTask.metadata as any)?.multiAgent?.enabled;
         captureTelemetry('workspace_created', {
-          provider: isMultiAgent ? 'multi' : (newWorkspace.agentId as string) || 'codex',
+          provider: isMultiAgent ? 'multi' : (newTask.agentId as string) || 'codex',
           has_initial_prompt: !!taskMetadata?.initialPrompt,
         });
 
         // Set the active workspace and its provider (none if multi-agent)
-        setActiveWorkspace(newWorkspace);
-        if ((newWorkspace.metadata as any)?.multiAgent?.enabled) {
-          setActiveWorkspaceProvider(null);
+        setActiveTask(newTask);
+        if ((newTask.metadata as any)?.multiAgent?.enabled) {
+          setActiveTaskProvider(null);
         } else {
           // Use the saved agentId from the workspace, which should match primaryProvider
-          setActiveWorkspaceProvider(
-            (newWorkspace.agentId as Provider) || primaryProvider || 'codex'
+          setActiveTaskProvider(
+            (newTask.agentId as Provider) || primaryProvider || 'codex'
           );
         }
       }
@@ -1138,14 +1138,14 @@ const AppContent: React.FC = () => {
           'Failed to create workspace. Please check the console for details.',
       });
     } finally {
-      setIsCreatingWorkspace(false);
+      setIsCreatingTask(false);
     }
   };
 
   const handleGoHome = () => {
     setSelectedProject(null);
     setShowHomeView(true);
-    setActiveWorkspace(null);
+    setActiveTask(null);
   };
 
   const handleSelectProject = (project: Project) => {
@@ -1153,14 +1153,14 @@ const AppContent: React.FC = () => {
   };
 
   const handleSelectTask = (workspace: Task) => {
-    setActiveWorkspace(workspace);
+    setActiveTask(workspace);
     // Load provider from workspace.agentId if it exists, otherwise default to null
     // This ensures the selected provider persists across app restarts
     if ((workspace.metadata as any)?.multiAgent?.enabled) {
-      setActiveWorkspaceProvider(null);
+      setActiveTaskProvider(null);
     } else {
       // Use agentId from workspace if available, otherwise fall back to 'codex' for backwards compatibility
-      setActiveWorkspaceProvider((workspace.agentId as Provider) || 'codex');
+      setActiveTaskProvider((workspace.agentId as Provider) || 'codex');
     }
   };
 
@@ -1173,27 +1173,27 @@ const AppContent: React.FC = () => {
     [activateProjectView, projects]
   );
 
-  const removeWorkspaceFromState = (projectId: string, taskId: string, wasActive: boolean) => {
-    const filterWorkspaces = (list?: Task[]) =>
+  const removeTaskFromState = (projectId: string, taskId: string, wasActive: boolean) => {
+    const filterTasks = (list?: Task[]) =>
       (list || []).filter((w) => w.id !== taskId);
 
     setProjects((prev) =>
       prev.map((project) =>
         project.id === projectId
-          ? { ...project, workspaces: filterWorkspaces(project.workspaces) }
+          ? { ...project, workspaces: filterTasks(project.workspaces) }
           : project
       )
     );
 
     setSelectedProject((prev) =>
       prev && prev.id === projectId
-        ? { ...prev, workspaces: filterWorkspaces(prev.workspaces) }
+        ? { ...prev, workspaces: filterTasks(prev.workspaces) }
         : prev
     );
 
     if (wasActive) {
-      setActiveWorkspace(null);
-      setActiveWorkspaceProvider(null);
+      setActiveTask(null);
+      setActiveTaskProvider(null);
     }
   };
 
@@ -1211,9 +1211,9 @@ const AppContent: React.FC = () => {
     }
 
     const wasActive = activeTask?.id === workspace.id;
-    const workspaceSnapshot = { ...workspace };
+    const taskSnapshot = { ...workspace };
     deletingTaskIdsRef.current.add(workspace.id);
-    removeWorkspaceFromState(targetProject.id, workspace.id, wasActive);
+    removeTaskFromState(targetProject.id, workspace.id, wasActive);
 
     const runDeletion = async (): Promise<boolean> => {
       try {
@@ -1336,23 +1336,23 @@ const AppContent: React.FC = () => {
             prev.map((project) => {
               if (project.id !== targetProject.id) return project;
               const existing = project.workspaces || [];
-              const alreadyPresent = existing.some((w) => w.id === workspaceSnapshot.id);
+              const alreadyPresent = existing.some((w) => w.id === taskSnapshot.id);
               return alreadyPresent
                 ? project
-                : { ...project, workspaces: [workspaceSnapshot, ...existing] };
+                : { ...project, workspaces: [taskSnapshot, ...existing] };
             })
           );
           setSelectedProject((prev) => {
             if (!prev || prev.id !== targetProject.id) return prev;
             const existing = prev.workspaces || [];
-            const alreadyPresent = existing.some((w) => w.id === workspaceSnapshot.id);
+            const alreadyPresent = existing.some((w) => w.id === taskSnapshot.id);
             return alreadyPresent
               ? prev
-              : { ...prev, workspaces: [workspaceSnapshot, ...existing] };
+              : { ...prev, workspaces: [taskSnapshot, ...existing] };
           });
 
           if (wasActive) {
-            handleSelectTask(workspaceSnapshot);
+            handleSelectTask(taskSnapshot);
           }
         }
         return false;
@@ -1398,7 +1398,7 @@ const AppContent: React.FC = () => {
       setProjects((prev) => prev.filter((p) => p.id !== project.id));
       if (selectedProject?.id === project.id) {
         setSelectedProject(null);
-        setActiveWorkspace(null);
+        setActiveTask(null);
         setShowHomeView(true);
       }
       toast({ title: 'Project deleted', description: `"${project.name}" was removed.` });
diff --git a/src/renderer/lib/taskTerminalsStore.ts b/src/renderer/lib/taskTerminalsStore.ts
index ef341da4..a05decda 100644
--- a/src/renderer/lib/taskTerminalsStore.ts
+++ b/src/renderer/lib/taskTerminalsStore.ts
@@ -23,7 +23,7 @@ const STORAGE_PREFIX = 'emdash:workspaceTerminals:v1';
 
 const workspaceStates = new Map<string, TaskTerminalsState>();
 const workspaceListeners = new Map<string, Set<() => void>>();
-const workspaceSnapshots = new Map<string, WorkspaceSnapshot>();
+const taskSnapshots = new Map<string, WorkspaceSnapshot>();
 
 const EMPTY_SNAPSHOT: WorkspaceSnapshot = {
   terminals: [],
@@ -144,18 +144,18 @@ function createDefaultState(taskId: string, taskPath?: string): TaskTerminalsSta
 }
 
 function ensureSnapshot(taskId: string, state: TaskTerminalsState) {
-  const current = workspaceSnapshots.get(taskId);
+  const current = taskSnapshots.get(taskId);
   if (
     !current ||
     current.terminals !== state.terminals ||
     current.activeTerminalId !== state.activeId
   ) {
-    workspaceSnapshots.set(taskId, {
+    taskSnapshots.set(taskId, {
       terminals: state.terminals,
       activeTerminalId: state.activeId,
     });
   }
-  return workspaceSnapshots.get(taskId)!;
+  return taskSnapshots.get(taskId)!;
 }
 
 function ensureWorkspaceState(

From abbcb741b83b7a9de73670c23d38cd3633572774 Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Fri, 12 Dec 2025 17:40:07 -0800
Subject: [PATCH 08/35] refactor: rename workspace IPC methods to task

---
 src/main/ipc/dbIpc.ts                      | 12 ++++++------
 src/main/main.ts                           |  2 +-
 src/main/preload.ts                        | 12 ++++++------
 src/main/services/DatabaseService.ts       |  6 +++---
 src/renderer/App.tsx                       | 10 +++++-----
 src/renderer/components/ChatInterface.tsx  |  2 +-
 src/renderer/components/MultiAgentTask.tsx |  2 +-
 src/renderer/types/electron-api.d.ts       | 12 ++++++------
 src/renderer/types/global.d.ts             |  6 +++---
 9 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/src/main/ipc/dbIpc.ts b/src/main/ipc/dbIpc.ts
index 9f964496..a3920ce9 100644
--- a/src/main/ipc/dbIpc.ts
+++ b/src/main/ipc/dbIpc.ts
@@ -23,18 +23,18 @@ export function registerDatabaseIpc() {
     }
   });
 
-  ipcMain.handle('db:getWorkspaces', async (_, projectId?: string) => {
+  ipcMain.handle('db:getTasks', async (_, projectId?: string) => {
     try {
-      return await databaseService.getWorkspaces(projectId);
+      return await databaseService.getTasks(projectId);
     } catch (error) {
       log.error('Failed to get workspaces:', error);
       return [];
     }
   });
 
-  ipcMain.handle('db:saveWorkspace', async (_, workspace: any) => {
+  ipcMain.handle('db:saveTask', async (_, workspace: any) => {
     try {
-      await databaseService.saveWorkspace(workspace);
+      await databaseService.saveTask(workspace);
       return { success: true };
     } catch (error) {
       log.error('Failed to save workspace:', error);
@@ -112,7 +112,7 @@ export function registerDatabaseIpc() {
     }
   });
 
-  ipcMain.handle('db:deleteWorkspace', async (_, taskId: string) => {
+  ipcMain.handle('db:deleteTask', async (_, taskId: string) => {
     try {
       // Stop any running Docker container for this workspace before deletion
       const stopResult = await containerRunnerService.stopRun(taskId);
@@ -121,7 +121,7 @@ export function registerDatabaseIpc() {
         log.warn('Failed to stop container during workspace deletion:', stopResult.error);
       }
 
-      await databaseService.deleteWorkspace(taskId);
+      await databaseService.deleteTask(taskId);
       return { success: true };
     } catch (error) {
       log.error('Failed to delete workspace:', error);
diff --git a/src/main/main.ts b/src/main/main.ts
index c10c31e8..1978d141 100644
--- a/src/main/main.ts
+++ b/src/main/main.ts
@@ -150,7 +150,7 @@ app.whenReady().then(async () => {
   try {
     const [projects, workspaces] = await Promise.all([
       databaseService.getProjects(),
-      databaseService.getWorkspaces(),
+      databaseService.getTasks(),
     ]);
     const projectCount = projects.length;
     const workspaceCount = workspaces.length;
diff --git a/src/main/preload.ts b/src/main/preload.ts
index 76a3ddac..ef54ed52 100644
--- a/src/main/preload.ts
+++ b/src/main/preload.ts
@@ -274,10 +274,10 @@ contextBridge.exposeInMainWorld('electronAPI', {
   // Database methods
   getProjects: () => ipcRenderer.invoke('db:getProjects'),
   saveProject: (project: any) => ipcRenderer.invoke('db:saveProject', project),
-  getWorkspaces: (projectId?: string) => ipcRenderer.invoke('db:getWorkspaces', projectId),
-  saveWorkspace: (workspace: any) => ipcRenderer.invoke('db:saveWorkspace', workspace),
+  getTasks: (projectId?: string) => ipcRenderer.invoke('db:getTasks', projectId),
+  saveTask: (workspace: any) => ipcRenderer.invoke('db:saveTask', workspace),
   deleteProject: (projectId: string) => ipcRenderer.invoke('db:deleteProject', projectId),
-  deleteWorkspace: (taskId: string) => ipcRenderer.invoke('db:deleteWorkspace', taskId),
+  deleteTask: (taskId: string) => ipcRenderer.invoke('db:deleteTask', taskId),
 
   // Conversation management
   saveConversation: (conversation: any) => ipcRenderer.invoke('db:saveConversation', conversation),
@@ -624,10 +624,10 @@ export interface ElectronAPI {
   // Database methods
   getProjects: () => Promise<any[]>;
   saveProject: (project: any) => Promise<{ success: boolean; error?: string }>;
-  getWorkspaces: (projectId?: string) => Promise<any[]>;
-  saveWorkspace: (workspace: any) => Promise<{ success: boolean; error?: string }>;
+  getTasks: (projectId?: string) => Promise<any[]>;
+  saveTask: (workspace: any) => Promise<{ success: boolean; error?: string }>;
   deleteProject: (projectId: string) => Promise<{ success: boolean; error?: string }>;
-  deleteWorkspace: (taskId: string) => Promise<{ success: boolean; error?: string }>;
+  deleteTask: (taskId: string) => Promise<{ success: boolean; error?: string }>;
 
   // Conversation management
   saveConversation: (conversation: any) => Promise<{ success: boolean; error?: string }>;
diff --git a/src/main/services/DatabaseService.ts b/src/main/services/DatabaseService.ts
index b5ccf285..4c548525 100644
--- a/src/main/services/DatabaseService.ts
+++ b/src/main/services/DatabaseService.ts
@@ -207,7 +207,7 @@ export class DatabaseService {
     return this.getProjectById(projectId);
   }
 
-  async saveWorkspace(workspace: Omit<Workspace, 'createdAt' | 'updatedAt'>): Promise<void> {
+  async saveTask(workspace: Omit<Workspace, 'createdAt' | 'updatedAt'>): Promise<void> {
     if (this.disabled) return;
     const metadataValue =
       typeof workspace.metadata === 'string'
@@ -244,7 +244,7 @@ export class DatabaseService {
       });
   }
 
-  async getWorkspaces(projectId?: string): Promise<Workspace[]> {
+  async getTasks(projectId?: string): Promise<Workspace[]> {
     if (this.disabled) return [];
     const { db } = await getDrizzleClient();
 
@@ -264,7 +264,7 @@ export class DatabaseService {
     await db.delete(projectsTable).where(eq(projectsTable.id, projectId));
   }
 
-  async deleteWorkspace(taskId: string): Promise<void> {
+  async deleteTask(taskId: string): Promise<void> {
     if (this.disabled) return;
     const { db } = await getDrizzleClient();
     await db.delete(workspacesTable).where(eq(workspacesTable.id, taskId));
diff --git a/src/renderer/App.tsx b/src/renderer/App.tsx
index 80c64658..5dbb0ae0 100644
--- a/src/renderer/App.tsx
+++ b/src/renderer/App.tsx
@@ -459,7 +459,7 @@ const AppContent: React.FC = () => {
 
         const projectsWithTasks = await Promise.all(
           initialProjects.map(async (project) => {
-            const workspaces = await window.electronAPI.getWorkspaces(project.id);
+            const workspaces = await window.electronAPI.getTasks(project.id);
             return withRepoKey({ ...project, workspaces });
           })
         );
@@ -888,7 +888,7 @@ const AppContent: React.FC = () => {
           metadata: multiMeta,
         };
 
-        const saveResult = await window.electronAPI.saveWorkspace({
+        const saveResult = await window.electronAPI.saveTask({
           ...newTask,
           agentId: primaryProvider,
           metadata: multiMeta,
@@ -926,7 +926,7 @@ const AppContent: React.FC = () => {
           metadata: taskMetadata,
         };
 
-        const saveResult = await window.electronAPI.saveWorkspace({
+        const saveResult = await window.electronAPI.saveTask({
           ...newTask,
           agentId: primaryProvider,
           metadata: taskMetadata,
@@ -1266,7 +1266,7 @@ const AppContent: React.FC = () => {
             worktreePath: workspace.path,
             branch: workspace.branch,
           }),
-          window.electronAPI.deleteWorkspace(workspace.id),
+          window.electronAPI.deleteTask(workspace.id),
         ]);
 
         if (removeResult.status !== 'fulfilled' || !removeResult.value?.success) {
@@ -1309,7 +1309,7 @@ const AppContent: React.FC = () => {
         });
 
         try {
-          const refreshedWorkspaces = await window.electronAPI.getWorkspaces(targetProject.id);
+          const refreshedWorkspaces = await window.electronAPI.getTasks(targetProject.id);
           setProjects((prev) =>
             prev.map((project) =>
               project.id === targetProject.id
diff --git a/src/renderer/components/ChatInterface.tsx b/src/renderer/components/ChatInterface.tsx
index 64beb440..dbe87dd1 100644
--- a/src/renderer/components/ChatInterface.tsx
+++ b/src/renderer/components/ChatInterface.tsx
@@ -723,7 +723,7 @@ const ChatInterface: React.FC<Props> = ({
                 setCliStartFailed(false);
                 // Mark initial injection as sent so it won't re-run on restart
                 if (initialInjection && !task.metadata?.initialInjectionSent) {
-                  void window.electronAPI.saveWorkspace({
+                  void window.electronAPI.saveTask({
                     ...task,
                     metadata: {
                       ...task.metadata,
diff --git a/src/renderer/components/MultiAgentTask.tsx b/src/renderer/components/MultiAgentTask.tsx
index bb000240..8ab6c003 100644
--- a/src/renderer/components/MultiAgentTask.tsx
+++ b/src/renderer/components/MultiAgentTask.tsx
@@ -469,7 +469,7 @@ const MultiAgentTask: React.FC<Props> = ({ task }) => {
                       }
                       // Mark initial injection as sent so it won't re-run on restart
                       if (initialInjection && !task.metadata?.initialInjectionSent) {
-                        void window.electronAPI.saveWorkspace({
+                        void window.electronAPI.saveTask({
                           ...task,
                           metadata: {
                             ...task.metadata,
diff --git a/src/renderer/types/electron-api.d.ts b/src/renderer/types/electron-api.d.ts
index 6cd60bcd..dcb5e27c 100644
--- a/src/renderer/types/electron-api.d.ts
+++ b/src/renderer/types/electron-api.d.ts
@@ -572,10 +572,10 @@ declare global {
       // Database operations
       getProjects: () => Promise<any[]>;
       saveProject: (project: any) => Promise<{ success: boolean; error?: string }>;
-      getWorkspaces: (projectId?: string) => Promise<any[]>;
-      saveWorkspace: (workspace: any) => Promise<{ success: boolean; error?: string }>;
+      getTasks: (projectId?: string) => Promise<any[]>;
+      saveTask: (workspace: any) => Promise<{ success: boolean; error?: string }>;
       deleteProject: (projectId: string) => Promise<{ success: boolean; error?: string }>;
-      deleteWorkspace: (taskId: string) => Promise<{ success: boolean; error?: string }>;
+      deleteTask: (taskId: string) => Promise<{ success: boolean; error?: string }>;
 
       // Message operations
       saveMessage: (message: any) => Promise<{ success: boolean; error?: string }>;
@@ -899,10 +899,10 @@ export interface ElectronAPI {
   // Database operations
   getProjects: () => Promise<any[]>;
   saveProject: (project: any) => Promise<{ success: boolean; error?: string }>;
-  getWorkspaces: (projectId?: string) => Promise<any[]>;
-  saveWorkspace: (workspace: any) => Promise<{ success: boolean; error?: string }>;
+  getTasks: (projectId?: string) => Promise<any[]>;
+  saveTask: (workspace: any) => Promise<{ success: boolean; error?: string }>;
   deleteProject: (projectId: string) => Promise<{ success: boolean; error?: string }>;
-  deleteWorkspace: (taskId: string) => Promise<{ success: boolean; error?: string }>;
+  deleteTask: (taskId: string) => Promise<{ success: boolean; error?: string }>;
 
   // Message operations
   saveMessage: (message: any) => Promise<{ success: boolean; error?: string }>;
diff --git a/src/renderer/types/global.d.ts b/src/renderer/types/global.d.ts
index 709c7411..542fc29c 100644
--- a/src/renderer/types/global.d.ts
+++ b/src/renderer/types/global.d.ts
@@ -205,10 +205,10 @@ declare global {
       // Database methods
       getProjects: () => Promise<any[]>;
       saveProject: (project: any) => Promise<{ success: boolean; error?: string }>;
-      getWorkspaces: (projectId?: string) => Promise<any[]>;
-      saveWorkspace: (workspace: any) => Promise<{ success: boolean; error?: string }>;
+      getTasks: (projectId?: string) => Promise<any[]>;
+      saveTask: (workspace: any) => Promise<{ success: boolean; error?: string }>;
       deleteProject: (projectId: string) => Promise<{ success: boolean; error?: string }>;
-      deleteWorkspace: (taskId: string) => Promise<{ success: boolean; error?: string }>;
+      deleteTask: (taskId: string) => Promise<{ success: boolean; error?: string }>;
     };
   }
 }

From d2b66b46bad6ddf7a1b7992027d44834a43f138c Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Fri, 12 Dec 2025 17:44:35 -0800
Subject: [PATCH 09/35] refactor: rename project.workspaces to project.tasks

---
 src/renderer/App.tsx                          | 32 +++++++++----------
 src/renderer/components/ActiveRuns.tsx        |  2 +-
 src/renderer/components/CommandPalette.tsx    |  6 ++--
 .../components/CommandPaletteWrapper.tsx      |  2 +-
 src/renderer/components/DeletePrNotice.tsx    |  8 ++---
 src/renderer/components/LeftSidebar.tsx       |  2 +-
 src/renderer/components/ProjectMainView.tsx   | 30 ++++++++---------
 src/renderer/components/TaskDeleteButton.tsx  |  2 +-
 .../components/kanban/KanbanBoard.tsx         | 20 ++++++------
 src/renderer/hooks/useDeleteRisks.ts          | 14 ++++----
 src/renderer/types/app.ts                     |  5 ++-
 11 files changed, 61 insertions(+), 62 deletions(-)

diff --git a/src/renderer/App.tsx b/src/renderer/App.tsx
index 5dbb0ae0..994c44e2 100644
--- a/src/renderer/App.tsx
+++ b/src/renderer/App.tsx
@@ -459,8 +459,8 @@ const AppContent: React.FC = () => {
 
         const projectsWithTasks = await Promise.all(
           initialProjects.map(async (project) => {
-            const workspaces = await window.electronAPI.getTasks(project.id);
-            return withRepoKey({ ...project, workspaces });
+            const tasks = await window.electronAPI.getTasks(project.id);
+            return withRepoKey({ ...project, tasks });
           })
         );
         const ordered = applyProjectOrder(projectsWithTasks);
@@ -547,7 +547,7 @@ const AppContent: React.FC = () => {
               branch: gitInfo.branch || undefined,
               baseRef: computeBaseRef(gitInfo.baseRef, gitInfo.remote, gitInfo.branch),
             },
-            workspaces: [],
+            tasks: [],
           };
 
           if (isAuthenticated && isGithubRemote) {
@@ -1094,7 +1094,7 @@ const AppContent: React.FC = () => {
             project.id === selectedProject.id
               ? {
                   ...project,
-                  workspaces: [newTask, ...(project.workspaces || [])],
+                  tasks: [newTask, ...(project.tasks || [])],
                 }
               : project
           )
@@ -1104,7 +1104,7 @@ const AppContent: React.FC = () => {
           prev
             ? {
                 ...prev,
-                workspaces: [newTask, ...(prev.workspaces || [])],
+                tasks: [newTask, ...(prev.tasks || [])],
               }
             : null
         );
@@ -1180,14 +1180,14 @@ const AppContent: React.FC = () => {
     setProjects((prev) =>
       prev.map((project) =>
         project.id === projectId
-          ? { ...project, workspaces: filterTasks(project.workspaces) }
+          ? { ...project, tasks: filterTasks(project.tasks) }
           : project
       )
     );
 
     setSelectedProject((prev) =>
       prev && prev.id === projectId
-        ? { ...prev, workspaces: filterTasks(prev.workspaces) }
+        ? { ...prev, tasks: filterTasks(prev.tasks) }
         : prev
     );
 
@@ -1309,22 +1309,22 @@ const AppContent: React.FC = () => {
         });
 
         try {
-          const refreshedWorkspaces = await window.electronAPI.getTasks(targetProject.id);
+          const refreshedTasks = await window.electronAPI.getTasks(targetProject.id);
           setProjects((prev) =>
             prev.map((project) =>
               project.id === targetProject.id
-                ? { ...project, workspaces: refreshedWorkspaces }
+                ? { ...project, tasks: refreshedTasks }
                 : project
             )
           );
           setSelectedProject((prev) =>
             prev && prev.id === targetProject.id
-              ? { ...prev, workspaces: refreshedWorkspaces }
+              ? { ...prev, tasks: refreshedTasks }
               : prev
           );
 
           if (wasActive) {
-            const restored = refreshedWorkspaces.find((w) => w.id === workspace.id);
+            const restored = refreshedTasks.find((w) => w.id === workspace.id);
             if (restored) {
               handleSelectTask(restored);
             }
@@ -1335,20 +1335,20 @@ const AppContent: React.FC = () => {
           setProjects((prev) =>
             prev.map((project) => {
               if (project.id !== targetProject.id) return project;
-              const existing = project.workspaces || [];
+              const existing = project.tasks || [];
               const alreadyPresent = existing.some((w) => w.id === taskSnapshot.id);
               return alreadyPresent
                 ? project
-                : { ...project, workspaces: [taskSnapshot, ...existing] };
+                : { ...project, tasks: [taskSnapshot, ...existing] };
             })
           );
           setSelectedProject((prev) => {
             if (!prev || prev.id !== targetProject.id) return prev;
-            const existing = prev.workspaces || [];
+            const existing = prev.tasks || [];
             const alreadyPresent = existing.some((w) => w.id === taskSnapshot.id);
             return alreadyPresent
               ? prev
-              : { ...prev, workspaces: [taskSnapshot, ...existing] };
+              : { ...prev, tasks: [taskSnapshot, ...existing] };
           });
 
           if (wasActive) {
@@ -1759,7 +1759,7 @@ const AppContent: React.FC = () => {
               onCreateTask={handleCreateTask}
               projectName={selectedProject?.name || ''}
               defaultBranch={selectedProject?.gitInfo.branch || 'main'}
-              existingNames={(selectedProject?.workspaces || []).map((w) => w.name)}
+              existingNames={(selectedProject?.tasks || []).map((w) => w.name)}
               projectPath={selectedProject?.path}
             />
             <FirstLaunchModal open={showFirstLaunchModal} onClose={markFirstLaunchSeen} />
diff --git a/src/renderer/components/ActiveRuns.tsx b/src/renderer/components/ActiveRuns.tsx
index 1b40cab7..9d2a7754 100644
--- a/src/renderer/components/ActiveRuns.tsx
+++ b/src/renderer/components/ActiveRuns.tsx
@@ -40,7 +40,7 @@ const ActiveRuns: React.FC<Props> = ({ projects, onSelectProject, onSelectTask }
   for (const s of activeRuns) {
     let match: { project: any | null; workspace: any | null } | null = null;
     for (const proj of projects) {
-      const ws = (proj.workspaces || []).find((w: any) => w.id === s.taskId) || null;
+      const ws = (proj.tasks || []).find((w: any) => w.id === s.taskId) || null;
       if (ws) {
         match = { project: proj, workspace: ws };
         break;
diff --git a/src/renderer/components/CommandPalette.tsx b/src/renderer/components/CommandPalette.tsx
index 387a37d3..f04815c0 100644
--- a/src/renderer/components/CommandPalette.tsx
+++ b/src/renderer/components/CommandPalette.tsx
@@ -26,7 +26,7 @@ interface CommandPaletteProps {
     id: string;
     name: string;
     path: string;
-    workspaces?: Array<{
+    tasks?: Array<{
       id: string;
       name: string;
       branch: string;
@@ -209,8 +209,8 @@ const CommandPalette: React.FC<CommandPaletteProps> = ({
       }
 
       // Workspace commands
-      if (project.workspaces && onSelectTask) {
-        project.workspaces.forEach((workspace) => {
+      if (project.tasks && onSelectTask) {
+        project.tasks.forEach((workspace) => {
           items.push({
             id: `workspace-${project.id}-${workspace.id}`,
             label: workspace.name,
diff --git a/src/renderer/components/CommandPaletteWrapper.tsx b/src/renderer/components/CommandPaletteWrapper.tsx
index 84317f0b..01d5c96e 100644
--- a/src/renderer/components/CommandPaletteWrapper.tsx
+++ b/src/renderer/components/CommandPaletteWrapper.tsx
@@ -41,7 +41,7 @@ const CommandPaletteWrapper: React.FC<CommandPaletteWrapperProps> = ({
       }}
       onSelectTask={(projectId, taskId) => {
         const project = projects.find((p) => p.id === projectId);
-        const workspace = project?.workspaces?.find((w: Task) => w.id === taskId);
+        const workspace = project?.tasks?.find((w: Task) => w.id === taskId);
         if (project && workspace) {
           handleSelectProject(project);
           handleSelectTask(workspace);
diff --git a/src/renderer/components/DeletePrNotice.tsx b/src/renderer/components/DeletePrNotice.tsx
index 44818b1c..7418e4d4 100644
--- a/src/renderer/components/DeletePrNotice.tsx
+++ b/src/renderer/components/DeletePrNotice.tsx
@@ -11,11 +11,11 @@ type PrInfo = {
 };
 
 type Props = {
-  workspaces: Array<{ name: string; pr: PrInfo }>;
+  tasks: Array<{ name: string; pr: PrInfo }>;
 };
 
-export const DeletePrNotice: React.FC<Props> = ({ workspaces }) => {
-  if (!workspaces.length) return null;
+export const DeletePrNotice: React.FC<Props> = ({ tasks }) => {
+  if (!tasks.length) return null;
 
   const handleOpen = (url?: string) => {
     if (!url) return;
@@ -31,7 +31,7 @@ export const DeletePrNotice: React.FC<Props> = ({ workspaces }) => {
         <p className="font-medium">Open PR detected</p>
       </div>
       <div className="space-y-1">
-        {workspaces.map((ws) => {
+        {tasks.map((ws) => {
           const badge = ws.pr.isDraft ? 'Draft' : 'PR';
           const number = typeof ws.pr.number === 'number' ? ` #${ws.pr.number}` : '';
           const state = ws.pr.state ? ` (${String(ws.pr.state)})` : '';
diff --git a/src/renderer/components/LeftSidebar.tsx b/src/renderer/components/LeftSidebar.tsx
index b1aa6b1c..6d6d4ed9 100644
--- a/src/renderer/components/LeftSidebar.tsx
+++ b/src/renderer/components/LeftSidebar.tsx
@@ -277,7 +277,7 @@ const LeftSidebar: React.FC<LeftSidebarProps> = ({
                                 </button>
                               </div>
                               <div className="hidden min-w-0 space-y-1 sm:block">
-                                {typedProject.workspaces?.map((task) => {
+                                {typedProject.tasks?.map((task) => {
                                   const isActive = activeTask?.id === task.id;
                                   return (
                                     <div
diff --git a/src/renderer/components/ProjectMainView.tsx b/src/renderer/components/ProjectMainView.tsx
index f7b1cf89..b4d70ec5 100644
--- a/src/renderer/components/ProjectMainView.tsx
+++ b/src/renderer/components/ProjectMainView.tsx
@@ -425,11 +425,11 @@ const ProjectMainView: React.FC<ProjectMainViewProps> = ({
   const [isDeleting, setIsDeleting] = useState(false);
   const [acknowledgeDirtyDelete, setAcknowledgeDirtyDelete] = useState(false);
 
-  const workspaces = project.workspaces ?? [];
+  const tasksInProject = project.tasks ?? [];
   const selectedCount = selectedIds.size;
-  const selectedWorkspaces = useMemo(
-    () => workspaces.filter((ws) => selectedIds.has(ws.id)),
-    [selectedIds, workspaces]
+  const selectedTasks = useMemo(
+    () => tasksInProject.filter((ws) => selectedIds.has(ws.id)),
+    [selectedIds, tasksInProject]
   );
   const [deleteStatus, setDeleteStatus] = useState<
     Record<
@@ -455,7 +455,7 @@ const ProjectMainView: React.FC<ProjectMainViewProps> = ({
   const deleteRisks = useMemo(() => {
     const riskyIds = new Set<string>();
     const summaries: Record<string, string> = {};
-    for (const ws of selectedWorkspaces) {
+    for (const ws of selectedTasks) {
       const status = deleteStatus[ws.id];
       if (!status) continue;
       const dirty =
@@ -484,7 +484,7 @@ const ProjectMainView: React.FC<ProjectMainViewProps> = ({
       }
     }
     return { riskyIds, summaries };
-  }, [deleteStatus, selectedWorkspaces]);
+  }, [deleteStatus, selectedTasks]);
   const deleteDisabled: boolean =
     Boolean(isDeleting || deleteStatusLoading) ||
     (deleteRisks.riskyIds.size > 0 && acknowledgeDirtyDelete !== true);
@@ -507,7 +507,7 @@ const ProjectMainView: React.FC<ProjectMainViewProps> = ({
   };
 
   const handleBulkDelete = async () => {
-    const toDelete = workspaces.filter((ws) => selectedIds.has(ws.id));
+    const toDelete = tasksInProject.filter((ws) => selectedIds.has(ws.id));
     if (toDelete.length === 0) return;
 
     setIsDeleting(true);
@@ -562,7 +562,7 @@ const ProjectMainView: React.FC<ProjectMainViewProps> = ({
       setDeleteStatusLoading(true);
       const next: typeof deleteStatus = {};
 
-      for (const ws of selectedWorkspaces) {
+      for (const ws of selectedTasks) {
         try {
           const [statusRes, infoRes, prRes] = await Promise.allSettled([
             window.electronAPI.getGitStatus(ws.path),
@@ -634,7 +634,7 @@ const ProjectMainView: React.FC<ProjectMainViewProps> = ({
     return () => {
       cancelled = true;
     };
-  }, [showDeleteDialog, selectedWorkspaces]);
+  }, [showDeleteDialog, selectedTasks]);
 
   useEffect(() => {
     let cancelled = false;
@@ -813,7 +813,7 @@ const ProjectMainView: React.FC<ProjectMainViewProps> = ({
                     </Button>
                   )}
                 </div>
-                {workspaces.length > 0 && (
+                {tasksInProject.length > 0 && (
                   <div className="flex justify-end gap-2">
                     {isSelectMode && selectedCount > 0 && (
                       <Button
@@ -844,7 +844,7 @@ const ProjectMainView: React.FC<ProjectMainViewProps> = ({
                   </div>
                 )}
                 <div className="flex flex-col gap-3">
-                  {workspaces.map((ws) => (
+                  {tasksInProject.map((ws) => (
                     <WorkspaceRow
                       key={ws.id}
                       ws={ws}
@@ -859,7 +859,7 @@ const ProjectMainView: React.FC<ProjectMainViewProps> = ({
                 </div>
               </div>
 
-              {(!project.workspaces || project.workspaces.length === 0) && (
+              {(!project.tasks || project.tasks.length === 0) && (
                 <Alert>
                   <AlertTitle>What's a task?</AlertTitle>
                   <AlertDescription className="flex items-center justify-between gap-4">
@@ -896,7 +896,7 @@ const ProjectMainView: React.FC<ProjectMainViewProps> = ({
                 >
                   <p className="font-medium">Unmerged or unpushed work detected</p>
                   <ul className="space-y-1">
-                    {selectedWorkspaces.map((ws) => {
+                    {selectedTasks.map((ws) => {
                       const summary = deleteRisks.summaries[ws.id];
                       const status = deleteStatus[ws.id];
                       if (!summary && !status?.error) return null;
@@ -919,7 +919,7 @@ const ProjectMainView: React.FC<ProjectMainViewProps> = ({
 
             <AnimatePresence initial={false}>
               {(() => {
-                const prWorkspaces = selectedWorkspaces
+                const prWorkspaces = selectedTasks
                   .map((ws) => ({ name: ws.name, pr: deleteStatus[ws.id]?.pr }))
                   .filter((w) => w.pr);
                 return prWorkspaces.length ? (
@@ -930,7 +930,7 @@ const ProjectMainView: React.FC<ProjectMainViewProps> = ({
                     exit={{ opacity: 0, y: 6, scale: 0.99 }}
                     transition={{ duration: 0.2, ease: 'easeOut', delay: 0.02 }}
                   >
-                    <DeletePrNotice workspaces={prWorkspaces as any} />
+                    <DeletePrNotice tasks={prWorkspaces as any} />
                   </motion.div>
                 ) : null;
               })()}
diff --git a/src/renderer/components/TaskDeleteButton.tsx b/src/renderer/components/TaskDeleteButton.tsx
index 666a2552..5ecbe627 100644
--- a/src/renderer/components/TaskDeleteButton.tsx
+++ b/src/renderer/components/TaskDeleteButton.tsx
@@ -149,7 +149,7 @@ export const WorkspaceDeleteButton: React.FC<Props> = ({
                   </span>
                 </div>
                 {status.pr ? (
-                  <DeletePrNotice workspaces={[{ name: taskName, pr: status.pr }]} />
+                  <DeletePrNotice tasks={[{ name: taskName, pr: status.pr }]} />
                 ) : null}
               </motion.div>
             ) : null}
diff --git a/src/renderer/components/kanban/KanbanBoard.tsx b/src/renderer/components/kanban/KanbanBoard.tsx
index bf594caa..1fb35973 100644
--- a/src/renderer/components/kanban/KanbanBoard.tsx
+++ b/src/renderer/components/kanban/KanbanBoard.tsx
@@ -35,7 +35,7 @@ const KanbanBoard: React.FC<{
   React.useEffect(() => {
     const offs: Array<() => void> = [];
     const idleTimers = new Map<string, ReturnType<typeof setTimeout>>();
-    const wsList = project.workspaces || [];
+    const wsList = project.tasks || [];
     for (const ws of wsList) {
       // Watch PTY output to capture terminal-based providers as activity
       offs.push(watchWorkspacePty(ws.id));
@@ -104,12 +104,12 @@ const KanbanBoard: React.FC<{
     }
     return () => offs.forEach((f) => f());
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [project.id, project.workspaces?.length]);
+  }, [project.id, project.tasks?.length]);
 
   // Promote any workspace with local changes directly to "Ready for review" (done)
   React.useEffect(() => {
     let cancelled = false;
-    const wsList = project.workspaces || [];
+    const wsList = project.tasks || [];
     const check = async () => {
       for (const ws of wsList) {
         const variantPaths: string[] = (() => {
@@ -155,12 +155,12 @@ const KanbanBoard: React.FC<{
       cancelled = true;
       window.clearInterval(id);
     };
-  }, [project.id, project.workspaces?.length]);
+  }, [project.id, project.tasks?.length]);
 
   // Promote any workspace with an open PR to "Ready for review" (done)
   React.useEffect(() => {
     let cancelled = false;
-    const wsList = project.workspaces || [];
+    const wsList = project.tasks || [];
     const check = async () => {
       for (const ws of wsList) {
         const variantPaths: string[] = (() => {
@@ -206,11 +206,11 @@ const KanbanBoard: React.FC<{
       cancelled = true;
       window.clearInterval(id);
     };
-  }, [project.id, project.workspaces?.length]);
+  }, [project.id, project.tasks?.length]);
 
   React.useEffect(() => {
     let cancelled = false;
-    const wsList = project.workspaces || [];
+    const wsList = project.tasks || [];
     const check = async () => {
       for (const ws of wsList) {
         const variantPaths: string[] = (() => {
@@ -258,14 +258,14 @@ const KanbanBoard: React.FC<{
       cancelled = true;
       window.clearInterval(id);
     };
-  }, [project.id, project.workspaces?.length]);
+  }, [project.id, project.tasks?.length]);
 
   const byStatus: Record<KanbanStatus, Task[]> = { todo: [], 'in-progress': [], done: [] };
-  for (const ws of project.workspaces || []) {
+  for (const ws of project.tasks || []) {
     const s = statusMap[ws.id] || 'todo';
     byStatus[s].push(ws);
   }
-  const hasAny = (project.workspaces?.length ?? 0) > 0;
+  const hasAny = (project.tasks?.length ?? 0) > 0;
 
   const handleDrop = (target: KanbanStatus, taskId: string) => {
     setStatus(taskId, target);
diff --git a/src/renderer/hooks/useDeleteRisks.ts b/src/renderer/hooks/useDeleteRisks.ts
index b4d6502a..c57a2549 100644
--- a/src/renderer/hooks/useDeleteRisks.ts
+++ b/src/renderer/hooks/useDeleteRisks.ts
@@ -1,6 +1,6 @@
 import { useEffect, useMemo, useState } from 'react';
 
-type WorkspaceRef = { id: string; name: string; path: string };
+type TaskRef = { id: string; name: string; path: string };
 
 type RiskState = Record<
   string,
@@ -21,13 +21,13 @@ type RiskState = Record<
   }
 >;
 
-export function useDeleteRisks(workspaces: WorkspaceRef[], enabled: boolean) {
+export function useDeleteRisks(tasks: TaskRef[], enabled: boolean) {
   const [risks, setRisks] = useState<RiskState>({});
   const [loading, setLoading] = useState(false);
   const [loaded, setLoaded] = useState(false);
 
   useEffect(() => {
-    if (!enabled || workspaces.length === 0) {
+    if (!enabled || tasks.length === 0) {
       setRisks({});
       setLoading(false);
       setLoaded(false);
@@ -37,7 +37,7 @@ export function useDeleteRisks(workspaces: WorkspaceRef[], enabled: boolean) {
     const load = async () => {
       setLoading(true);
       const next: RiskState = {};
-      for (const ws of workspaces) {
+      for (const ws of tasks) {
         try {
           const [statusRes, infoRes, prRes] = await Promise.allSettled([
             (window as any).electronAPI?.getGitStatus?.(ws.path),
@@ -109,13 +109,13 @@ export function useDeleteRisks(workspaces: WorkspaceRef[], enabled: boolean) {
     return () => {
       cancelled = true;
     };
-  }, [enabled, workspaces]);
+  }, [enabled, tasks]);
 
   const hasData = loaded && Object.keys(risks).length > 0;
   const summary = useMemo(() => {
     const riskyIds = new Set<string>();
     const summaries: Record<string, string> = {};
-    for (const ws of workspaces) {
+    for (const ws of tasks) {
       const status = risks[ws.id];
       if (!status) continue;
       const dirty =
@@ -151,7 +151,7 @@ export function useDeleteRisks(workspaces: WorkspaceRef[], enabled: boolean) {
       }
     }
     return { riskyIds, summaries };
-  }, [risks, workspaces]);
+  }, [risks, tasks]);
 
   return { risks, loading, summary, hasData };
 }
diff --git a/src/renderer/types/app.ts b/src/renderer/types/app.ts
index 8c02d254..b7c22515 100644
--- a/src/renderer/types/app.ts
+++ b/src/renderer/types/app.ts
@@ -16,12 +16,11 @@ export interface Project {
     repository: string;
     connected: boolean;
   };
-  // Internal DB field name kept as 'workspaces' for compatibility
-  workspaces?: Task[];
+  tasks?: Task[];
 }
 
 // Lightweight shapes for palette/list UIs, if needed later
 export type ProjectSummary = Pick<Project, 'id' | 'name'> & {
-  workspaces?: Pick<Task, 'id' | 'name'>[];
+  tasks?: Pick<Task, 'id' | 'name'>[];
 };
 export type TaskSummary = Pick<Task, 'id' | 'name'>;

From 394b27a1415ee3b018f7b5a9c3ef374a512432f3 Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Fri, 12 Dec 2025 17:48:37 -0800
Subject: [PATCH 10/35] refactor: rename remaining workspace variables and
 messages to task

---
 src/renderer/App.tsx                          | 74 +++++++++----------
 src/renderer/components/ActiveRuns.tsx        | 10 +--
 .../components/AutoApproveIndicator.tsx       |  2 +-
 src/renderer/components/CommandPalette.tsx    | 14 ++--
 .../components/CommandPaletteWrapper.tsx      |  8 +-
 src/renderer/components/ProjectMainView.tsx   |  4 +-
 src/renderer/components/ProviderBar.tsx       |  6 +-
 src/renderer/components/TaskModal.tsx         |  2 +-
 src/renderer/hooks/useCreatePR.tsx            |  2 +-
 .../hooks/useInitialPromptInjection.ts        |  2 +-
 src/renderer/hooks/usePlanActivation.ts       |  2 +-
 src/renderer/lib/attachments.ts               |  4 +-
 src/renderer/lib/containerRuns.ts             |  8 +-
 src/renderer/types/electron-api.d.ts          |  4 +-
 src/renderer/types/global.d.ts                |  2 +-
 15 files changed, 72 insertions(+), 72 deletions(-)

diff --git a/src/renderer/App.tsx b/src/renderer/App.tsx
index 994c44e2..df2ca91e 100644
--- a/src/renderer/App.tsx
+++ b/src/renderer/App.tsx
@@ -895,8 +895,8 @@ const AppContent: React.FC = () => {
         });
         if (!saveResult?.success) {
           const { log } = await import('./lib/logger');
-          log.error('Failed to save multi-agent workspace:', saveResult?.error);
-          toast({ title: 'Error', description: 'Failed to create multi-agent workspace.' });
+          log.error('Failed to save multi-agent task:', saveResult?.error);
+          toast({ title: 'Error', description: 'Failed to create multi-agent task.' });
           setIsCreatingTask(false);
           return;
         }
@@ -933,8 +933,8 @@ const AppContent: React.FC = () => {
         });
         if (!saveResult?.success) {
           const { log } = await import('./lib/logger');
-          log.error('Failed to save workspace:', saveResult?.error);
-          toast({ title: 'Error', description: 'Failed to create workspace.' });
+          log.error('Failed to save task:', saveResult?.error);
+          toast({ title: 'Error', description: 'Failed to create task.' });
           setIsCreatingTask(false);
           return;
         }
@@ -990,7 +990,7 @@ const AppContent: React.FC = () => {
             }
           } catch (seedError) {
             const { log } = await import('./lib/logger');
-            log.error('Failed to seed workspace with Linear issue context:', seedError as any);
+            log.error('Failed to seed task with Linear issue context:', seedError as any);
           }
         }
         if (taskMetadata?.githubIssue) {
@@ -1048,7 +1048,7 @@ const AppContent: React.FC = () => {
             }
           } catch (seedError) {
             const { log } = await import('./lib/logger');
-            log.error('Failed to seed workspace with GitHub issue context:', seedError as any);
+            log.error('Failed to seed task with GitHub issue context:', seedError as any);
           }
         }
         if (taskMetadata?.jiraIssue) {
@@ -1085,7 +1085,7 @@ const AppContent: React.FC = () => {
             }
           } catch (seedError) {
             const { log } = await import('./lib/logger');
-            log.error('Failed to seed workspace with Jira issue context:', seedError as any);
+            log.error('Failed to seed task with Jira issue context:', seedError as any);
           }
         }
 
@@ -1130,12 +1130,12 @@ const AppContent: React.FC = () => {
       }
     } catch (error) {
       const { log } = await import('./lib/logger');
-      log.error('Failed to create workspace:', error as any);
+      log.error('Failed to create task:', error as any);
       toast({
         title: 'Error',
         description:
           (error as Error)?.message ||
-          'Failed to create workspace. Please check the console for details.',
+          'Failed to create task. Please check the console for details.',
       });
     } finally {
       setIsCreatingTask(false);
@@ -1152,15 +1152,15 @@ const AppContent: React.FC = () => {
     activateProjectView(project);
   };
 
-  const handleSelectTask = (workspace: Task) => {
-    setActiveTask(workspace);
-    // Load provider from workspace.agentId if it exists, otherwise default to null
+  const handleSelectTask = (task: Task) => {
+    setActiveTask(task);
+    // Load provider from task.agentId if it exists, otherwise default to null
     // This ensures the selected provider persists across app restarts
-    if ((workspace.metadata as any)?.multiAgent?.enabled) {
+    if ((task.metadata as any)?.multiAgent?.enabled) {
       setActiveTaskProvider(null);
     } else {
       // Use agentId from workspace if available, otherwise fall back to 'codex' for backwards compatibility
-      setActiveTaskProvider((workspace.agentId as Provider) || 'codex');
+      setActiveTaskProvider((task.agentId as Provider) || 'codex');
     }
   };
 
@@ -1199,21 +1199,21 @@ const AppContent: React.FC = () => {
 
   const handleDeleteTask = async (
     targetProject: Project,
-    workspace: Task,
+    task: Task,
     options?: { silent?: boolean }
   ): Promise<boolean> => {
-    if (deletingTaskIdsRef.current.has(workspace.id)) {
+    if (deletingTaskIdsRef.current.has(task.id)) {
       toast({
         title: 'Deletion in progress',
-        description: `"${workspace.name}" is already being removed.`,
+        description: `"${task.name}" is already being removed.`,
       });
       return false;
     }
 
-    const wasActive = activeTask?.id === workspace.id;
-    const taskSnapshot = { ...workspace };
-    deletingTaskIdsRef.current.add(workspace.id);
-    removeTaskFromState(targetProject.id, workspace.id, wasActive);
+    const wasActive = activeTask?.id === task.id;
+    const taskSnapshot = { ...task };
+    deletingTaskIdsRef.current.add(task.id);
+    removeTaskFromState(targetProject.id, task.id, wasActive);
 
     const runDeletion = async (): Promise<boolean> => {
       try {
@@ -1222,30 +1222,30 @@ const AppContent: React.FC = () => {
           const { initialPromptSentKey } = await import('./lib/keys');
           try {
             // Legacy key (no provider)
-            const legacy = initialPromptSentKey(workspace.id);
+            const legacy = initialPromptSentKey(task.id);
             localStorage.removeItem(legacy);
           } catch {}
           try {
             // Provider-scoped keys
             for (const p of TERMINAL_PROVIDER_IDS) {
-              const k = initialPromptSentKey(workspace.id, p);
+              const k = initialPromptSentKey(task.id, p);
               localStorage.removeItem(k);
             }
           } catch {}
         } catch {}
         try {
-          window.electronAPI.ptyKill?.(`workspace-${workspace.id}`);
+          window.electronAPI.ptyKill?.(`workspace-${task.id}`);
         } catch {}
         try {
           for (const provider of TERMINAL_PROVIDER_IDS) {
             try {
-              window.electronAPI.ptyKill?.(`${provider}-main-${workspace.id}`);
+              window.electronAPI.ptyKill?.(`${provider}-main-${task.id}`);
             } catch {}
           }
         } catch {}
         const sessionIds = [
-          `workspace-${workspace.id}`,
-          ...TERMINAL_PROVIDER_IDS.map((provider) => `${provider}-main-${workspace.id}`),
+          `workspace-${task.id}`,
+          ...TERMINAL_PROVIDER_IDS.map((provider) => `${provider}-main-${task.id}`),
         ];
 
         await Promise.allSettled(
@@ -1262,11 +1262,11 @@ const AppContent: React.FC = () => {
         const [removeResult, deleteResult] = await Promise.allSettled([
           window.electronAPI.worktreeRemove({
             projectPath: targetProject.path,
-            worktreeId: workspace.id,
-            worktreePath: workspace.path,
-            branch: workspace.branch,
+            worktreeId: task.id,
+            worktreePath: task.path,
+            branch: task.branch,
           }),
-          window.electronAPI.deleteTask(workspace.id),
+          window.electronAPI.deleteTask(task.id),
         ]);
 
         if (removeResult.status !== 'fulfilled' || !removeResult.value?.success) {
@@ -1280,7 +1280,7 @@ const AppContent: React.FC = () => {
         if (deleteResult.status !== 'fulfilled' || !deleteResult.value?.success) {
           const errorMsg =
             deleteResult.status === 'fulfilled'
-              ? deleteResult.value?.error || 'Failed to delete workspace'
+              ? deleteResult.value?.error || 'Failed to delete task'
               : deleteResult.reason?.message || String(deleteResult.reason);
           throw new Error(errorMsg);
         }
@@ -1292,19 +1292,19 @@ const AppContent: React.FC = () => {
         if (!options?.silent) {
           toast({
             title: 'Task deleted',
-            description: workspace.name,
+            description: task.name,
           });
         }
         return true;
       } catch (error) {
         const { log } = await import('./lib/logger');
-        log.error('Failed to delete workspace:', error as any);
+        log.error('Failed to delete task:', error as any);
         toast({
           title: 'Error',
           description:
             error instanceof Error
               ? error.message
-              : 'Could not delete workspace. Check the console for details.',
+              : 'Could not delete task. Check the console for details.',
           variant: 'destructive',
         });
 
@@ -1324,7 +1324,7 @@ const AppContent: React.FC = () => {
           );
 
           if (wasActive) {
-            const restored = refreshedTasks.find((w) => w.id === workspace.id);
+            const restored = refreshedTasks.find((w) => w.id === task.id);
             if (restored) {
               handleSelectTask(restored);
             }
@@ -1357,7 +1357,7 @@ const AppContent: React.FC = () => {
         }
         return false;
       } finally {
-        deletingTaskIdsRef.current.delete(workspace.id);
+        deletingTaskIdsRef.current.delete(task.id);
       }
     };
 
diff --git a/src/renderer/components/ActiveRuns.tsx b/src/renderer/components/ActiveRuns.tsx
index 9d2a7754..7bc178e3 100644
--- a/src/renderer/components/ActiveRuns.tsx
+++ b/src/renderer/components/ActiveRuns.tsx
@@ -36,17 +36,17 @@ const ActiveRuns: React.FC<Props> = ({ projects, onSelectProject, onSelectTask }
   if (!activeRuns.length) return null;
 
   // Resolve workspace/project mapping for display and navigation
-  const byId = new Map<string, { project: any | null; workspace: any | null }>();
+  const byId = new Map<string, { project: any | null; task: any | null }>();
   for (const s of activeRuns) {
-    let match: { project: any | null; workspace: any | null } | null = null;
+    let match: { project: any | null; task: any | null } | null = null;
     for (const proj of projects) {
       const ws = (proj.tasks || []).find((w: any) => w.id === s.taskId) || null;
       if (ws) {
-        match = { project: proj, workspace: ws };
+        match = { project: proj, task: ws };
         break;
       }
     }
-    byId.set(s.taskId, match ?? { project: null, workspace: null });
+    byId.set(s.taskId, match ?? { project: null, task: null });
   }
 
   return (
@@ -65,7 +65,7 @@ const ActiveRuns: React.FC<Props> = ({ projects, onSelectProject, onSelectTask }
           {activeRuns.map((s) => {
             const info = byId.get(s.taskId);
             const project = info?.project || null;
-            const ws = info?.workspace || null;
+            const ws = info?.task || null;
             const name = ws?.name || s.taskId;
             const previewUrl = s.previewUrl;
             const onOpen = () => {
diff --git a/src/renderer/components/AutoApproveIndicator.tsx b/src/renderer/components/AutoApproveIndicator.tsx
index 1b7d64b8..37ac7829 100644
--- a/src/renderer/components/AutoApproveIndicator.tsx
+++ b/src/renderer/components/AutoApproveIndicator.tsx
@@ -31,7 +31,7 @@ const AutoApproveIndicator: React.FC<Props> = ({ enabled, className = '' }) => {
           <div>
             <span className="block font-medium">Auto-approve Enabled</span>
             <span className="block">
-              File operations are automatically approved without prompting. This workspace was
+              File operations are automatically approved without prompting. This task was
               created with --dangerously-skip-permissions mode.
             </span>
           </div>
diff --git a/src/renderer/components/CommandPalette.tsx b/src/renderer/components/CommandPalette.tsx
index f04815c0..cdf5ce5f 100644
--- a/src/renderer/components/CommandPalette.tsx
+++ b/src/renderer/components/CommandPalette.tsx
@@ -210,20 +210,20 @@ const CommandPalette: React.FC<CommandPaletteProps> = ({
 
       // Workspace commands
       if (project.tasks && onSelectTask) {
-        project.tasks.forEach((workspace) => {
+        project.tasks.forEach((task) => {
           items.push({
-            id: `workspace-${project.id}-${workspace.id}`,
-            label: workspace.name,
-            description: `${project.name} • ${workspace.branch}`,
+            id: `workspace-${project.id}-${task.id}`,
+            label: task.name,
+            description: `${project.name} • ${task.branch}`,
             icon: <GitBranch className="h-4 w-4" />,
             group: 'Workspaces',
             keywords: [
               'workspace',
-              workspace.name.toLowerCase(),
-              workspace.branch.toLowerCase(),
+              task.name.toLowerCase(),
+              task.branch.toLowerCase(),
               project.name.toLowerCase(),
             ],
-            onSelect: () => runCommand(() => onSelectTask(project.id, workspace.id)),
+            onSelect: () => runCommand(() => onSelectTask(project.id, task.id)),
           });
         });
       }
diff --git a/src/renderer/components/CommandPaletteWrapper.tsx b/src/renderer/components/CommandPaletteWrapper.tsx
index 01d5c96e..5ddd1f6d 100644
--- a/src/renderer/components/CommandPaletteWrapper.tsx
+++ b/src/renderer/components/CommandPaletteWrapper.tsx
@@ -10,7 +10,7 @@ export interface CommandPaletteWrapperProps {
   onClose: () => void;
   projects: Project[];
   handleSelectProject: (project: Project) => void;
-  handleSelectTask: (workspace: Task) => void;
+  handleSelectTask: (task: Task) => void;
   handleGoHome: () => void;
   handleOpenProject: () => void;
   handleOpenSettings: () => void;
@@ -41,10 +41,10 @@ const CommandPaletteWrapper: React.FC<CommandPaletteWrapperProps> = ({
       }}
       onSelectTask={(projectId, taskId) => {
         const project = projects.find((p) => p.id === projectId);
-        const workspace = project?.tasks?.find((w: Task) => w.id === taskId);
-        if (project && workspace) {
+        const task = project?.tasks?.find((w: Task) => w.id === taskId);
+        if (project && task) {
           handleSelectProject(project);
-          handleSelectTask(workspace);
+          handleSelectTask(task);
         }
       }}
       onOpenSettings={handleOpenSettings}
diff --git a/src/renderer/components/ProjectMainView.tsx b/src/renderer/components/ProjectMainView.tsx
index b4d70ec5..83040b09 100644
--- a/src/renderer/components/ProjectMainView.tsx
+++ b/src/renderer/components/ProjectMainView.tsx
@@ -362,7 +362,7 @@ function WorkspaceRow({
                 }
               }}
               isDeleting={isDeleting}
-              aria-label={`Delete workspace ${ws.name}`}
+              aria-label={`Delete task ${ws.name}`}
               className="inline-flex items-center justify-center rounded p-2 text-muted-foreground hover:bg-transparent focus-visible:ring-0"
             />
           )}
@@ -787,7 +787,7 @@ const ProjectMainView: React.FC<ProjectMainViewProps> = ({
                   <div className="space-y-1">
                     <h2 className="text-lg font-semibold">Tasks</h2>
                     <p className="text-xs text-muted-foreground">
-                      Spin up a fresh, isolated workspace for this project.
+                      Spin up a fresh, isolated task for this project.
                     </p>
                   </div>
                   {!isSelectMode && (
diff --git a/src/renderer/components/ProviderBar.tsx b/src/renderer/components/ProviderBar.tsx
index ca2e33ca..047873b3 100644
--- a/src/renderer/components/ProviderBar.tsx
+++ b/src/renderer/components/ProviderBar.tsx
@@ -92,7 +92,7 @@ export const ProviderBar: React.FC<Props> = ({
       if (!c7Enabled) return;
 
       if (!c7WorkspaceEnabled) {
-        // Enable for this workspace and send invocation once
+        // Enable for this task and send invocation once
         try {
           localStorage.setItem(`c7:ws:${taskId}`, '1');
         } catch {}
@@ -408,8 +408,8 @@ export const ProviderBar: React.FC<Props> = ({
                       title={
                         c7Enabled
                           ? c7WorkspaceEnabled
-                            ? 'Disable Context7 for this workspace'
-                            : 'Enable for this workspace & send to terminal'
+                            ? 'Disable Context7 for this task'
+                            : 'Enable for this task & send to terminal'
                           : 'Enable Context7 in Settings → MCP to use here'
                       }
                     >
diff --git a/src/renderer/components/TaskModal.tsx b/src/renderer/components/TaskModal.tsx
index 2c8a3d9e..c615e6dc 100644
--- a/src/renderer/components/TaskModal.tsx
+++ b/src/renderer/components/TaskModal.tsx
@@ -421,7 +421,7 @@ const TaskModal: React.FC<TaskModalProps> = ({
                         );
                         onClose();
                       } catch (error) {
-                        console.error('Failed to create workspace:', error);
+                        console.error('Failed to create task:', error);
                       } finally {
                         setIsCreating(false);
                       }
diff --git a/src/renderer/hooks/useCreatePR.tsx b/src/renderer/hooks/useCreatePR.tsx
index 92fec60a..b20793c8 100644
--- a/src/renderer/hooks/useCreatePR.tsx
+++ b/src/renderer/hooks/useCreatePR.tsx
@@ -27,7 +27,7 @@ export function useCreatePR() {
   const createPR = async (opts: CreatePROptions) => {
     const {
       taskPath,
-      commitMessage = 'chore: apply workspace changes',
+      commitMessage = 'chore: apply task changes',
       createBranchIfOnDefault = true,
       branchPrefix = 'orch',
       prOptions,
diff --git a/src/renderer/hooks/useInitialPromptInjection.ts b/src/renderer/hooks/useInitialPromptInjection.ts
index 5705571d..d57f4b94 100644
--- a/src/renderer/hooks/useInitialPromptInjection.ts
+++ b/src/renderer/hooks/useInitialPromptInjection.ts
@@ -4,7 +4,7 @@ import { classifyActivity } from '../lib/activityClassifier';
 
 /**
  * Injects an initial prompt into the provider's terminal once the PTY is ready.
- * One-shot per workspace. Provider-agnostic.
+ * One-shot per task. Provider-agnostic.
  */
 export function useInitialPromptInjection(opts: {
   taskId: string;
diff --git a/src/renderer/hooks/usePlanActivation.ts b/src/renderer/hooks/usePlanActivation.ts
index 7c21e7da..a321614f 100644
--- a/src/renderer/hooks/usePlanActivation.ts
+++ b/src/renderer/hooks/usePlanActivation.ts
@@ -5,7 +5,7 @@ import { logPlanEvent } from '@/lib/planLogs';
 
 /**
  * Terminal-only providers: if a native plan activation command exists,
- * send it once when the PTY session starts for this workspace/provider.
+ * send it once when the PTY session starts for this task/provider.
  */
 export function usePlanActivationTerminal(opts: {
   enabled: boolean;
diff --git a/src/renderer/lib/attachments.ts b/src/renderer/lib/attachments.ts
index d90b5979..7ef0f915 100644
--- a/src/renderer/lib/attachments.ts
+++ b/src/renderer/lib/attachments.ts
@@ -63,7 +63,7 @@ export async function buildAttachmentsSection(
   }
 
   if (parts.length === 0) return '';
-  return `\n\n---\nAttached files (from workspace):\n\n${parts.join('\n\n')}\n`;
+  return `\n\n---\nAttached files (from task):\n\n${parts.join('\n\n')}\n`;
 }
 
 export function buildImageAttachmentsSection(taskPath: string, relPaths: string[]): string {
@@ -77,5 +77,5 @@ export function buildImageAttachmentsSection(taskPath: string, relPaths: string[
     const url = `file://${absPath}`;
     lines.push(`![${name}](${url})`);
   }
-  return `\n\n---\nAttached images (from workspace):\n\n${lines.join('\n')}\n`;
+  return `\n\n---\nAttached images (from task):\n\n${lines.join('\n')}\n`;
 }
diff --git a/src/renderer/lib/containerRuns.ts b/src/renderer/lib/containerRuns.ts
index 10e1aa5b..0efe4774 100644
--- a/src/renderer/lib/containerRuns.ts
+++ b/src/renderer/lib/containerRuns.ts
@@ -133,7 +133,7 @@ function updateWorkspaceState(event: RunnerEvent) {
       try {
         listener({ ...state });
       } catch (error) {
-        log.warn?.('[containers] workspace listener failure', error);
+        log.warn?.('[containers] task listener failure', error);
       }
     }
   }
@@ -150,7 +150,7 @@ function ensureSubscribed() {
       try {
         updateWorkspaceState(event);
       } catch (error) {
-        log.error('[containers] failed to update workspace state', error);
+        log.error('[containers] failed to update task state', error);
       }
       for (const listener of listeners) {
         try {
@@ -188,7 +188,7 @@ export function subscribeToWorkspaceRunState(
     try {
       listener({ ...current });
     } catch (error) {
-      log.warn?.('[containers] workspace listener init failure', error);
+      log.warn?.('[containers] task listener init failure', error);
     }
   }
 
@@ -280,7 +280,7 @@ export function subscribeToAllRunStates(
 }
 
 /**
- * Inspect any existing compose stack for this workspace and hydrate local state,
+ * Inspect any existing compose stack for this task and hydrate local state,
  * so UI shows ports/running status after a window refresh.
  */
 export async function refreshWorkspaceRunState(taskId: string) {
diff --git a/src/renderer/types/electron-api.d.ts b/src/renderer/types/electron-api.d.ts
index dcb5e27c..682cf831 100644
--- a/src/renderer/types/electron-api.d.ts
+++ b/src/renderer/types/electron-api.d.ts
@@ -573,7 +573,7 @@ declare global {
       getProjects: () => Promise<any[]>;
       saveProject: (project: any) => Promise<{ success: boolean; error?: string }>;
       getTasks: (projectId?: string) => Promise<any[]>;
-      saveTask: (workspace: any) => Promise<{ success: boolean; error?: string }>;
+      saveTask: (task: any) => Promise<{ success: boolean; error?: string }>;
       deleteProject: (projectId: string) => Promise<{ success: boolean; error?: string }>;
       deleteTask: (taskId: string) => Promise<{ success: boolean; error?: string }>;
 
@@ -900,7 +900,7 @@ export interface ElectronAPI {
   getProjects: () => Promise<any[]>;
   saveProject: (project: any) => Promise<{ success: boolean; error?: string }>;
   getTasks: (projectId?: string) => Promise<any[]>;
-  saveTask: (workspace: any) => Promise<{ success: boolean; error?: string }>;
+  saveTask: (task: any) => Promise<{ success: boolean; error?: string }>;
   deleteProject: (projectId: string) => Promise<{ success: boolean; error?: string }>;
   deleteTask: (taskId: string) => Promise<{ success: boolean; error?: string }>;
 
diff --git a/src/renderer/types/global.d.ts b/src/renderer/types/global.d.ts
index 542fc29c..e1f49bd8 100644
--- a/src/renderer/types/global.d.ts
+++ b/src/renderer/types/global.d.ts
@@ -206,7 +206,7 @@ declare global {
       getProjects: () => Promise<any[]>;
       saveProject: (project: any) => Promise<{ success: boolean; error?: string }>;
       getTasks: (projectId?: string) => Promise<any[]>;
-      saveTask: (workspace: any) => Promise<{ success: boolean; error?: string }>;
+      saveTask: (task: any) => Promise<{ success: boolean; error?: string }>;
       deleteProject: (projectId: string) => Promise<{ success: boolean; error?: string }>;
       deleteTask: (taskId: string) => Promise<{ success: boolean; error?: string }>;
     };

From 4873ab1e048030742acabed97436162e27628396 Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Fri, 12 Dec 2025 17:51:24 -0800
Subject: [PATCH 11/35] refactor: rename workspace to task in main process

---
 src/main/ipc/dbIpc.ts                      | 10 +++---
 src/main/ipc/gitIpc.ts                     |  2 +-
 src/main/preload.ts                        |  4 +--
 src/main/services/DatabaseService.ts       | 36 +++++++++++-----------
 src/renderer/components/CommandPalette.tsx |  2 +-
 src/renderer/components/TaskPorts.tsx      |  2 +-
 6 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/src/main/ipc/dbIpc.ts b/src/main/ipc/dbIpc.ts
index a3920ce9..80d5daaa 100644
--- a/src/main/ipc/dbIpc.ts
+++ b/src/main/ipc/dbIpc.ts
@@ -32,12 +32,12 @@ export function registerDatabaseIpc() {
     }
   });
 
-  ipcMain.handle('db:saveTask', async (_, workspace: any) => {
+  ipcMain.handle('db:saveTask', async (_, task: any) => {
     try {
-      await databaseService.saveTask(workspace);
+      await databaseService.saveTask(task);
       return { success: true };
     } catch (error) {
-      log.error('Failed to save workspace:', error);
+      log.error('Failed to save task:', error);
       return { success: false, error: (error as Error).message };
     }
   });
@@ -118,13 +118,13 @@ export function registerDatabaseIpc() {
       const stopResult = await containerRunnerService.stopRun(taskId);
       if (!stopResult.ok) {
         // Log but don't fail workspace deletion if container stop fails
-        log.warn('Failed to stop container during workspace deletion:', stopResult.error);
+        log.warn('Failed to stop container during task deletion:', stopResult.error);
       }
 
       await databaseService.deleteTask(taskId);
       return { success: true };
     } catch (error) {
-      log.error('Failed to delete workspace:', error);
+      log.error('Failed to delete task:', error);
       return { success: false, error: (error as Error).message };
     }
   });
diff --git a/src/main/ipc/gitIpc.ts b/src/main/ipc/gitIpc.ts
index f301a8d1..ee5c0004 100644
--- a/src/main/ipc/gitIpc.ts
+++ b/src/main/ipc/gitIpc.ts
@@ -372,7 +372,7 @@ current branch '${currentBranch}' ahead of base '${baseRef}'.`,
     ) => {
       const {
         taskPath,
-        commitMessage = 'chore: apply workspace changes',
+        commitMessage = 'chore: apply task changes',
         createBranchIfOnDefault = true,
         branchPrefix = 'orch',
       } = (args ||
diff --git a/src/main/preload.ts b/src/main/preload.ts
index ef54ed52..f1305b67 100644
--- a/src/main/preload.ts
+++ b/src/main/preload.ts
@@ -275,7 +275,7 @@ contextBridge.exposeInMainWorld('electronAPI', {
   getProjects: () => ipcRenderer.invoke('db:getProjects'),
   saveProject: (project: any) => ipcRenderer.invoke('db:saveProject', project),
   getTasks: (projectId?: string) => ipcRenderer.invoke('db:getTasks', projectId),
-  saveTask: (workspace: any) => ipcRenderer.invoke('db:saveTask', workspace),
+  saveTask: (task: any) => ipcRenderer.invoke('db:saveTask', task),
   deleteProject: (projectId: string) => ipcRenderer.invoke('db:deleteProject', projectId),
   deleteTask: (taskId: string) => ipcRenderer.invoke('db:deleteTask', taskId),
 
@@ -625,7 +625,7 @@ export interface ElectronAPI {
   getProjects: () => Promise<any[]>;
   saveProject: (project: any) => Promise<{ success: boolean; error?: string }>;
   getTasks: (projectId?: string) => Promise<any[]>;
-  saveTask: (workspace: any) => Promise<{ success: boolean; error?: string }>;
+  saveTask: (task: any) => Promise<{ success: boolean; error?: string }>;
   deleteProject: (projectId: string) => Promise<{ success: boolean; error?: string }>;
   deleteTask: (taskId: string) => Promise<{ success: boolean; error?: string }>;
 
diff --git a/src/main/services/DatabaseService.ts b/src/main/services/DatabaseService.ts
index 4c548525..0c2dd83b 100644
--- a/src/main/services/DatabaseService.ts
+++ b/src/main/services/DatabaseService.ts
@@ -207,37 +207,37 @@ export class DatabaseService {
     return this.getProjectById(projectId);
   }
 
-  async saveTask(workspace: Omit<Workspace, 'createdAt' | 'updatedAt'>): Promise<void> {
+  async saveTask(task: Omit<Workspace, 'createdAt' | 'updatedAt'>): Promise<void> {
     if (this.disabled) return;
     const metadataValue =
-      typeof workspace.metadata === 'string'
-        ? workspace.metadata
-        : workspace.metadata
-          ? JSON.stringify(workspace.metadata)
+      typeof task.metadata === 'string'
+        ? task.metadata
+        : task.metadata
+          ? JSON.stringify(task.metadata)
           : null;
     const { db } = await getDrizzleClient();
     await db
       .insert(workspacesTable)
       .values({
-        id: workspace.id,
-        projectId: workspace.projectId,
-        name: workspace.name,
-        branch: workspace.branch,
-        path: workspace.path,
-        status: workspace.status,
-        agentId: workspace.agentId ?? null,
+        id: task.id,
+        projectId: task.projectId,
+        name: task.name,
+        branch: task.branch,
+        path: task.path,
+        status: task.status,
+        agentId: task.agentId ?? null,
         metadata: metadataValue,
         updatedAt: sql`CURRENT_TIMESTAMP`,
       })
       .onConflictDoUpdate({
         target: workspacesTable.id,
         set: {
-          projectId: workspace.projectId,
-          name: workspace.name,
-          branch: workspace.branch,
-          path: workspace.path,
-          status: workspace.status,
-          agentId: workspace.agentId ?? null,
+          projectId: task.projectId,
+          name: task.name,
+          branch: task.branch,
+          path: task.path,
+          status: task.status,
+          agentId: task.agentId ?? null,
           metadata: metadataValue,
           updatedAt: sql`CURRENT_TIMESTAMP`,
         },
diff --git a/src/renderer/components/CommandPalette.tsx b/src/renderer/components/CommandPalette.tsx
index cdf5ce5f..fbb27f9d 100644
--- a/src/renderer/components/CommandPalette.tsx
+++ b/src/renderer/components/CommandPalette.tsx
@@ -218,7 +218,7 @@ const CommandPalette: React.FC<CommandPaletteProps> = ({
             icon: <GitBranch className="h-4 w-4" />,
             group: 'Workspaces',
             keywords: [
-              'workspace',
+              'task',
               task.name.toLowerCase(),
               task.branch.toLowerCase(),
               project.name.toLowerCase(),
diff --git a/src/renderer/components/TaskPorts.tsx b/src/renderer/components/TaskPorts.tsx
index b12abc21..47937d39 100644
--- a/src/renderer/components/TaskPorts.tsx
+++ b/src/renderer/components/TaskPorts.tsx
@@ -224,7 +224,7 @@ const WorkspacePorts: React.FC<Props> = ({
             </>
           ) : (
             <div className="space-y-2">
-              <div>Live expose requires a docker-compose.yml at the workspace root.</div>
+              <div>Live expose requires a docker-compose.yml at the task root.</div>
               <button
                 type="button"
                 className="inline-flex items-center rounded border border-border/70 bg-background px-2 py-0.5 text-[11px] font-medium hover:bg-muted/40"

From c23812dc4897b721c0532a7b21459db4f70284eb Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Fri, 12 Dec 2025 17:54:10 -0800
Subject: [PATCH 12/35] refactor: rename workspace HTML IDs to task

---
 src/renderer/components/CommandPalette.tsx | 2 +-
 src/renderer/components/TaskModal.tsx      | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/renderer/components/CommandPalette.tsx b/src/renderer/components/CommandPalette.tsx
index fbb27f9d..6ff78a15 100644
--- a/src/renderer/components/CommandPalette.tsx
+++ b/src/renderer/components/CommandPalette.tsx
@@ -212,7 +212,7 @@ const CommandPalette: React.FC<CommandPaletteProps> = ({
       if (project.tasks && onSelectTask) {
         project.tasks.forEach((task) => {
           items.push({
-            id: `workspace-${project.id}-${task.id}`,
+            id: `task-${project.id}-${task.id}`,
             label: task.name,
             description: `${project.name} • ${task.branch}`,
             icon: <GitBranch className="h-4 w-4" />,
diff --git a/src/renderer/components/TaskModal.tsx b/src/renderer/components/TaskModal.tsx
index c615e6dc..a8d9f465 100644
--- a/src/renderer/components/TaskModal.tsx
+++ b/src/renderer/components/TaskModal.tsx
@@ -430,18 +430,18 @@ const TaskModal: React.FC<TaskModalProps> = ({
                   className="space-y-4"
                 >
                   <div>
-                    <Label htmlFor="workspace-name" className="mb-2 block">
+                    <Label htmlFor="task-name" className="mb-2 block">
                       Task name
                     </Label>
                     <Input
-                      id="workspace-name"
+                      id="task-name"
                       value={taskName}
                       onChange={(e) => onChange(e.target.value)}
                       onBlur={() => setTouched(true)}
                       placeholder="refactor-api-routes"
                       className={`w-full ${touched && error ? 'border-destructive focus-visible:border-destructive focus-visible:ring-destructive' : ''}`}
                       aria-invalid={touched && !!error}
-                      aria-describedby="workspace-name-error"
+                      aria-describedby="task-name-error"
                       autoFocus
                     />
                   </div>
@@ -506,7 +506,7 @@ const TaskModal: React.FC<TaskModalProps> = ({
                           <span>Advanced options</span>
                         </span>
                       </AccordionTrigger>
-                      <AccordionContent className="space-y-4 px-0 pt-2" id="workspace-advanced">
+                      <AccordionContent className="space-y-4 px-0 pt-2" id="task-advanced">
                         <div className="flex flex-col gap-4 p-2">
                           {hasAutoApproveSupport ? (
                             <div className="flex items-center gap-4">

From 584bd9beee5015ce0bd82a0c725e137d35f871c9 Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Fri, 12 Dec 2025 17:55:12 -0800
Subject: [PATCH 13/35] refactor: rename workspace CSS classes to task

---
 src/renderer/components/LeftSidebar.tsx | 6 +++---
 src/renderer/components/TaskItem.tsx    | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/renderer/components/LeftSidebar.tsx b/src/renderer/components/LeftSidebar.tsx
index 6d6d4ed9..7b1d93be 100644
--- a/src/renderer/components/LeftSidebar.tsx
+++ b/src/renderer/components/LeftSidebar.tsx
@@ -204,7 +204,7 @@ const LeftSidebar: React.FC<LeftSidebarProps> = ({
                       <SidebarMenuItem>
                         <Collapsible defaultOpen className="group/collapsible">
                           <div
-                            className={`group/project group/workspace flex w-full min-w-0 items-center rounded-md px-2 py-2 text-sm font-medium focus-within:bg-accent focus-within:text-accent-foreground hover:bg-accent hover:text-accent-foreground ${
+                            className={`group/project group/task flex w-full min-w-0 items-center rounded-md px-2 py-2 text-sm font-medium focus-within:bg-accent focus-within:text-accent-foreground hover:bg-accent hover:text-accent-foreground ${
                               isProjectActive ? 'bg-black/5 dark:bg-white/5' : ''
                             }`}
                           >
@@ -231,7 +231,7 @@ const LeftSidebar: React.FC<LeftSidebarProps> = ({
                                   className={`absolute left-0 inline-flex h-5 w-5 items-center justify-center rounded p-0.5 text-muted-foreground opacity-0 transition-opacity duration-150 hover:bg-muted focus:opacity-100 focus-visible:opacity-100 focus-visible:ring-0 disabled:cursor-not-allowed disabled:opacity-100 ${
                                     isDeletingProject
                                       ? 'opacity-100'
-                                      : 'group-hover/workspace:opacity-100'
+                                      : 'group-hover/task:opacity-100'
                                   }`}
                                 />
                               ) : null}
@@ -292,7 +292,7 @@ const LeftSidebar: React.FC<LeftSidebarProps> = ({
                                         }
                                         onSelectTask && onSelectTask(task);
                                       }}
-                                      className={`group/workspace min-w-0 rounded-md px-2 py-1.5 hover:bg-black/5 dark:hover:bg-white/5 ${
+                                      className={`group/task min-w-0 rounded-md px-2 py-1.5 hover:bg-black/5 dark:hover:bg-white/5 ${
                                         isActive ? 'bg-black/5 dark:bg-white/5' : ''
                                       }`}
                                       title={task.name}
diff --git a/src/renderer/components/TaskItem.tsx b/src/renderer/components/TaskItem.tsx
index 93c83bfa..063a2b0a 100644
--- a/src/renderer/components/TaskItem.tsx
+++ b/src/renderer/components/TaskItem.tsx
@@ -64,7 +64,7 @@ export const TaskItem: React.FC<TaskItemProps> = ({
             isDeleting={isDeleting}
             aria-label={`Delete Task ${task.name}`}
             className={`absolute left-0 inline-flex h-5 w-5 items-center justify-center rounded p-0.5 text-muted-foreground transition-opacity duration-150 hover:bg-muted focus:opacity-100 focus-visible:opacity-100 ${
-              isDeleting ? 'opacity-100' : 'opacity-0 group-hover/workspace:opacity-100'
+              isDeleting ? 'opacity-100' : 'opacity-0 group-hover/task:opacity-100'
             }`}
           />
         ) : null}

From b9ba8ae66afbf6a0704304ca9585e4c3700fcf05 Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Fri, 12 Dec 2025 17:56:34 -0800
Subject: [PATCH 14/35] refactor: update workspace fallback strings and
 comments to task

---
 src/main/services/DatabaseService.ts         | 2 +-
 src/main/services/GitHubService.ts           | 2 +-
 src/main/services/TerminalSnapshotService.ts | 2 +-
 src/main/services/WorktreeService.ts         | 8 ++++----
 src/main/services/containerRunnerService.ts  | 2 +-
 5 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/main/services/DatabaseService.ts b/src/main/services/DatabaseService.ts
index 0c2dd83b..6919d486 100644
--- a/src/main/services/DatabaseService.ts
+++ b/src/main/services/DatabaseService.ts
@@ -512,7 +512,7 @@ export class DatabaseService {
     try {
       return JSON.parse(serialized);
     } catch (error) {
-      console.warn(`Failed to parse workspace metadata for ${taskId}`, error);
+      console.warn(`Failed to parse task metadata for ${taskId}`, error);
       return null;
     }
   }
diff --git a/src/main/services/GitHubService.ts b/src/main/services/GitHubService.ts
index d098054a..f7b337df 100644
--- a/src/main/services/GitHubService.ts
+++ b/src/main/services/GitHubService.ts
@@ -748,7 +748,7 @@ export class GitHubService {
   }
 
   /**
-   * Clone a repository to local workspace
+   * Clone a repository to local task directory
    */
   async cloneRepository(
     repoUrl: string,
diff --git a/src/main/services/TerminalSnapshotService.ts b/src/main/services/TerminalSnapshotService.ts
index 099443c3..7f67196c 100644
--- a/src/main/services/TerminalSnapshotService.ts
+++ b/src/main/services/TerminalSnapshotService.ts
@@ -117,7 +117,7 @@ class TerminalSnapshotService {
       const json = JSON.stringify(payload);
       const bytes = Buffer.byteLength(json, 'utf8');
       if (bytes > MAX_SNAPSHOT_BYTES) {
-        return { ok: false, error: 'Snapshot size exceeds per-workspace limit' };
+        return { ok: false, error: 'Snapshot size exceeds per-task limit' };
       }
 
       await ensureDir();
diff --git a/src/main/services/WorktreeService.ts b/src/main/services/WorktreeService.ts
index c977be0b..11ba1aee 100644
--- a/src/main/services/WorktreeService.ts
+++ b/src/main/services/WorktreeService.ts
@@ -25,7 +25,7 @@ export class WorktreeService {
   private worktrees = new Map<string, WorktreeInfo>();
 
   /**
-   * Slugify workspace name to make it shell-safe
+   * Slugify task name to make it shell-safe
    */
   private slugify(name: string): string {
     return name
@@ -45,7 +45,7 @@ export class WorktreeService {
   }
 
   /**
-   * Create a new Git worktree for an agent workspace
+   * Create a new Git worktree for an agent task
    */
   async createWorktree(
     projectPath: string,
@@ -249,7 +249,7 @@ export class WorktreeService {
     n = n.replace(/^[./-]+/, '').replace(/[./-]+$/, '');
     // Avoid reserved ref names
     if (!n || n === 'HEAD') {
-      n = `agent/${this.slugify('workspace')}-${Date.now()}`;
+      n = `agent/${this.slugify('task')}-${Date.now()}`;
     }
     return n;
   }
@@ -774,7 +774,7 @@ export class WorktreeService {
     options?: { worktreePath?: string }
   ): Promise<WorktreeInfo> {
     const normalizedName = taskName || branchName.replace(/\//g, '-');
-    const sluggedName = this.slugify(normalizedName) || 'workspace';
+    const sluggedName = this.slugify(normalizedName) || 'task';
     const targetPath =
       options?.worktreePath ||
       path.join(projectPath, '..', `worktrees/${sluggedName}-${Date.now()}`);
diff --git a/src/main/services/containerRunnerService.ts b/src/main/services/containerRunnerService.ts
index 74bdcfc1..10b61b44 100644
--- a/src/main/services/containerRunnerService.ts
+++ b/src/main/services/containerRunnerService.ts
@@ -785,7 +785,7 @@ export class ContainerRunnerService extends EventEmitter {
     }
   }
 
-  /** Stop and remove a running container for a task (workspace) */
+  /** Stop and remove a running container for a task */
   async stopRun(taskId: string, opts: { now?: () => number; mode?: RunnerMode } = {}) {
     const now = opts.now ?? Date.now;
     const mode = opts.mode ?? 'container';

From a265d31c4c2f3e1847e9f91ee1670a5839684062 Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Fri, 12 Dec 2025 17:59:38 -0800
Subject: [PATCH 15/35] refactor: rename workspace relation to task in schema

---
 src/main/db/schema.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/db/schema.ts b/src/main/db/schema.ts
index fcdfd2a5..e70fb6d1 100644
--- a/src/main/db/schema.ts
+++ b/src/main/db/schema.ts
@@ -102,7 +102,7 @@ export const workspacesRelations = relations(workspaces, ({ one, many }) => ({
 }));
 
 export const conversationsRelations = relations(conversations, ({ one, many }) => ({
-  workspace: one(workspaces, {
+  task: one(workspaces, {
     fields: [conversations.taskId],
     references: [workspaces.id],
   }),

From aec7a991b9e36cd0c58ddf55b1a180be93409c54 Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Fri, 12 Dec 2025 18:33:01 -0800
Subject: [PATCH 16/35] db: rename workspaces table to tasks

---
 drizzle/0002_lyrical_impossible_man.sql |  34 +++
 drizzle/meta/0001_snapshot.json         |   2 +-
 drizzle/meta/0002_snapshot.json         | 369 ++++++++++++++++++++++++
 drizzle/meta/_journal.json              |  11 +-
 src/main/db/schema.ts                   |  24 +-
 src/main/services/DatabaseService.ts    |  24 +-
 6 files changed, 437 insertions(+), 27 deletions(-)
 create mode 100644 drizzle/0002_lyrical_impossible_man.sql
 create mode 100644 drizzle/meta/0002_snapshot.json

diff --git a/drizzle/0002_lyrical_impossible_man.sql b/drizzle/0002_lyrical_impossible_man.sql
new file mode 100644
index 00000000..d3795025
--- /dev/null
+++ b/drizzle/0002_lyrical_impossible_man.sql
@@ -0,0 +1,34 @@
+ALTER TABLE `workspaces` RENAME TO `tasks`;--> statement-breakpoint
+PRAGMA foreign_keys=OFF;--> statement-breakpoint
+CREATE TABLE `__new_tasks` (
+	`id` text PRIMARY KEY NOT NULL,
+	`project_id` text NOT NULL,
+	`name` text NOT NULL,
+	`branch` text NOT NULL,
+	`path` text NOT NULL,
+	`status` text DEFAULT 'idle' NOT NULL,
+	`agent_id` text,
+	`metadata` text,
+	`created_at` text DEFAULT CURRENT_TIMESTAMP NOT NULL,
+	`updated_at` text DEFAULT CURRENT_TIMESTAMP NOT NULL,
+	FOREIGN KEY (`project_id`) REFERENCES `projects`(`id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+INSERT INTO `__new_tasks`("id", "project_id", "name", "branch", "path", "status", "agent_id", "metadata", "created_at", "updated_at") SELECT "id", "project_id", "name", "branch", "path", "status", "agent_id", "metadata", "created_at", "updated_at" FROM `tasks`;--> statement-breakpoint
+DROP TABLE `tasks`;--> statement-breakpoint
+ALTER TABLE `__new_tasks` RENAME TO `tasks`;--> statement-breakpoint
+PRAGMA foreign_keys=ON;--> statement-breakpoint
+CREATE INDEX `idx_tasks_project_id` ON `tasks` (`project_id`);--> statement-breakpoint
+CREATE TABLE `__new_conversations` (
+	`id` text PRIMARY KEY NOT NULL,
+	`task_id` text NOT NULL,
+	`title` text NOT NULL,
+	`created_at` text DEFAULT CURRENT_TIMESTAMP NOT NULL,
+	`updated_at` text DEFAULT CURRENT_TIMESTAMP NOT NULL,
+	FOREIGN KEY (`task_id`) REFERENCES `tasks`(`id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+INSERT INTO `__new_conversations`("id", "task_id", "title", "created_at", "updated_at") SELECT "id", "workspace_id", "title", "created_at", "updated_at" FROM `conversations`;--> statement-breakpoint
+DROP TABLE `conversations`;--> statement-breakpoint
+ALTER TABLE `__new_conversations` RENAME TO `conversations`;--> statement-breakpoint
+CREATE INDEX `idx_conversations_task_id` ON `conversations` (`task_id`);
\ No newline at end of file
diff --git a/drizzle/meta/0001_snapshot.json b/drizzle/meta/0001_snapshot.json
index c3aeb73b..90204e26 100644
--- a/drizzle/meta/0001_snapshot.json
+++ b/drizzle/meta/0001_snapshot.json
@@ -1,5 +1,5 @@
 {
-  "version": "7",
+  "version": "6",
   "dialect": "sqlite",
   "id": "ec5ad35e-22ec-4c0b-9d48-cfb1033d9d93",
   "prevId": "b932945e-f26a-4c07-9c63-08179d95d5bc",
diff --git a/drizzle/meta/0002_snapshot.json b/drizzle/meta/0002_snapshot.json
new file mode 100644
index 00000000..3cb2e097
--- /dev/null
+++ b/drizzle/meta/0002_snapshot.json
@@ -0,0 +1,369 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "f61fcd81-f000-4e2d-84f2-2f79133ae5d6",
+  "prevId": "ec5ad35e-22ec-4c0b-9d48-cfb1033d9d93",
+  "tables": {
+    "conversations": {
+      "name": "conversations",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "task_id": {
+          "name": "task_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "CURRENT_TIMESTAMP"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "CURRENT_TIMESTAMP"
+        }
+      },
+      "indexes": {
+        "idx_conversations_task_id": {
+          "name": "idx_conversations_task_id",
+          "columns": [
+            "task_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "conversations_task_id_tasks_id_fk": {
+          "name": "conversations_task_id_tasks_id_fk",
+          "tableFrom": "conversations",
+          "tableTo": "tasks",
+          "columnsFrom": [
+            "task_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "messages": {
+      "name": "messages",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "conversation_id": {
+          "name": "conversation_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sender": {
+          "name": "sender",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "timestamp": {
+          "name": "timestamp",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "CURRENT_TIMESTAMP"
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "idx_messages_conversation_id": {
+          "name": "idx_messages_conversation_id",
+          "columns": [
+            "conversation_id"
+          ],
+          "isUnique": false
+        },
+        "idx_messages_timestamp": {
+          "name": "idx_messages_timestamp",
+          "columns": [
+            "timestamp"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "messages_conversation_id_conversations_id_fk": {
+          "name": "messages_conversation_id_conversations_id_fk",
+          "tableFrom": "messages",
+          "tableTo": "conversations",
+          "columnsFrom": [
+            "conversation_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "projects": {
+      "name": "projects",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "path": {
+          "name": "path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "git_remote": {
+          "name": "git_remote",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "git_branch": {
+          "name": "git_branch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "base_ref": {
+          "name": "base_ref",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "github_repository": {
+          "name": "github_repository",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "github_connected": {
+          "name": "github_connected",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "CURRENT_TIMESTAMP"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "CURRENT_TIMESTAMP"
+        }
+      },
+      "indexes": {
+        "idx_projects_path": {
+          "name": "idx_projects_path",
+          "columns": [
+            "path"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "tasks": {
+      "name": "tasks",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "branch": {
+          "name": "branch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "path": {
+          "name": "path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'idle'"
+        },
+        "agent_id": {
+          "name": "agent_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "CURRENT_TIMESTAMP"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "CURRENT_TIMESTAMP"
+        }
+      },
+      "indexes": {
+        "idx_tasks_project_id": {
+          "name": "idx_tasks_project_id",
+          "columns": [
+            "project_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "tasks_project_id_projects_id_fk": {
+          "name": "tasks_project_id_projects_id_fk",
+          "tableFrom": "tasks",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {
+      "\"workspaces\"": "\"tasks\""
+    },
+    "columns": {
+      "\"conversations\".\"workspace_id\"": "\"conversations\".\"task_id\""
+    }
+  },
+  "internal": {
+    "indexes": {}
+  }
+}
\ No newline at end of file
diff --git a/drizzle/meta/_journal.json b/drizzle/meta/_journal.json
index c018fded..82d78e8d 100644
--- a/drizzle/meta/_journal.json
+++ b/drizzle/meta/_journal.json
@@ -11,10 +11,17 @@
     },
     {
       "idx": 1,
-      "version": "7",
+      "version": "6",
       "when": 1761240000000,
       "tag": "0001_add_base_ref_to_projects",
       "breakpoints": true
+    },
+    {
+      "idx": 2,
+      "version": "6",
+      "when": 1765592430354,
+      "tag": "0002_lyrical_impossible_man",
+      "breakpoints": true
     }
   ]
-}
+}
\ No newline at end of file
diff --git a/src/main/db/schema.ts b/src/main/db/schema.ts
index e70fb6d1..62b413f8 100644
--- a/src/main/db/schema.ts
+++ b/src/main/db/schema.ts
@@ -24,8 +24,8 @@ export const projects = sqliteTable(
   })
 );
 
-export const workspaces = sqliteTable(
-  'workspaces',
+export const tasks = sqliteTable(
+  'tasks',
   {
     id: text('id').primaryKey(),
     projectId: text('project_id')
@@ -45,7 +45,7 @@ export const workspaces = sqliteTable(
       .default(sql`CURRENT_TIMESTAMP`),
   },
   (table) => ({
-    projectIdIdx: index('idx_workspaces_project_id').on(table.projectId),
+    projectIdIdx: index('idx_tasks_project_id').on(table.projectId),
   })
 );
 
@@ -53,9 +53,9 @@ export const conversations = sqliteTable(
   'conversations',
   {
     id: text('id').primaryKey(),
-    taskId: text('workspace_id')
+    taskId: text('task_id')
       .notNull()
-      .references(() => workspaces.id, { onDelete: 'cascade' }),
+      .references(() => tasks.id, { onDelete: 'cascade' }),
     title: text('title').notNull(),
     createdAt: text('created_at')
       .notNull()
@@ -65,7 +65,7 @@ export const conversations = sqliteTable(
       .default(sql`CURRENT_TIMESTAMP`),
   },
   (table) => ({
-    taskIdIdx: index('idx_conversations_workspace_id').on(table.taskId),
+    taskIdIdx: index('idx_conversations_task_id').on(table.taskId),
   })
 );
 
@@ -90,21 +90,21 @@ export const messages = sqliteTable(
 );
 
 export const projectsRelations = relations(projects, ({ many }) => ({
-  workspaces: many(workspaces),
+  tasks: many(tasks),
 }));
 
-export const workspacesRelations = relations(workspaces, ({ one, many }) => ({
+export const tasksRelations = relations(tasks, ({ one, many }) => ({
   project: one(projects, {
-    fields: [workspaces.projectId],
+    fields: [tasks.projectId],
     references: [projects.id],
   }),
   conversations: many(conversations),
 }));
 
 export const conversationsRelations = relations(conversations, ({ one, many }) => ({
-  task: one(workspaces, {
+  task: one(tasks, {
     fields: [conversations.taskId],
-    references: [workspaces.id],
+    references: [tasks.id],
   }),
   messages: many(messages),
 }));
@@ -117,6 +117,6 @@ export const messagesRelations = relations(messages, ({ one }) => ({
 }));
 
 export type ProjectRow = typeof projects.$inferSelect;
-export type WorkspaceRow = typeof workspaces.$inferSelect;
+export type TaskRow = typeof tasks.$inferSelect;
 export type ConversationRow = typeof conversations.$inferSelect;
 export type MessageRow = typeof messages.$inferSelect;
diff --git a/src/main/services/DatabaseService.ts b/src/main/services/DatabaseService.ts
index 6919d486..dc02bbd9 100644
--- a/src/main/services/DatabaseService.ts
+++ b/src/main/services/DatabaseService.ts
@@ -5,11 +5,11 @@ import { resolveDatabasePath, resolveMigrationsPath } from '../db/path';
 import { getDrizzleClient } from '../db/drizzleClient';
 import {
   projects as projectsTable,
-  workspaces as workspacesTable,
+  tasks as tasksTable,
   conversations as conversationsTable,
   messages as messagesTable,
   type ProjectRow,
-  type WorkspaceRow,
+  type TaskRow,
   type ConversationRow,
   type MessageRow,
 } from '../db/schema';
@@ -217,7 +217,7 @@ export class DatabaseService {
           : null;
     const { db } = await getDrizzleClient();
     await db
-      .insert(workspacesTable)
+      .insert(tasksTable)
       .values({
         id: task.id,
         projectId: task.projectId,
@@ -230,7 +230,7 @@ export class DatabaseService {
         updatedAt: sql`CURRENT_TIMESTAMP`,
       })
       .onConflictDoUpdate({
-        target: workspacesTable.id,
+        target: tasksTable.id,
         set: {
           projectId: task.projectId,
           name: task.name,
@@ -248,14 +248,14 @@ export class DatabaseService {
     if (this.disabled) return [];
     const { db } = await getDrizzleClient();
 
-    const rows: WorkspaceRow[] = projectId
+    const rows: TaskRow[] = projectId
       ? await db
           .select()
-          .from(workspacesTable)
-          .where(eq(workspacesTable.projectId, projectId))
-          .orderBy(desc(workspacesTable.updatedAt))
-      : await db.select().from(workspacesTable).orderBy(desc(workspacesTable.updatedAt));
-    return rows.map((row) => this.mapDrizzleWorkspaceRow(row));
+          .from(tasksTable)
+          .where(eq(tasksTable.projectId, projectId))
+          .orderBy(desc(tasksTable.updatedAt))
+      : await db.select().from(tasksTable).orderBy(desc(tasksTable.updatedAt));
+    return rows.map((row) => this.mapDrizzleTaskRow(row));
   }
 
   async deleteProject(projectId: string): Promise<void> {
@@ -267,7 +267,7 @@ export class DatabaseService {
   async deleteTask(taskId: string): Promise<void> {
     if (this.disabled) return;
     const { db } = await getDrizzleClient();
-    await db.delete(workspacesTable).where(eq(workspacesTable.id, taskId));
+    await db.delete(tasksTable).where(eq(tasksTable.id, taskId));
   }
 
   // Conversation management methods
@@ -469,7 +469,7 @@ export class DatabaseService {
     };
   }
 
-  private mapDrizzleWorkspaceRow(row: WorkspaceRow): Workspace {
+  private mapDrizzleTaskRow(row: TaskRow): Workspace {
     return {
       id: row.id,
       projectId: row.projectId,

From aa4ed2568410d08963ae15db0acc41a9e5a1f532 Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Mon, 15 Dec 2025 16:27:23 -0800
Subject: [PATCH 17/35] refactor: rename workspace internal variables and
 functions to task

- Rename WorkspaceSnapshot to TaskSnapshot
- Rename workspaceStates/workspaceListeners to taskStates/taskListeners
- Rename ensureWorkspaceState/updateWorkspaceState to ensureTaskState/updateTaskState
- Rename subscribeToWorkspaceRunState to subscribeToTaskRunState
- Rename refreshWorkspaceRunState to refreshTaskRunState
- Rename watchWorkspacePty/Containers/Activity to watchTaskPty/Containers/Activity
- Update comments and internal variable names
---
 src/renderer/lib/containerRuns.ts       | 56 ++++++++++++-------------
 src/renderer/lib/quickPreview.ts        |  4 +-
 src/renderer/lib/taskStatus.ts          | 44 +++++++++----------
 src/renderer/lib/taskTerminalsStore.ts  | 48 ++++++++++-----------
 src/test/renderer/containerRuns.test.ts |  6 +--
 5 files changed, 79 insertions(+), 79 deletions(-)

diff --git a/src/renderer/lib/containerRuns.ts b/src/renderer/lib/containerRuns.ts
index 0efe4774..526ef38f 100644
--- a/src/renderer/lib/containerRuns.ts
+++ b/src/renderer/lib/containerRuns.ts
@@ -12,7 +12,7 @@ import type { RunnerPortMapping } from '@shared/container';
 import { log } from './logger';
 
 type Listener = (event: RunnerEvent) => void;
-type WorkspaceListener = (state: ContainerRunState) => void;
+type TaskListener = (state: ContainerRunState) => void;
 
 interface StartRunArgs {
   taskId: string;
@@ -22,8 +22,8 @@ interface StartRunArgs {
 }
 
 const listeners = new Set<Listener>();
-const workspaceListeners = new Map<string, Set<WorkspaceListener>>();
-const workspaceStates = new Map<string, ContainerRunState>();
+const taskListeners = new Map<string, Set<TaskListener>>();
+const taskStates = new Map<string, ContainerRunState>();
 let subscribed = false;
 let unsubscribe: (() => void) | undefined;
 
@@ -34,7 +34,7 @@ function clean(value: string | undefined | null): string | undefined {
 }
 
 function getOrCreateState(taskId: string): ContainerRunState {
-  const existing = workspaceStates.get(taskId);
+  const existing = taskStates.get(taskId);
   if (existing) return existing;
   const created: ContainerRunState = {
     taskId,
@@ -47,7 +47,7 @@ function getOrCreateState(taskId: string): ContainerRunState {
     lastUpdatedAt: 0,
     lastError: null,
   };
-  workspaceStates.set(taskId, created);
+  taskStates.set(taskId, created);
   return created;
 }
 
@@ -56,7 +56,7 @@ function clonePort(port: RunnerPortMapping): RunnerPortMapping & { url: string }
   return { ...port, url };
 }
 
-function updateWorkspaceState(event: RunnerEvent) {
+function updateTaskState(event: RunnerEvent) {
   const state = getOrCreateState(event.taskId);
   const isNewRun = state.runId && state.runId !== event.runId;
   if (!state.runId || isNewRun) {
@@ -125,11 +125,11 @@ function updateWorkspaceState(event: RunnerEvent) {
       break;
   }
   state.lastUpdatedAt = event.ts;
-  workspaceStates.set(event.taskId, { ...state });
+  taskStates.set(event.taskId, { ...state });
 
-  const wsListeners = workspaceListeners.get(event.taskId);
-  if (wsListeners) {
-    for (const listener of wsListeners) {
+  const taskListenersForTask = taskListeners.get(event.taskId);
+  if (taskListenersForTask) {
+    for (const listener of taskListenersForTask) {
       try {
         listener({ ...state });
       } catch (error) {
@@ -148,7 +148,7 @@ function ensureSubscribed() {
     unsubscribe = api.onRunEvent((event: RunnerEvent) => {
       log.info('[containers] runner event', event);
       try {
-        updateWorkspaceState(event);
+        updateTaskState(event);
       } catch (error) {
         log.error('[containers] failed to update task state', error);
       }
@@ -175,15 +175,15 @@ export function subscribeToContainerRuns(listener: Listener): () => void {
   };
 }
 
-export function subscribeToWorkspaceRunState(
+export function subscribeToTaskRunState(
   taskId: string,
-  listener: WorkspaceListener
+  listener: TaskListener
 ): () => void {
   ensureSubscribed();
-  const set = workspaceListeners.get(taskId) ?? new Set<WorkspaceListener>();
+  const set = taskListeners.get(taskId) ?? new Set<TaskListener>();
   set.add(listener);
-  workspaceListeners.set(taskId, set);
-  const current = workspaceStates.get(taskId);
+  taskListeners.set(taskId, set);
+  const current = taskStates.get(taskId);
   if (current) {
     try {
       listener({ ...current });
@@ -193,17 +193,17 @@ export function subscribeToWorkspaceRunState(
   }
 
   return () => {
-    const listenersForWorkspace = workspaceListeners.get(taskId);
-    if (!listenersForWorkspace) return;
-    listenersForWorkspace.delete(listener);
-    if (listenersForWorkspace.size === 0) {
-      workspaceListeners.delete(taskId);
+    const listenersForTask = taskListeners.get(taskId);
+    if (!listenersForTask) return;
+    listenersForTask.delete(listener);
+    if (listenersForTask.size === 0) {
+      taskListeners.delete(taskId);
     }
   };
 }
 
 export function getContainerRunState(taskId: string): ContainerRunState | undefined {
-  const state = workspaceStates.get(taskId);
+  const state = taskStates.get(taskId);
   return state ? { ...state } : undefined;
 }
 
@@ -252,14 +252,14 @@ export function resetContainerRunListeners() {
     } catch {}
   }
   listeners.clear();
-  workspaceListeners.clear();
-  workspaceStates.clear();
+  taskListeners.clear();
+  taskStates.clear();
   subscribed = false;
   unsubscribe = undefined;
 }
 
 export function getAllRunStates(): ContainerRunState[] {
-  return Array.from(workspaceStates.values()).map((s) => ({ ...s }));
+  return Array.from(taskStates.values()).map((s) => ({ ...s }));
 }
 
 export function subscribeToAllRunStates(
@@ -283,7 +283,7 @@ export function subscribeToAllRunStates(
  * Inspect any existing compose stack for this task and hydrate local state,
  * so UI shows ports/running status after a window refresh.
  */
-export async function refreshWorkspaceRunState(taskId: string) {
+export async function refreshTaskRunState(taskId: string) {
   ensureSubscribed();
   const api = (window as any).electronAPI;
   if (!api?.inspectContainerRun) return;
@@ -306,7 +306,7 @@ export async function refreshWorkspaceRunState(taskId: string) {
           url: `http://localhost:${p.host}`,
         })),
       } as any;
-      updateWorkspaceState(portsEvent);
+      updateTaskState(portsEvent);
       const lifecycleEvent: RunnerEvent = {
         ts: now,
         taskId,
@@ -315,7 +315,7 @@ export async function refreshWorkspaceRunState(taskId: string) {
         type: 'lifecycle',
         status: 'ready',
       } as any;
-      updateWorkspaceState(lifecycleEvent);
+      updateTaskState(lifecycleEvent);
     }
   } catch (error) {
     log.warn?.('[containers] refresh run state failed', error);
diff --git a/src/renderer/lib/quickPreview.ts b/src/renderer/lib/quickPreview.ts
index 461c7f15..41f236a4 100644
--- a/src/renderer/lib/quickPreview.ts
+++ b/src/renderer/lib/quickPreview.ts
@@ -1,6 +1,6 @@
 import {
   startContainerRun,
-  subscribeToWorkspaceRunState,
+  subscribeToTaskRunState,
   getContainerRunState,
 } from '@/lib/containerRuns';
 
@@ -59,7 +59,7 @@ export async function quickStartPreview(args: {
     // Subscribe for preview becoming ready
     const unsubRef: { current: null | (() => void) } = { current: null };
     await new Promise<void>((resolve) => {
-      unsubRef.current = subscribeToWorkspaceRunState(taskId, (state) => {
+      unsubRef.current = subscribeToTaskRunState(taskId, (state) => {
         if (state.previewUrl) {
           onPreviewUrl?.(state.previewUrl);
           resolve();
diff --git a/src/renderer/lib/taskStatus.ts b/src/renderer/lib/taskStatus.ts
index 58b95565..5101537e 100644
--- a/src/renderer/lib/taskStatus.ts
+++ b/src/renderer/lib/taskStatus.ts
@@ -1,15 +1,15 @@
-// Lightweight derived status store for workspaces based on agent activity
-// - Derives 'busy' when we receive stream output for a task (workspace)
+// Lightweight derived status store for tasks based on agent activity
+// - Derives 'busy' when we receive stream output for a task
 // - Derives 'idle' after a short inactivity window or when a 'complete' event fires
 
 type Derived = 'idle' | 'busy';
-import { subscribeToWorkspaceRunState } from './containerRuns';
+import { subscribeToTaskRunState } from './containerRuns';
 import { activityStore } from './activityStore';
 
 type Listener = (status: Derived) => void;
 
-const statusByWorkspace = new Map<string, Derived>();
-const listenersByWorkspace = new Map<string, Set<Listener>>();
+const statusByTask = new Map<string, Derived>();
+const listenersByTask = new Map<string, Set<Listener>>();
 const lastActivity = new Map<string, number>();
 
 // Inactivity delay before flipping back to idle
@@ -21,20 +21,20 @@ function ensureTicker() {
   tickStarted = true;
   setInterval(() => {
     const now = Date.now();
-    for (const [wid, ts] of lastActivity.entries()) {
-      const cur = statusByWorkspace.get(wid) || 'idle';
+    for (const [tid, ts] of lastActivity.entries()) {
+      const cur = statusByTask.get(tid) || 'idle';
       if (cur === 'busy' && now - ts > IDLE_AFTER_MS) {
-        setStatusInternal(wid, 'idle');
+        setStatusInternal(tid, 'idle');
       }
     }
   }, 2_000);
 }
 
 function setStatusInternal(taskId: string, next: Derived) {
-  const prev = statusByWorkspace.get(taskId) || 'idle';
+  const prev = statusByTask.get(taskId) || 'idle';
   if (prev === next) return;
-  statusByWorkspace.set(taskId, next);
-  const ls = listenersByWorkspace.get(taskId);
+  statusByTask.set(taskId, next);
+  const ls = listenersByTask.get(taskId);
   if (ls)
     for (const fn of Array.from(ls)) {
       try {
@@ -55,15 +55,15 @@ function wireGlobal() {
 
 export function getDerivedStatus(taskId: string): Derived {
   wireGlobal();
-  return statusByWorkspace.get(taskId) || 'idle';
+  return statusByTask.get(taskId) || 'idle';
 }
 
 export function subscribeDerivedStatus(taskId: string, listener: Listener): () => void {
   wireGlobal();
-  let set = listenersByWorkspace.get(taskId);
+  let set = listenersByTask.get(taskId);
   if (!set) {
     set = new Set<Listener>();
-    listenersByWorkspace.set(taskId, set);
+    listenersByTask.set(taskId, set);
   }
   set.add(listener);
   // Emit current immediately
@@ -71,18 +71,18 @@ export function subscribeDerivedStatus(taskId: string, listener: Listener): () =
     listener(getDerivedStatus(taskId));
   } catch {}
   return () => {
-    const set2 = listenersByWorkspace.get(taskId);
+    const set2 = listenersByTask.get(taskId);
     if (!set2) return;
     set2.delete(listener);
-    if (set2.size === 0) listenersByWorkspace.delete(taskId);
+    if (set2.size === 0) listenersByTask.delete(taskId);
   };
 }
 
 // Observe PTY activity (all current providers emit via PTY).
-// Call once per workspace to ensure terminal output marks the workspace busy.
+// Call once per task to ensure terminal output marks the task busy.
 // Kept as a separate watcher so future non‑PTY providers can remain decoupled.
 const ptyUnsubs = new Map<string, () => void>();
-export function watchWorkspacePty(taskId: string): () => void {
+export function watchTaskPty(taskId: string): () => void {
   wireGlobal();
   if (ptyUnsubs.has(taskId)) return ptyUnsubs.get(taskId)!;
   const api: any = (window as any).electronAPI;
@@ -124,10 +124,10 @@ export function watchWorkspacePty(taskId: string): () => void {
   return cleanup;
 }
 
-// Container runs also imply workspace activity (build/start/ready)
-export function watchWorkspaceContainers(taskId: string): () => void {
+// Container runs also imply task activity (build/start/ready)
+export function watchTaskContainers(taskId: string): () => void {
   wireGlobal();
-  const off = subscribeToWorkspaceRunState(taskId, (state) => {
+  const off = subscribeToTaskRunState(taskId, (state) => {
     const s = String(state?.status || 'idle');
     const active = /^(starting|building|running|ready)$/i.test(s);
     lastActivity.set(taskId, Date.now());
@@ -139,7 +139,7 @@ export function watchWorkspaceContainers(taskId: string): () => void {
 // Align with the app's activity indicator (left sidebar).
 // Subscribes to the shared activityStore which understands provider-specific PTY IDs
 // and classifies chunks as busy/idle with debouncing.
-export function watchWorkspaceActivity(taskId: string): () => void {
+export function watchTaskActivity(taskId: string): () => void {
   wireGlobal();
   const off = activityStore.subscribe(taskId, (isBusy) => {
     lastActivity.set(taskId, Date.now());
diff --git a/src/renderer/lib/taskTerminalsStore.ts b/src/renderer/lib/taskTerminalsStore.ts
index a05decda..fe10e9ba 100644
--- a/src/renderer/lib/taskTerminalsStore.ts
+++ b/src/renderer/lib/taskTerminalsStore.ts
@@ -14,18 +14,18 @@ type TaskTerminalsState = {
   counter: number;
 };
 
-type WorkspaceSnapshot = {
+type TaskSnapshot = {
   terminals: TaskTerminal[];
   activeTerminalId: string | null;
 };
 
 const STORAGE_PREFIX = 'emdash:workspaceTerminals:v1';
 
-const workspaceStates = new Map<string, TaskTerminalsState>();
-const workspaceListeners = new Map<string, Set<() => void>>();
-const taskSnapshots = new Map<string, WorkspaceSnapshot>();
+const taskStates = new Map<string, TaskTerminalsState>();
+const taskListeners = new Map<string, Set<() => void>>();
+const taskSnapshots = new Map<string, TaskSnapshot>();
 
-const EMPTY_SNAPSHOT: WorkspaceSnapshot = {
+const EMPTY_SNAPSHOT: TaskSnapshot = {
   terminals: [],
   activeTerminalId: null,
 };
@@ -158,24 +158,24 @@ function ensureSnapshot(taskId: string, state: TaskTerminalsState) {
   return taskSnapshots.get(taskId)!;
 }
 
-function ensureWorkspaceState(
+function ensureTaskState(
   taskId: string,
   taskPath?: string
 ): TaskTerminalsState {
-  let state = workspaceStates.get(taskId);
+  let state = taskStates.get(taskId);
   if (state) {
     ensureSnapshot(taskId, state);
     return state;
   }
 
   state = loadFromStorage(taskId) ?? createDefaultState(taskId, taskPath);
-  workspaceStates.set(taskId, state);
+  taskStates.set(taskId, state);
   ensureSnapshot(taskId, state);
   return state;
 }
 
 function emit(taskId: string) {
-  const listeners = workspaceListeners.get(taskId);
+  const listeners = taskListeners.get(taskId);
   if (!listeners) return;
   for (const listener of listeners) {
     try {
@@ -186,18 +186,18 @@ function emit(taskId: string) {
   }
 }
 
-function updateWorkspaceState(
+function updateTaskState(
   taskId: string,
   taskPath: string | undefined,
   mutate: (draft: TaskTerminalsState) => void
 ) {
-  const current = ensureWorkspaceState(taskId, taskPath);
+  const current = ensureTaskState(taskId, taskPath);
   const draft = cloneState(current);
   mutate(draft);
   // Ensure state remains valid
   if (!draft.terminals.length) {
     const fallback = createDefaultState(taskId, taskPath);
-    workspaceStates.set(taskId, fallback);
+    taskStates.set(taskId, fallback);
     ensureSnapshot(taskId, fallback);
     saveToStorage(taskId, fallback);
     emit(taskId);
@@ -207,15 +207,15 @@ function updateWorkspaceState(
     draft.activeId = draft.terminals[0].id;
   }
   draft.counter = Math.max(draft.counter, draft.terminals.length);
-  workspaceStates.set(taskId, draft);
+  taskStates.set(taskId, draft);
   ensureSnapshot(taskId, draft);
   saveToStorage(taskId, draft);
   emit(taskId);
 }
 
-function getSnapshot(taskId: string | null, taskPath?: string): WorkspaceSnapshot {
+function getSnapshot(taskId: string | null, taskPath?: string): TaskSnapshot {
   if (!taskId) return EMPTY_SNAPSHOT;
-  const state = ensureWorkspaceState(taskId, taskPath);
+  const state = ensureTaskState(taskId, taskPath);
   return ensureSnapshot(taskId, state);
 }
 
@@ -227,25 +227,25 @@ function subscribe(
   if (!taskId) {
     return () => undefined;
   }
-  ensureWorkspaceState(taskId, taskPath);
-  let set = workspaceListeners.get(taskId);
+  ensureTaskState(taskId, taskPath);
+  let set = taskListeners.get(taskId);
   if (!set) {
     set = new Set();
-    workspaceListeners.set(taskId, set);
+    taskListeners.set(taskId, set);
   }
   set.add(listener);
   return () => {
-    const listeners = workspaceListeners.get(taskId);
+    const listeners = taskListeners.get(taskId);
     if (!listeners) return;
     listeners.delete(listener);
     if (listeners.size === 0) {
-      workspaceListeners.delete(taskId);
+      taskListeners.delete(taskId);
     }
   };
 }
 
 function createTerminal(taskId: string, taskPath?: string) {
-  updateWorkspaceState(taskId, taskPath, (draft) => {
+  updateTaskState(taskId, taskPath, (draft) => {
     const nextIndex = draft.counter + 1;
     const id = makeTerminalId(taskId);
     draft.counter = nextIndex;
@@ -263,7 +263,7 @@ function createTerminal(taskId: string, taskPath?: string) {
 }
 
 function setActive(taskId: string, terminalId: string, taskPath?: string) {
-  updateWorkspaceState(taskId, taskPath, (draft) => {
+  updateTaskState(taskId, taskPath, (draft) => {
     if (draft.terminals.some((terminal) => terminal.id === terminalId)) {
       draft.activeId = terminalId;
     }
@@ -271,14 +271,14 @@ function setActive(taskId: string, terminalId: string, taskPath?: string) {
 }
 
 function closeTerminal(taskId: string, terminalId: string, taskPath?: string) {
-  const state = ensureWorkspaceState(taskId, taskPath);
+  const state = ensureTaskState(taskId, taskPath);
   if (state.terminals.length <= 1) {
     return;
   }
   const exists = state.terminals.some((terminal) => terminal.id === terminalId);
   if (!exists) return;
 
-  updateWorkspaceState(taskId, taskPath, (draft) => {
+  updateTaskState(taskId, taskPath, (draft) => {
     const idx = draft.terminals.findIndex((terminal) => terminal.id === terminalId);
     draft.terminals = draft.terminals.filter((terminal) => terminal.id !== terminalId);
     if (draft.activeId === terminalId) {
diff --git a/src/test/renderer/containerRuns.test.ts b/src/test/renderer/containerRuns.test.ts
index 8616c4f6..c365b599 100644
--- a/src/test/renderer/containerRuns.test.ts
+++ b/src/test/renderer/containerRuns.test.ts
@@ -49,7 +49,7 @@ vi.mock('../../renderer/lib/logger', () => ({
 import {
   startContainerRun,
   subscribeToContainerRuns,
-  subscribeToWorkspaceRunState,
+  subscribeToTaskRunState,
   getContainerRunState,
   resetContainerRunListeners,
 } from '../../renderer/lib/containerRuns';
@@ -100,9 +100,9 @@ describe('containerRuns renderer bridge', () => {
     unsubscribe();
   });
 
-  it('tracks workspace state and notifies workspace listeners', () => {
+  it('tracks task state and notifies task listeners', () => {
     const updates: Array<{ status: string; previewUrl?: string | undefined }> = [];
-    const unsubscribe = subscribeToWorkspaceRunState('ws-1', (state) =>
+    const unsubscribe = subscribeToTaskRunState('ws-1', (state) =>
       updates.push({ status: state.status, previewUrl: state.previewUrl })
     );
 

From ac76146ac74669b48abd88edb51f3c7bf92f664d Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Mon, 15 Dec 2025 16:27:41 -0800
Subject: [PATCH 18/35] refactor: rename workspace refs to task in renderer
 components

- Rename prevWorkspaceIdRef/lastWorkspaceUrlRef to prevTaskIdRef/lastTaskUrlRef
- Rename isWorkspaceMultiAgent prop to isTaskMultiAgent
- Update imports to use renamed functions
- Update comments and telemetry events (workspace_created -> task_created)
---
 src/renderer/App.tsx                          | 20 +++++------
 src/renderer/components/BrowserPane.tsx       | 36 +++++++++----------
 src/renderer/components/ChatInterface.tsx     |  4 +--
 src/renderer/components/ProjectMainView.tsx   |  6 ++--
 .../components/kanban/KanbanBoard.tsx         | 12 +++----
 src/renderer/components/titlebar/Titlebar.tsx |  6 ++--
 6 files changed, 42 insertions(+), 42 deletions(-)

diff --git a/src/renderer/App.tsx b/src/renderer/App.tsx
index df2ca91e..efc4184a 100644
--- a/src/renderer/App.tsx
+++ b/src/renderer/App.tsx
@@ -827,7 +827,7 @@ const AppContent: React.FC = () => {
 
       let newTask: Task;
       if (isMultiAgent) {
-        // Multi-agent workspace: create worktrees for each provider×runs combo
+        // Multi-agent task: create worktrees for each provider×runs combo
         const variants: Array<{
           id: string;
           provider: Provider;
@@ -1109,20 +1109,20 @@ const AppContent: React.FC = () => {
             : null
         );
 
-        // Track workspace creation
+        // Track task creation
         const { captureTelemetry } = await import('./lib/telemetryClient');
         const isMultiAgent = (newTask.metadata as any)?.multiAgent?.enabled;
-        captureTelemetry('workspace_created', {
+        captureTelemetry('task_created', {
           provider: isMultiAgent ? 'multi' : (newTask.agentId as string) || 'codex',
           has_initial_prompt: !!taskMetadata?.initialPrompt,
         });
 
-        // Set the active workspace and its provider (none if multi-agent)
+        // Set the active task and its provider (none if multi-agent)
         setActiveTask(newTask);
         if ((newTask.metadata as any)?.multiAgent?.enabled) {
           setActiveTaskProvider(null);
         } else {
-          // Use the saved agentId from the workspace, which should match primaryProvider
+          // Use the saved agentId from the task, which should match primaryProvider
           setActiveTaskProvider(
             (newTask.agentId as Provider) || primaryProvider || 'codex'
           );
@@ -1159,7 +1159,7 @@ const AppContent: React.FC = () => {
     if ((task.metadata as any)?.multiAgent?.enabled) {
       setActiveTaskProvider(null);
     } else {
-      // Use agentId from workspace if available, otherwise fall back to 'codex' for backwards compatibility
+      // Use agentId from task if available, otherwise fall back to 'codex' for backwards compatibility
       setActiveTaskProvider((task.agentId as Provider) || 'codex');
     }
   };
@@ -1285,9 +1285,9 @@ const AppContent: React.FC = () => {
           throw new Error(errorMsg);
         }
 
-        // Track workspace deletion
+        // Track task deletion
         const { captureTelemetry } = await import('./lib/telemetryClient');
-        captureTelemetry('workspace_deleted');
+        captureTelemetry('task_deleted');
 
         if (!options?.silent) {
           toast({
@@ -1330,7 +1330,7 @@ const AppContent: React.FC = () => {
             }
           }
         } catch (refreshError) {
-          log.error('Failed to refresh workspaces after delete failure:', refreshError as any);
+          log.error('Failed to refresh tasks after delete failure:', refreshError as any);
 
           setProjects((prev) =>
             prev.map((project) => {
@@ -1664,7 +1664,7 @@ const AppContent: React.FC = () => {
               taskId={activeTask?.id || null}
               taskPath={activeTask?.path || null}
               projectPath={selectedProject?.path || null}
-              isWorkspaceMultiAgent={Boolean(activeTask?.metadata?.multiAgent?.enabled)}
+              isTaskMultiAgent={Boolean(activeTask?.metadata?.multiAgent?.enabled)}
               githubUser={user}
               onToggleKanban={handleToggleKanban}
               isKanbanOpen={Boolean(showKanban)}
diff --git a/src/renderer/components/BrowserPane.tsx b/src/renderer/components/BrowserPane.tsx
index b147753c..9f5f2179 100644
--- a/src/renderer/components/BrowserPane.tsx
+++ b/src/renderer/components/BrowserPane.tsx
@@ -65,10 +65,10 @@ const BrowserPane: React.FC<{
     if (typeof url === 'string') setAddress(url);
   }, [url]);
 
-  const prevWorkspaceIdRef = React.useRef<string | null>(null);
-  const lastWorkspaceUrlRef = React.useRef<string | null>(null);
+  const prevTaskIdRef = React.useRef<string | null>(null);
+  const lastTaskUrlRef = React.useRef<string | null>(null);
   React.useEffect(() => {
-    const prev = prevWorkspaceIdRef.current;
+    const prev = prevTaskIdRef.current;
     const cur = (taskId || '').trim() || null;
 
     if (prev && cur && prev !== cur) {
@@ -77,8 +77,8 @@ const BrowserPane: React.FC<{
         (window as any).electronAPI?.browserClear?.();
         (window as any).electronAPI?.browserHide?.();
         setRunning(prev, false);
-        // Reset workspace URL tracking to force reload
-        lastWorkspaceUrlRef.current = null;
+        // Reset task URL tracking to force reload
+        lastTaskUrlRef.current = null;
       } catch {}
     }
 
@@ -96,7 +96,7 @@ const BrowserPane: React.FC<{
       } catch {}
     }
 
-    prevWorkspaceIdRef.current = cur;
+    prevTaskIdRef.current = cur;
   }, [taskId, clearUrl, hideSpinner]);
 
   React.useEffect(() => {
@@ -315,21 +315,21 @@ const BrowserPane: React.FC<{
   }, [isOpen, url]);
 
   const lastUrlRef = React.useRef<string | null>(null);
-  const lastWorkspaceIdRef = React.useRef<string | null | undefined>(null);
+  const lastTaskIdRef2 = React.useRef<string | null | undefined>(null);
   React.useEffect(() => {
-    if (taskId !== lastWorkspaceIdRef.current) {
+    if (taskId !== lastTaskIdRef2.current) {
       lastUrlRef.current = null;
-      lastWorkspaceIdRef.current = taskId || null;
-      lastWorkspaceUrlRef.current = null;
+      lastTaskIdRef2.current = taskId || null;
+      lastTaskUrlRef.current = null;
     }
 
     if (isOpen && url && !overlayActive && !overlayRaised && taskId) {
-      const workspaceUrlKey = `${taskId}:${url}`;
-      // Force reload if workspace changed or URL changed
-      const isWorkspaceChange = lastWorkspaceUrlRef.current === null;
-      if (lastWorkspaceUrlRef.current !== workspaceUrlKey || lastUrlRef.current !== url) {
+      const taskUrlKey = `${taskId}:${url}`;
+      // Force reload if task changed or URL changed
+      const isTaskChange = lastTaskUrlRef.current === null;
+      if (lastTaskUrlRef.current !== taskUrlKey || lastUrlRef.current !== url) {
         lastUrlRef.current = url;
-        lastWorkspaceUrlRef.current = workspaceUrlKey;
+        lastTaskUrlRef.current = taskUrlKey;
 
         try {
           (window as any).electronAPI?.browserClear?.();
@@ -337,8 +337,8 @@ const BrowserPane: React.FC<{
 
         const timeoutId = setTimeout(() => {
           try {
-            // Force reload when workspace changes to ensure fresh content
-            (window as any).electronAPI?.browserLoadURL?.(url, isWorkspaceChange);
+            // Force reload when task changes to ensure fresh content
+            (window as any).electronAPI?.browserLoadURL?.(url, isTaskChange);
           } catch {}
         }, URL_LOAD_DELAY_MS);
         return () => clearTimeout(timeoutId);
@@ -530,7 +530,7 @@ const BrowserPane: React.FC<{
         </div>
         {!busy && url && lines.length > 0 && (
           <div className="flex flex-shrink-0 items-center gap-2 border-b border-border bg-muted/30 px-2 py-1 text-xs">
-            <span className="font-medium">Workspace Preview</span>
+            <span className="font-medium">Task Preview</span>
             <div className="ml-auto inline-flex items-center gap-2 text-muted-foreground">
               {lines.length ? (
                 <span className="max-w-[360px] truncate">{lines[lines.length - 1]}</span>
diff --git a/src/renderer/components/ChatInterface.tsx b/src/renderer/components/ChatInterface.tsx
index dbe87dd1..4f4a8611 100644
--- a/src/renderer/components/ChatInterface.tsx
+++ b/src/renderer/components/ChatInterface.tsx
@@ -17,7 +17,7 @@ import { type Provider } from '../types';
 import { Task } from '../types/chat';
 import {
   getContainerRunState,
-  subscribeToWorkspaceRunState,
+  subscribeToTaskRunState,
   type ContainerRunState,
 } from '@/lib/containerRuns';
 import { useBrowser } from '@/providers/BrowserProvider';
@@ -461,7 +461,7 @@ const ChatInterface: React.FC<Props> = ({
   }, [provider, task.id]);
 
   useEffect(() => {
-    const off = subscribeToWorkspaceRunState(task.id, (state) => {
+    const off = subscribeToTaskRunState(task.id, (state) => {
       setContainerState(state);
     });
     return () => {
diff --git a/src/renderer/components/ProjectMainView.tsx b/src/renderer/components/ProjectMainView.tsx
index 83040b09..0471987b 100644
--- a/src/renderer/components/ProjectMainView.tsx
+++ b/src/renderer/components/ProjectMainView.tsx
@@ -31,7 +31,7 @@ import DeletePrNotice from './DeletePrNotice';
 import {
   getContainerRunState,
   startContainerRun,
-  subscribeToWorkspaceRunState,
+  subscribeToTaskRunState,
   type ContainerRunState,
 } from '@/lib/containerRuns';
 import { activityStore } from '../lib/activityStore';
@@ -126,7 +126,7 @@ function WorkspaceRow({
   }, [ws.id]);
 
   useEffect(() => {
-    const off = subscribeToWorkspaceRunState(ws.id, (state) => setContainerState(state));
+    const off = subscribeToTaskRunState(ws.id, (state) => setContainerState(state));
     return () => {
       off?.();
     };
@@ -137,7 +137,7 @@ function WorkspaceRow({
     (async () => {
       try {
         const mod = await import('@/lib/containerRuns');
-        await mod.refreshWorkspaceRunState(ws.id);
+        await mod.refreshTaskRunState(ws.id);
       } catch {}
     })();
   }, [ws.id]);
diff --git a/src/renderer/components/kanban/KanbanBoard.tsx b/src/renderer/components/kanban/KanbanBoard.tsx
index 1fb35973..098102d8 100644
--- a/src/renderer/components/kanban/KanbanBoard.tsx
+++ b/src/renderer/components/kanban/KanbanBoard.tsx
@@ -7,9 +7,9 @@ import { Inbox, Plus } from 'lucide-react';
 import { getAll, setStatus, type KanbanStatus } from '../../lib/kanbanStore';
 import {
   subscribeDerivedStatus,
-  watchWorkspacePty,
-  watchWorkspaceContainers,
-  watchWorkspaceActivity,
+  watchTaskPty,
+  watchTaskContainers,
+  watchTaskActivity,
 } from '../../lib/taskStatus';
 import { activityStore } from '../../lib/activityStore';
 
@@ -38,11 +38,11 @@ const KanbanBoard: React.FC<{
     const wsList = project.tasks || [];
     for (const ws of wsList) {
       // Watch PTY output to capture terminal-based providers as activity
-      offs.push(watchWorkspacePty(ws.id));
+      offs.push(watchTaskPty(ws.id));
       // Watch container run state as another activity source (build/start/ready)
-      offs.push(watchWorkspaceContainers(ws.id));
+      offs.push(watchTaskContainers(ws.id));
       // Watch app-wide activity classification (matches left sidebar spinner)
-      offs.push(watchWorkspaceActivity(ws.id));
+      offs.push(watchTaskActivity(ws.id));
       const off = subscribeDerivedStatus(ws.id, (derived) => {
         if (derived !== 'busy') return;
         setStatusMap((prev) => {
diff --git a/src/renderer/components/titlebar/Titlebar.tsx b/src/renderer/components/titlebar/Titlebar.tsx
index a22ac854..3436ca7d 100644
--- a/src/renderer/components/titlebar/Titlebar.tsx
+++ b/src/renderer/components/titlebar/Titlebar.tsx
@@ -24,7 +24,7 @@ interface TitlebarProps {
   taskId?: string | null;
   taskPath?: string | null;
   projectPath?: string | null;
-  isWorkspaceMultiAgent?: boolean;
+  isTaskMultiAgent?: boolean;
   onToggleKanban?: () => void;
   isKanbanOpen?: boolean;
   kanbanAvailable?: boolean;
@@ -39,7 +39,7 @@ const Titlebar: React.FC<TitlebarProps> = ({
   taskId,
   taskPath,
   projectPath,
-  isWorkspaceMultiAgent,
+  isTaskMultiAgent,
   onToggleKanban,
   isKanbanOpen = false,
   kanbanAvailable = false,
@@ -139,7 +139,7 @@ const Titlebar: React.FC<TitlebarProps> = ({
               </Tooltip>
             </TooltipProvider>
           ) : null}
-          {taskId && !isWorkspaceMultiAgent ? (
+          {taskId && !isTaskMultiAgent ? (
             <BrowserToggleButton
               defaultUrl={defaultPreviewUrl || undefined}
               taskId={taskId}

From 86f45d67dad5f89b2edf285d0babb90c2eb28fc7 Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Mon, 15 Dec 2025 16:44:31 -0800
Subject: [PATCH 19/35] refactor: rename workspace types and functions to task
 in main process

- Rename Workspace interface to Task in DatabaseService.ts
- Rename loadWorkspaceContainerConfig to loadTaskContainerConfig
- Rename inferPackageManagerForWorkspace to inferPackageManagerForTask
- Rename resolveWorkspacePath to resolveTaskPath in containerIpc.ts
- Rename parseWorkspaceMetadata to parseTaskMetadata
---
 src/main/ipc/containerIpc.ts                |  8 ++++----
 src/main/services/DatabaseService.ts        | 14 +++++++-------
 src/main/services/containerConfigService.ts |  4 ++--
 src/main/services/containerRunnerService.ts |  4 ++--
 4 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/src/main/ipc/containerIpc.ts b/src/main/ipc/containerIpc.ts
index 49acb9e2..330de69c 100644
--- a/src/main/ipc/containerIpc.ts
+++ b/src/main/ipc/containerIpc.ts
@@ -4,7 +4,7 @@ import { log } from '../lib/logger';
 import {
   ContainerConfigLoadError,
   ContainerConfigLoadErrorCode,
-  loadWorkspaceContainerConfig,
+  loadTaskContainerConfig,
 } from '../services/containerConfigService';
 import type { ResolvedContainerConfig } from '@shared/container';
 import {
@@ -63,7 +63,7 @@ export function registerContainerIpc(): void {
   ipcMain.handle(
     'container:load-config',
     async (_event, args): Promise<ContainerConfigIpcResponse> => {
-      const taskPath = resolveWorkspacePath(args);
+      const taskPath = resolveTaskPath(args);
       if (!taskPath) {
         return {
           ok: false,
@@ -77,7 +77,7 @@ export function registerContainerIpc(): void {
       }
 
       try {
-        const result = await loadWorkspaceContainerConfig(taskPath);
+        const result = await loadTaskContainerConfig(taskPath);
         if (result.ok) {
           return {
             ok: true,
@@ -189,7 +189,7 @@ export function registerContainerIpc(): void {
   );
 }
 
-function resolveWorkspacePath(args: unknown): string | null {
+function resolveTaskPath(args: unknown): string | null {
   if (typeof args === 'string') {
     const trimmed = args.trim();
     return trimmed.length > 0 ? trimmed : null;
diff --git a/src/main/services/DatabaseService.ts b/src/main/services/DatabaseService.ts
index dc02bbd9..4b1ca080 100644
--- a/src/main/services/DatabaseService.ts
+++ b/src/main/services/DatabaseService.ts
@@ -32,7 +32,7 @@ export interface Project {
   updatedAt: string;
 }
 
-export interface Workspace {
+export interface Task {
   id: string;
   projectId: string;
   name: string;
@@ -207,7 +207,7 @@ export class DatabaseService {
     return this.getProjectById(projectId);
   }
 
-  async saveTask(task: Omit<Workspace, 'createdAt' | 'updatedAt'>): Promise<void> {
+  async saveTask(task: Omit<Task, 'createdAt' | 'updatedAt'>): Promise<void> {
     if (this.disabled) return;
     const metadataValue =
       typeof task.metadata === 'string'
@@ -244,7 +244,7 @@ export class DatabaseService {
       });
   }
 
-  async getTasks(projectId?: string): Promise<Workspace[]> {
+  async getTasks(projectId?: string): Promise<Task[]> {
     if (this.disabled) return [];
     const { db } = await getDrizzleClient();
 
@@ -469,18 +469,18 @@ export class DatabaseService {
     };
   }
 
-  private mapDrizzleTaskRow(row: TaskRow): Workspace {
+  private mapDrizzleTaskRow(row: TaskRow): Task {
     return {
       id: row.id,
       projectId: row.projectId,
       name: row.name,
       branch: row.branch,
       path: row.path,
-      status: (row.status as Workspace['status']) ?? 'idle',
+      status: (row.status as Task['status']) ?? 'idle',
       agentId: row.agentId ?? null,
       metadata:
         typeof row.metadata === 'string' && row.metadata.length > 0
-          ? this.parseWorkspaceMetadata(row.metadata, row.id)
+          ? this.parseTaskMetadata(row.metadata, row.id)
           : null,
       createdAt: row.createdAt,
       updatedAt: row.updatedAt,
@@ -508,7 +508,7 @@ export class DatabaseService {
     };
   }
 
-  private parseWorkspaceMetadata(serialized: string, taskId: string): any {
+  private parseTaskMetadata(serialized: string, taskId: string): any {
     try {
       return JSON.parse(serialized);
     } catch (error) {
diff --git a/src/main/services/containerConfigService.ts b/src/main/services/containerConfigService.ts
index 05cdcf48..20d0d124 100644
--- a/src/main/services/containerConfigService.ts
+++ b/src/main/services/containerConfigService.ts
@@ -55,7 +55,7 @@ export interface ContainerConfigLoadFailure {
 
 export type ContainerConfigLoadResult = ContainerConfigLoadSuccess | ContainerConfigLoadFailure;
 
-export async function loadWorkspaceContainerConfig(
+export async function loadTaskContainerConfig(
   taskPath: string
 ): Promise<ContainerConfigLoadResult> {
   const configPath = path.join(taskPath, CONFIG_RELATIVE_PATH);
@@ -150,6 +150,6 @@ function parseConfigJson(
   }
 }
 
-export function inferPackageManagerForWorkspace(taskPath: string): PackageManager | undefined {
+export function inferPackageManagerForTask(taskPath: string): PackageManager | undefined {
   return inferPackageManager(taskPath);
 }
diff --git a/src/main/services/containerRunnerService.ts b/src/main/services/containerRunnerService.ts
index 10b61b44..88c51035 100644
--- a/src/main/services/containerRunnerService.ts
+++ b/src/main/services/containerRunnerService.ts
@@ -22,7 +22,7 @@ import { log } from '../lib/logger';
 import {
   ContainerConfigLoadError,
   ContainerConfigLoadResult,
-  loadWorkspaceContainerConfig,
+  loadTaskContainerConfig,
 } from './containerConfigService';
 
 const RUN_EVENT_CHANNEL = 'runner-event';
@@ -897,7 +897,7 @@ export class ContainerRunnerService extends EventEmitter {
   }
 
   private async loadConfig(taskPath: string): Promise<ContainerConfigLoadResult> {
-    return loadWorkspaceContainerConfig(taskPath);
+    return loadTaskContainerConfig(taskPath);
   }
 
   private serializeConfigError(error: ContainerConfigLoadError): ContainerStartError {

From 974a5dbeebc1abdfa3dda4ff54346eec596fd490 Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Mon, 15 Dec 2025 16:44:48 -0800
Subject: [PATCH 20/35] test: update tests for renamed workspace functions

- Update ContainerConfigService tests for loadTaskContainerConfig
- Update ContainerIpc tests for loadTaskContainerConfig
- Update ContainerRunnerService tests for loadTaskContainerConfig
- Rename test helper makeWorkspaceDir to makeTaskDir
---
 src/test/main/ContainerConfigService.test.ts | 30 +++++++++---------
 src/test/main/ContainerIpc.test.ts           | 18 +++++------
 src/test/main/ContainerRunnerService.test.ts | 32 ++++++++++----------
 3 files changed, 40 insertions(+), 40 deletions(-)

diff --git a/src/test/main/ContainerConfigService.test.ts b/src/test/main/ContainerConfigService.test.ts
index 0fe2c021..98931a8d 100644
--- a/src/test/main/ContainerConfigService.test.ts
+++ b/src/test/main/ContainerConfigService.test.ts
@@ -5,12 +5,12 @@ import os from 'node:os';
 
 import {
   ContainerConfigLoadError,
-  loadWorkspaceContainerConfig,
+  loadTaskContainerConfig,
 } from '../../main/services/containerConfigService';
 
 let tempDir: string;
 
-function makeWorkspaceDir(name: string): string {
+function makeTaskDir(name: string): string {
   const dir = path.join(tempDir, name);
   fs.mkdirSync(dir, { recursive: true });
   return dir;
@@ -24,12 +24,12 @@ afterEach(() => {
   fs.rmSync(tempDir, { recursive: true, force: true });
 });
 
-describe('loadWorkspaceContainerConfig', () => {
+describe('loadTaskContainerConfig', () => {
   it('returns defaults when config file is missing', async () => {
-    const workspace = makeWorkspaceDir('missing-config');
-    fs.writeFileSync(path.join(workspace, 'pnpm-lock.yaml'), '', 'utf8');
+    const taskDir = makeTaskDir('missing-config');
+    fs.writeFileSync(path.join(taskDir, 'pnpm-lock.yaml'), '', 'utf8');
 
-    const result = await loadWorkspaceContainerConfig(workspace);
+    const result = await loadTaskContainerConfig(taskDir);
 
     expect(result.ok).toBe(true);
     if (result.ok) {
@@ -45,8 +45,8 @@ describe('loadWorkspaceContainerConfig', () => {
   });
 
   it('parses config file and maintains overrides', async () => {
-    const workspace = makeWorkspaceDir('custom-config');
-    const configDir = path.join(workspace, '.emdash');
+    const taskDir = makeTaskDir('custom-config');
+    const configDir = path.join(taskDir, '.emdash');
     fs.mkdirSync(configDir, { recursive: true });
     fs.writeFileSync(
       path.join(configDir, 'config.json'),
@@ -61,7 +61,7 @@ describe('loadWorkspaceContainerConfig', () => {
       'utf8'
     );
 
-    const result = await loadWorkspaceContainerConfig(workspace);
+    const result = await loadTaskContainerConfig(taskDir);
 
     expect(result.ok).toBe(true);
     if (result.ok) {
@@ -76,8 +76,8 @@ describe('loadWorkspaceContainerConfig', () => {
   });
 
   it('returns validation errors with context when config is invalid', async () => {
-    const workspace = makeWorkspaceDir('invalid-config');
-    const configDir = path.join(workspace, '.emdash');
+    const taskDir = makeTaskDir('invalid-config');
+    const configDir = path.join(taskDir, '.emdash');
     fs.mkdirSync(configDir, { recursive: true });
     fs.writeFileSync(
       path.join(configDir, 'config.json'),
@@ -87,7 +87,7 @@ describe('loadWorkspaceContainerConfig', () => {
       'utf8'
     );
 
-    const result = await loadWorkspaceContainerConfig(workspace);
+    const result = await loadTaskContainerConfig(taskDir);
 
     expect(result.ok).toBe(false);
     if (!result.ok) {
@@ -99,12 +99,12 @@ describe('loadWorkspaceContainerConfig', () => {
   });
 
   it('surfaces invalid JSON errors', async () => {
-    const workspace = makeWorkspaceDir('invalid-json');
-    const configDir = path.join(workspace, '.emdash');
+    const taskDir = makeTaskDir('invalid-json');
+    const configDir = path.join(taskDir, '.emdash');
     fs.mkdirSync(configDir, { recursive: true });
     fs.writeFileSync(path.join(configDir, 'config.json'), '{ invalid', 'utf8');
 
-    const result = await loadWorkspaceContainerConfig(workspace);
+    const result = await loadTaskContainerConfig(taskDir);
 
     expect(result.ok).toBe(false);
     if (!result.ok) {
diff --git a/src/test/main/ContainerIpc.test.ts b/src/test/main/ContainerIpc.test.ts
index 0119adeb..a21b50ff 100644
--- a/src/test/main/ContainerIpc.test.ts
+++ b/src/test/main/ContainerIpc.test.ts
@@ -45,8 +45,8 @@ const {
   };
 });
 
-const { loadWorkspaceContainerConfigMock } = vi.hoisted(() => ({
-  loadWorkspaceContainerConfigMock: vi.fn(),
+const { loadTaskContainerConfigMock } = vi.hoisted(() => ({
+  loadTaskContainerConfigMock: vi.fn(),
 }));
 
 vi.mock('electron', () => ({
@@ -64,7 +64,7 @@ vi.mock('../../main/services/containerConfigService', async () => {
   );
   return {
     ...actual,
-    loadWorkspaceContainerConfig: loadWorkspaceContainerConfigMock,
+    loadTaskContainerConfig: loadTaskContainerConfigMock,
   };
 });
 
@@ -87,7 +87,7 @@ describe('registerContainerIpc', () => {
   beforeEach(() => {
     handlers.clear();
     handleMock.mockClear();
-    loadWorkspaceContainerConfigMock.mockReset();
+    loadTaskContainerConfigMock.mockReset();
     startRunMock.mockReset();
     onRunnerEventMock.mockClear();
     windows.length = 0;
@@ -106,7 +106,7 @@ describe('registerContainerIpc', () => {
           { service: 'api', container: 4000, protocol: 'tcp', preview: false },
         ],
       };
-      loadWorkspaceContainerConfigMock.mockResolvedValue({
+      loadTaskContainerConfigMock.mockResolvedValue({
         ok: true,
         config,
         sourcePath: '/tmp/workspace/.emdash/config.json',
@@ -117,7 +117,7 @@ describe('registerContainerIpc', () => {
 
       const result = await handler({}, { taskPath: '  /tmp/workspace  ' });
 
-      expect(loadWorkspaceContainerConfigMock).toHaveBeenCalledWith('/tmp/workspace');
+      expect(loadTaskContainerConfigMock).toHaveBeenCalledWith('/tmp/workspace');
       expect(result).toEqual({
         ok: true,
         config,
@@ -126,7 +126,7 @@ describe('registerContainerIpc', () => {
     });
 
     it('returns serialized validation error when loader fails', async () => {
-      loadWorkspaceContainerConfigMock.mockResolvedValue({
+      loadTaskContainerConfigMock.mockResolvedValue({
         ok: false,
         error: {
           code: 'VALIDATION_FAILED',
@@ -167,11 +167,11 @@ describe('registerContainerIpc', () => {
           configPath: null,
         },
       });
-      expect(loadWorkspaceContainerConfigMock).not.toHaveBeenCalled();
+      expect(loadTaskContainerConfigMock).not.toHaveBeenCalled();
     });
 
     it('handles unexpected loader errors', async () => {
-      loadWorkspaceContainerConfigMock.mockRejectedValue(new Error('boom'));
+      loadTaskContainerConfigMock.mockRejectedValue(new Error('boom'));
 
       registerContainerIpc();
       const handler = getHandler('container:load-config');
diff --git a/src/test/main/ContainerRunnerService.test.ts b/src/test/main/ContainerRunnerService.test.ts
index e8880e33..0078434f 100644
--- a/src/test/main/ContainerRunnerService.test.ts
+++ b/src/test/main/ContainerRunnerService.test.ts
@@ -2,8 +2,8 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 import type { ResolvedContainerConfig, RunnerEvent } from '@shared/container';
 import { PortAllocationError } from '@shared/container';
 
-const { loadWorkspaceContainerConfigMock } = vi.hoisted(() => ({
-  loadWorkspaceContainerConfigMock: vi.fn(),
+const { loadTaskContainerConfigMock } = vi.hoisted(() => ({
+  loadTaskContainerConfigMock: vi.fn(),
 }));
 
 vi.mock('../../main/services/containerConfigService', async () => {
@@ -12,7 +12,7 @@ vi.mock('../../main/services/containerConfigService', async () => {
   );
   return {
     ...actual,
-    loadWorkspaceContainerConfig: loadWorkspaceContainerConfigMock,
+    loadTaskContainerConfig: loadTaskContainerConfigMock,
   };
 });
 
@@ -23,7 +23,7 @@ import { ContainerConfigLoadError } from '../../main/services/containerConfigSer
 
 describe('ContainerRunnerService', () => {
   beforeEach(() => {
-    loadWorkspaceContainerConfigMock.mockReset();
+    loadTaskContainerConfigMock.mockReset();
   });
 
   it('emits runner events and returns run info on success', async () => {
@@ -37,10 +37,10 @@ describe('ContainerRunnerService', () => {
         { service: 'api', container: 4000, protocol: 'tcp', preview: false },
       ],
     };
-    loadWorkspaceContainerConfigMock.mockResolvedValue({
+    loadTaskContainerConfigMock.mockResolvedValue({
       ok: true,
       config,
-      sourcePath: '/tmp/workspace/.emdash/config.json',
+      sourcePath: '/tmp/task/.emdash/config.json',
     });
 
     const allocateMock = vi.fn(async () => [
@@ -53,8 +53,8 @@ describe('ContainerRunnerService', () => {
     service.onRunnerEvent((event) => events.push(event));
 
     const result = await service.startMockRun({
-      taskId: 'ws-1',
-      taskPath: '/tmp/workspace',
+      taskId: 'task-1',
+      taskPath: '/tmp/task',
       runId: 'run-123',
       now: () => 1700000000000,
     });
@@ -63,7 +63,7 @@ describe('ContainerRunnerService', () => {
       ok: true,
       runId: 'run-123',
       config,
-      sourcePath: '/tmp/workspace/.emdash/config.json',
+      sourcePath: '/tmp/task/.emdash/config.json',
     });
     expect(allocateMock).toHaveBeenCalledWith(config.ports);
     expect(events).toHaveLength(4);
@@ -81,9 +81,9 @@ describe('ContainerRunnerService', () => {
   it('returns config error without emitting events', async () => {
     const error = new ContainerConfigLoadError('VALIDATION_FAILED', 'Invalid config', {
       configKey: 'ports[0]',
-      configPath: '/tmp/workspace/.emdash/config.json',
+      configPath: '/tmp/task/.emdash/config.json',
     });
-    loadWorkspaceContainerConfigMock.mockResolvedValue({
+    loadTaskContainerConfigMock.mockResolvedValue({
       ok: false,
       error,
     });
@@ -97,8 +97,8 @@ describe('ContainerRunnerService', () => {
     service.onRunnerEvent(listener);
 
     const result = await service.startMockRun({
-      taskId: 'ws-1',
-      taskPath: '/tmp/workspace',
+      taskId: 'task-1',
+      taskPath: '/tmp/task',
     });
 
     expect(result).toEqual({
@@ -107,7 +107,7 @@ describe('ContainerRunnerService', () => {
         code: 'VALIDATION_FAILED',
         message: 'Invalid config',
         configKey: 'ports[0]',
-        configPath: '/tmp/workspace/.emdash/config.json',
+        configPath: '/tmp/task/.emdash/config.json',
       },
     });
     expect(listener).not.toHaveBeenCalled();
@@ -121,7 +121,7 @@ describe('ContainerRunnerService', () => {
       workdir: '.',
       ports: [{ service: 'app', container: 3000, protocol: 'tcp', preview: true }],
     };
-    loadWorkspaceContainerConfigMock.mockResolvedValue({
+    loadTaskContainerConfigMock.mockResolvedValue({
       ok: true,
       config,
       sourcePath: null,
@@ -136,7 +136,7 @@ describe('ContainerRunnerService', () => {
     service.onRunnerEvent((event) => events.push(event));
 
     const result = await service.startMockRun({
-      taskId: 'ws-1',
+      taskId: 'task-1',
       taskPath: '/tmp/workspace',
       runId: 'run-err',
       now: () => 1700000000100,

From 81c18983ebc2dca25bfaf60e0dfb90bec3b1573a Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Mon, 15 Dec 2025 16:54:39 -0800
Subject: [PATCH 21/35] refactor: rename workspace telemetry events and
 components to task

---
 src/main/ipc/telemetryIpc.ts                 | 14 ++++++-------
 src/main/main.ts                             |  6 +++---
 src/main/telemetry.ts                        | 22 ++++++++++----------
 src/renderer/components/ChatInterface.tsx    |  2 +-
 src/renderer/components/CommandPalette.tsx   |  4 ++--
 src/renderer/components/MultiAgentTask.tsx   |  2 +-
 src/renderer/components/ProjectMainView.tsx  | 12 +++++------
 src/renderer/components/TaskDeleteButton.tsx |  4 ++--
 src/renderer/components/TaskModal.tsx        | 18 ++++++++--------
 src/renderer/components/TaskPorts.tsx        |  4 ++--
 src/renderer/lib/activityStore.ts            |  2 +-
 11 files changed, 45 insertions(+), 45 deletions(-)

diff --git a/src/main/ipc/telemetryIpc.ts b/src/main/ipc/telemetryIpc.ts
index e4f0b476..e7ae7527 100644
--- a/src/main/ipc/telemetryIpc.ts
+++ b/src/main/ipc/telemetryIpc.ts
@@ -9,7 +9,7 @@ import {
 
 // Events allowed from renderer process
 // Main process-only events (app_started, app_closed, app_window_focused, github_connection_triggered,
-// github_connected, workspace_snapshot, app_session, agent_run_start, agent_run_finish) should NOT be here
+// github_connected, task_snapshot, app_session, agent_run_start, agent_run_finish) should NOT be here
 const RENDERER_ALLOWED_EVENTS = new Set([
   // Legacy
   'feature_used',
@@ -20,12 +20,12 @@ const RENDERER_ALLOWED_EVENTS = new Set([
   'project_added_success',
   'project_deleted',
   'project_view_opened',
-  // Workspace management
-  'workspace_created',
-  'workspace_deleted',
-  'workspace_provider_switched',
-  'workspace_custom_named',
-  'workspace_advanced_options_opened',
+  // Task management
+  'task_created',
+  'task_deleted',
+  'task_provider_switched',
+  'task_custom_named',
+  'task_advanced_options_opened',
   // Terminal (Right Sidebar)
   'terminal_entered',
   'terminal_command_executed',
diff --git a/src/main/main.ts b/src/main/main.ts
index 1978d141..a5394b29 100644
--- a/src/main/main.ts
+++ b/src/main/main.ts
@@ -156,11 +156,11 @@ app.whenReady().then(async () => {
     const workspaceCount = workspaces.length;
     const toBucket = (n: number) =>
       n === 0 ? '0' : n <= 2 ? '1-2' : n <= 5 ? '3-5' : n <= 10 ? '6-10' : '>10';
-    telemetry.capture('workspace_snapshot', {
+    telemetry.capture('task_snapshot', {
       project_count: projectCount,
       project_count_bucket: toBucket(projectCount),
-      workspace_count: workspaceCount,
-      workspace_count_bucket: toBucket(workspaceCount),
+      task_count: workspaceCount,
+      task_count_bucket: toBucket(workspaceCount),
     } as any);
   } catch {
     // ignore errors — telemetry is best-effort only
diff --git a/src/main/telemetry.ts b/src/main/telemetry.ts
index e59e69c6..73b877e4 100644
--- a/src/main/telemetry.ts
+++ b/src/main/telemetry.ts
@@ -38,12 +38,12 @@ type TelemetryEvent =
   | 'project_added_success' // when a project is added successfully (both entrypoint buttons)
   | 'project_deleted'
   | 'project_view_opened' // when a user opens a project and see the Task overview in main screen (not the sidebar)
-  // Workspace management
-  | 'workspace_created' // when a new workspace (task) is created (track) (with all attributes, if initial prompt is used (but dont store the initial prompt itself))
-  | 'workspace_deleted' // when a workspace (task) is deleted
-  | 'workspace_provider_switched' // when a workspace (task) is switched to a different provider
-  | 'workspace_custom_named' // when a Task (workspace) is given a custom name instead of the default generated one
-  | 'workspace_advanced_options_opened' // when a workspace (task) advanced options are opened
+  // Task management
+  | 'task_created' // when a new task is created (track) (with all attributes, if initial prompt is used (but dont store the initial prompt itself))
+  | 'task_deleted' // when a task is deleted
+  | 'task_provider_switched' // when a task is switched to a different provider
+  | 'task_custom_named' // when a task is given a custom name instead of the default generated one
+  | 'task_advanced_options_opened' // when task advanced options are opened
   // Terminal (Right Sidebar)
   | 'terminal_entered' //when a user enters the terminal (right sidebar) with his mouse
   | 'terminal_command_executed' //when a user executes a command in the terminal
@@ -61,8 +61,8 @@ type TelemetryEvent =
   // Linear integration
   | 'linear_connected'
   | 'linear_disconnected'
-  | 'linear_issues_searched' // when creating a new task (workspace) and the Linear issue search is opened
-  | 'linear_issue_selected' // when a user selects a Linear issue to create a new task (workspace) (no need to send task, just selecting issue)
+  | 'linear_issues_searched' // when creating a new task and the Linear issue search is opened
+  | 'linear_issue_selected' // when a user selects a Linear issue to create a new task (no need to send task, just selecting issue)
   // Jira integration
   | 'jira_connected'
   | 'jira_disconnected'
@@ -93,7 +93,7 @@ type TelemetryEvent =
   | 'feature_used'
   | 'error'
   // Aggregates (privacy-safe)
-  | 'workspace_snapshot'
+  | 'task_snapshot'
   // Session summary (duration only)
   | 'app_session'
   // Agent usage (provider-level only)
@@ -219,8 +219,8 @@ function sanitizeEventAndProps(event: TelemetryEvent, props: Record<string, any>
     'duration_ms',
     'session_duration_ms',
     'outcome',
-    'workspace_count',
-    'workspace_count_bucket',
+    'task_count',
+    'task_count_bucket',
     'project_count',
     'project_count_bucket',
   ]);
diff --git a/src/renderer/components/ChatInterface.tsx b/src/renderer/components/ChatInterface.tsx
index 4f4a8611..1da0ed6b 100644
--- a/src/renderer/components/ChatInterface.tsx
+++ b/src/renderer/components/ChatInterface.tsx
@@ -225,7 +225,7 @@ const ChatInterface: React.FC<Props> = ({
     if (prevProviderRef.current && prevProviderRef.current !== provider) {
       void (async () => {
         const { captureTelemetry } = await import('../lib/telemetryClient');
-        captureTelemetry('workspace_provider_switched', { provider });
+        captureTelemetry('task_provider_switched', { provider });
       })();
     }
     prevProviderRef.current = provider;
diff --git a/src/renderer/components/CommandPalette.tsx b/src/renderer/components/CommandPalette.tsx
index 6ff78a15..5bb70f97 100644
--- a/src/renderer/components/CommandPalette.tsx
+++ b/src/renderer/components/CommandPalette.tsx
@@ -216,7 +216,7 @@ const CommandPalette: React.FC<CommandPaletteProps> = ({
             label: task.name,
             description: `${project.name} • ${task.branch}`,
             icon: <GitBranch className="h-4 w-4" />,
-            group: 'Workspaces',
+            group: 'Tasks',
             keywords: [
               'task',
               task.name.toLowerCase(),
@@ -254,7 +254,7 @@ const CommandPalette: React.FC<CommandPaletteProps> = ({
     return groups;
   }, [commands]);
 
-  const groupOrder = ['Navigation', 'Toggles', 'Projects', 'Workspaces'];
+  const groupOrder = ['Navigation', 'Toggles', 'Projects', 'Tasks'];
 
   return createPortal(
     <AnimatePresence>
diff --git a/src/renderer/components/MultiAgentTask.tsx b/src/renderer/components/MultiAgentTask.tsx
index 8ab6c003..b5d163b5 100644
--- a/src/renderer/components/MultiAgentTask.tsx
+++ b/src/renderer/components/MultiAgentTask.tsx
@@ -345,7 +345,7 @@ const MultiAgentTask: React.FC<Props> = ({ task }) => {
   // Sync variant busy state to activityStore for sidebar indicator
   useEffect(() => {
     const anyBusy = Object.values(variantBusy).some(Boolean);
-    activityStore.setWorkspaceBusy(task.id, anyBusy);
+    activityStore.setTaskBusy(task.id, anyBusy);
   }, [variantBusy, task.id]);
 
   // Scroll to bottom when active tab changes
diff --git a/src/renderer/components/ProjectMainView.tsx b/src/renderer/components/ProjectMainView.tsx
index 0471987b..f35c9c7d 100644
--- a/src/renderer/components/ProjectMainView.tsx
+++ b/src/renderer/components/ProjectMainView.tsx
@@ -8,7 +8,7 @@ import { usePrStatus } from '../hooks/usePrStatus';
 import { useTaskChanges } from '../hooks/useTaskChanges';
 import { ChangesBadge } from './TaskChanges';
 import { Spinner } from './ui/spinner';
-import WorkspaceDeleteButton from './TaskDeleteButton';
+import TaskDeleteButton from './TaskDeleteButton';
 import ProjectDeleteButton from './ProjectDeleteButton';
 import {
   AlertDialog,
@@ -24,7 +24,7 @@ import { Checkbox } from './ui/checkbox';
 import BaseBranchControls, { RemoteBranchOption } from './BaseBranchControls';
 import { useToast } from '../hooks/use-toast';
 import ContainerStatusBadge from './ContainerStatusBadge';
-import WorkspacePorts from './TaskPorts';
+import TaskPorts from './TaskPorts';
 import { TooltipProvider, Tooltip, TooltipTrigger, TooltipContent } from './ui/tooltip';
 import dockerLogo from '../../assets/images/docker.png';
 import DeletePrNotice from './DeletePrNotice';
@@ -44,7 +44,7 @@ const normalizeBaseRef = (ref?: string | null): string | undefined => {
   return trimmed.length > 0 ? trimmed : undefined;
 };
 
-function WorkspaceRow({
+function TaskRow({
   ws,
   active,
   onClick,
@@ -349,7 +349,7 @@ function WorkspaceRow({
               className="h-4 w-4 rounded border-muted-foreground/50 data-[state=checked]:border-muted-foreground data-[state=checked]:bg-muted-foreground"
             />
           ) : (
-            <WorkspaceDeleteButton
+            <TaskDeleteButton
               taskName={ws.name}
               taskId={ws.id}
               taskPath={ws.path}
@@ -371,7 +371,7 @@ function WorkspaceRow({
 
       <AnimatePresence initial={false}>
         {containerActive && expanded ? (
-          <WorkspacePorts
+          <TaskPorts
             key={`ports-${ws.id}`}
             taskId={ws.id}
             taskPath={ws.path}
@@ -845,7 +845,7 @@ const ProjectMainView: React.FC<ProjectMainViewProps> = ({
                 )}
                 <div className="flex flex-col gap-3">
                   {tasksInProject.map((ws) => (
-                    <WorkspaceRow
+                    <TaskRow
                       key={ws.id}
                       ws={ws}
                       isSelectMode={isSelectMode}
diff --git a/src/renderer/components/TaskDeleteButton.tsx b/src/renderer/components/TaskDeleteButton.tsx
index 5ecbe627..2cb8016b 100644
--- a/src/renderer/components/TaskDeleteButton.tsx
+++ b/src/renderer/components/TaskDeleteButton.tsx
@@ -28,7 +28,7 @@ type Props = {
   isDeleting?: boolean;
 };
 
-export const WorkspaceDeleteButton: React.FC<Props> = ({
+export const TaskDeleteButton: React.FC<Props> = ({
   taskName,
   taskId,
   taskPath,
@@ -197,4 +197,4 @@ export const WorkspaceDeleteButton: React.FC<Props> = ({
   );
 };
 
-export default WorkspaceDeleteButton;
+export default TaskDeleteButton;
diff --git a/src/renderer/components/TaskModal.tsx b/src/renderer/components/TaskModal.tsx
index a8d9f465..3aec75bc 100644
--- a/src/renderer/components/TaskModal.tsx
+++ b/src/renderer/components/TaskModal.tsx
@@ -60,7 +60,7 @@ const TaskModal: React.FC<TaskModalProps> = ({
   existingNames = [],
   projectPath,
 }) => {
-  const [taskName, setWorkspaceName] = useState('');
+  const [taskName, setTaskName] = useState('');
   const [defaultProviderFromSettings, setDefaultProviderFromSettings] =
     useState<Provider>(DEFAULT_PROVIDER);
   const [providerRuns, setProviderRuns] = useState<ProviderRun[]>([
@@ -144,7 +144,7 @@ const TaskModal: React.FC<TaskModalProps> = ({
   );
 
   const onChange = (val: string) => {
-    setWorkspaceName(val);
+    setTaskName(val);
     setError(validate(val));
     // Track that user has manually edited the name (not during initial setup)
     if (!isInitialSetupRef.current) {
@@ -161,7 +161,7 @@ const TaskModal: React.FC<TaskModalProps> = ({
       setCustomNameTracked(true);
       void (async () => {
         const { captureTelemetry } = await import('../lib/telemetryClient');
-        captureTelemetry('workspace_custom_named', { custom_name: 'true' });
+        captureTelemetry('task_custom_named', { custom_name: 'true' });
       })();
     }
   };
@@ -170,7 +170,7 @@ const TaskModal: React.FC<TaskModalProps> = ({
     if (!isOpen) return;
 
     // Reset all form state on open
-    setWorkspaceName('');
+    setTaskName('');
     setAutoGeneratedName('');
     setError(null);
     setTouched(false);
@@ -197,7 +197,7 @@ const TaskModal: React.FC<TaskModalProps> = ({
     // Default assumption: autoGenerateName is true (matches DEFAULT_SETTINGS)
     const suggested = generateFriendlyTaskName(normalizedExisting);
     setAutoGeneratedName(suggested);
-    setWorkspaceName(suggested);
+    setTaskName(suggested);
     setError(validate(suggested));
 
     // Mark initial setup as complete after state updates
@@ -226,11 +226,11 @@ const TaskModal: React.FC<TaskModalProps> = ({
         if (!autoGenerate) {
           // User disabled auto-generate, clear the name
           setAutoGeneratedName('');
-          setWorkspaceName('');
+          setTaskName('');
           setError(null);
         } else {
           // Ensure auto-generated name is set (may have been cleared by user typing)
-          setWorkspaceName(suggested);
+          setTaskName(suggested);
           setError(validate(suggested));
         }
       }
@@ -483,7 +483,7 @@ const TaskModal: React.FC<TaskModalProps> = ({
                           if (wasClosed) {
                             void (async () => {
                               const { captureTelemetry } = await import('../lib/telemetryClient');
-                              captureTelemetry('workspace_advanced_options_opened');
+                              captureTelemetry('task_advanced_options_opened');
                             })();
                           }
                         }}
@@ -495,7 +495,7 @@ const TaskModal: React.FC<TaskModalProps> = ({
                             if (wasClosed) {
                               void (async () => {
                                 const { captureTelemetry } = await import('../lib/telemetryClient');
-                                captureTelemetry('workspace_advanced_options_opened');
+                                captureTelemetry('task_advanced_options_opened');
                               })();
                             }
                           }
diff --git a/src/renderer/components/TaskPorts.tsx b/src/renderer/components/TaskPorts.tsx
index 47937d39..ccd9d608 100644
--- a/src/renderer/components/TaskPorts.tsx
+++ b/src/renderer/components/TaskPorts.tsx
@@ -13,7 +13,7 @@ interface Props {
   previewService?: string;
 }
 
-const WorkspacePorts: React.FC<Props> = ({
+const TaskPorts: React.FC<Props> = ({
   taskId,
   taskPath,
   ports,
@@ -271,4 +271,4 @@ const WorkspacePorts: React.FC<Props> = ({
   );
 };
 
-export default WorkspacePorts;
+export default TaskPorts;
diff --git a/src/renderer/lib/activityStore.ts b/src/renderer/lib/activityStore.ts
index 26ee5305..74fab4fe 100644
--- a/src/renderer/lib/activityStore.ts
+++ b/src/renderer/lib/activityStore.ts
@@ -102,7 +102,7 @@ class ActivityStore {
     }
   }
 
-  setWorkspaceBusy(wsId: string, busy: boolean) {
+  setTaskBusy(wsId: string, busy: boolean) {
     this.setBusy(wsId, busy, false);
   }
 

From 5dfc6cbc0b631da53c3f41d5b3006e03ca236637 Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Mon, 15 Dec 2025 16:55:38 -0800
Subject: [PATCH 22/35] test: update workspace paths to task in test files

---
 src/test/main/ContainerIpc.test.ts           | 26 ++++++++++----------
 src/test/main/ContainerRunnerService.test.ts |  2 +-
 src/test/renderer/containerRuns.test.ts      |  8 +++---
 3 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/src/test/main/ContainerIpc.test.ts b/src/test/main/ContainerIpc.test.ts
index a21b50ff..85ffa2ca 100644
--- a/src/test/main/ContainerIpc.test.ts
+++ b/src/test/main/ContainerIpc.test.ts
@@ -109,19 +109,19 @@ describe('registerContainerIpc', () => {
       loadTaskContainerConfigMock.mockResolvedValue({
         ok: true,
         config,
-        sourcePath: '/tmp/workspace/.emdash/config.json',
+        sourcePath: '/tmp/task/.emdash/config.json',
       });
 
       registerContainerIpc();
       const handler = getHandler('container:load-config');
 
-      const result = await handler({}, { taskPath: '  /tmp/workspace  ' });
+      const result = await handler({}, { taskPath: '  /tmp/task  ' });
 
-      expect(loadTaskContainerConfigMock).toHaveBeenCalledWith('/tmp/workspace');
+      expect(loadTaskContainerConfigMock).toHaveBeenCalledWith('/tmp/task');
       expect(result).toEqual({
         ok: true,
         config,
-        sourcePath: '/tmp/workspace/.emdash/config.json',
+        sourcePath: '/tmp/task/.emdash/config.json',
       });
     });
 
@@ -132,14 +132,14 @@ describe('registerContainerIpc', () => {
           code: 'VALIDATION_FAILED',
           message: '`service` must be a non-empty string',
           configKey: 'ports[0].service',
-          configPath: '/tmp/workspace/.emdash/config.json',
+          configPath: '/tmp/task/.emdash/config.json',
         },
       });
 
       registerContainerIpc();
       const handler = getHandler('container:load-config');
 
-      const result = await handler({}, { taskPath: '/tmp/workspace' });
+      const result = await handler({}, { taskPath: '/tmp/task' });
 
       expect(result).toEqual({
         ok: false,
@@ -147,7 +147,7 @@ describe('registerContainerIpc', () => {
           code: 'VALIDATION_FAILED',
           message: '`service` must be a non-empty string',
           configKey: 'ports[0].service',
-          configPath: '/tmp/workspace/.emdash/config.json',
+          configPath: '/tmp/task/.emdash/config.json',
         },
       });
     });
@@ -176,7 +176,7 @@ describe('registerContainerIpc', () => {
       registerContainerIpc();
       const handler = getHandler('container:load-config');
 
-      const result = await handler({}, { taskPath: '/tmp/workspace' });
+      const result = await handler({}, { taskPath: '/tmp/task' });
 
       expect(result).toEqual({
         ok: false,
@@ -203,7 +203,7 @@ describe('registerContainerIpc', () => {
         ok: true,
         runId: 'run-123',
         config,
-        sourcePath: '/tmp/workspace/.emdash/config.json',
+        sourcePath: '/tmp/task/.emdash/config.json',
       });
 
       registerContainerIpc();
@@ -211,17 +211,17 @@ describe('registerContainerIpc', () => {
 
       const result = await handler(
         {},
-        { taskId: ' ws-1 ', taskPath: ' /tmp/workspace ' }
+        { taskId: ' ws-1 ', taskPath: ' /tmp/task ' }
       );
 
       expect(startRunMock).toHaveBeenCalledWith({
         taskId: 'ws-1',
-        taskPath: '/tmp/workspace',
+        taskPath: '/tmp/task',
       });
       expect(result).toEqual({
         ok: true,
         runId: 'run-123',
-        sourcePath: '/tmp/workspace/.emdash/config.json',
+        sourcePath: '/tmp/task/.emdash/config.json',
       });
     });
 
@@ -239,7 +239,7 @@ describe('registerContainerIpc', () => {
       registerContainerIpc();
       const handler = getHandler('container:start-run');
 
-      const result = await handler({}, { taskId: 'ws-1', taskPath: '/tmp/workspace' });
+      const result = await handler({}, { taskId: 'ws-1', taskPath: '/tmp/task' });
 
       expect(result).toEqual({
         ok: false,
diff --git a/src/test/main/ContainerRunnerService.test.ts b/src/test/main/ContainerRunnerService.test.ts
index 0078434f..65c9076b 100644
--- a/src/test/main/ContainerRunnerService.test.ts
+++ b/src/test/main/ContainerRunnerService.test.ts
@@ -137,7 +137,7 @@ describe('ContainerRunnerService', () => {
 
     const result = await service.startMockRun({
       taskId: 'task-1',
-      taskPath: '/tmp/workspace',
+      taskPath: '/tmp/task',
       runId: 'run-err',
       now: () => 1700000000100,
     });
diff --git a/src/test/renderer/containerRuns.test.ts b/src/test/renderer/containerRuns.test.ts
index c365b599..de3cf79e 100644
--- a/src/test/renderer/containerRuns.test.ts
+++ b/src/test/renderer/containerRuns.test.ts
@@ -68,12 +68,12 @@ describe('containerRuns renderer bridge', () => {
 
     const result = await startContainerRun({
       taskId: ' ws-1 ',
-      taskPath: ' /tmp/workspace ',
+      taskPath: ' /tmp/task ',
     });
 
     expect(startRunMock).toHaveBeenCalledWith({
       taskId: 'ws-1',
-      taskPath: '/tmp/workspace',
+      taskPath: '/tmp/task',
     });
     expect(result).toEqual({ ok: true, runId: 'run-1', sourcePath: null });
     expect(onRunEventMock).toHaveBeenCalledTimes(1);
@@ -149,11 +149,11 @@ describe('containerRuns renderer bridge', () => {
   it('re-registers listener after reset', async () => {
     startRunMock.mockResolvedValue({ ok: true, runId: 'run-3', sourcePath: null });
 
-    await startContainerRun({ taskId: 'ws-1', taskPath: '/tmp/workspace' });
+    await startContainerRun({ taskId: 'ws-1', taskPath: '/tmp/task' });
     expect(onRunEventMock).toHaveBeenCalledTimes(1);
 
     resetContainerRunListeners();
-    await startContainerRun({ taskId: 'ws-1', taskPath: '/tmp/workspace' });
+    await startContainerRun({ taskId: 'ws-1', taskPath: '/tmp/task' });
     expect(onRunEventMock).toHaveBeenCalledTimes(2);
   });
 });

From 5635602a3ae2346df47f45ce61fa47ea32b24aa9 Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Mon, 15 Dec 2025 17:00:35 -0800
Subject: [PATCH 23/35] docs: update workspace references to task in comments

---
 src/main/ipc/dbIpc.ts                                  |  4 ++--
 src/main/main.ts                                       |  2 +-
 src/main/services/containerRunnerService.ts            |  6 +++---
 src/main/services/fsIpc.ts                             |  2 +-
 src/main/services/hostPreviewService.ts                |  2 +-
 src/main/services/iconService.ts                       |  2 +-
 src/renderer/components/ActiveRuns.tsx                 |  2 +-
 src/renderer/components/ChatInterface.tsx              | 10 +++++-----
 src/renderer/components/CommandPalette.tsx             |  2 +-
 src/renderer/components/MultiAgentTask.tsx             |  2 +-
 src/renderer/components/ProjectMainView.tsx            |  2 +-
 src/renderer/components/ProviderBar.tsx                |  2 +-
 src/renderer/components/RightSidebar.tsx               |  4 ++--
 src/renderer/components/kanban/KanbanBoard.tsx         |  8 ++++----
 src/renderer/components/kanban/KanbanCard.tsx          |  2 +-
 .../components/titlebar/BrowserToggleButton.tsx        |  2 +-
 src/renderer/hooks/useProviderPreference.ts            |  6 +++---
 src/renderer/lib/activityStore.ts                      |  4 ++--
 src/renderer/terminal/TerminalSessionManager.ts        |  2 +-
 19 files changed, 33 insertions(+), 33 deletions(-)

diff --git a/src/main/ipc/dbIpc.ts b/src/main/ipc/dbIpc.ts
index 80d5daaa..42497a71 100644
--- a/src/main/ipc/dbIpc.ts
+++ b/src/main/ipc/dbIpc.ts
@@ -114,10 +114,10 @@ export function registerDatabaseIpc() {
 
   ipcMain.handle('db:deleteTask', async (_, taskId: string) => {
     try {
-      // Stop any running Docker container for this workspace before deletion
+      // Stop any running Docker container for this task before deletion
       const stopResult = await containerRunnerService.stopRun(taskId);
       if (!stopResult.ok) {
-        // Log but don't fail workspace deletion if container stop fails
+        // Log but don't fail task deletion if container stop fails
         log.warn('Failed to stop container during task deletion:', stopResult.error);
       }
 
diff --git a/src/main/main.ts b/src/main/main.ts
index a5394b29..96c81cc5 100644
--- a/src/main/main.ts
+++ b/src/main/main.ts
@@ -146,7 +146,7 @@ app.whenReady().then(async () => {
   // Initialize telemetry (privacy-first, anonymous)
   telemetry.init({ installSource: app.isPackaged ? 'dmg' : 'dev' });
 
-  // Best-effort: capture a coarse snapshot of project/workspace counts (no names/paths)
+  // Best-effort: capture a coarse snapshot of project/task counts (no names/paths)
   try {
     const [projects, workspaces] = await Promise.all([
       databaseService.getProjects(),
diff --git a/src/main/services/containerRunnerService.ts b/src/main/services/containerRunnerService.ts
index 88c51035..26ddd940 100644
--- a/src/main/services/containerRunnerService.ts
+++ b/src/main/services/containerRunnerService.ts
@@ -570,7 +570,7 @@ export class ContainerRunnerService extends EventEmitter {
     };
 
     try {
-      // Host-side preflight checks to prevent unintended workspace mutations
+      // Host-side preflight checks to prevent unintended task mutations
       const absWorkspace = path.resolve(taskPath);
       const workdirAbs = path.resolve(absWorkspace, config.workdir);
 
@@ -645,7 +645,7 @@ export class ContainerRunnerService extends EventEmitter {
         };
       }
 
-      // Prefer compose runner when a compose file exists at the workspace root
+      // Prefer compose runner when a compose file exists at the task root
       const composeBase = this.findComposeFile(absWorkspace);
       if (composeBase) {
         log.info('[containers] compose detected; delegating to compose runner');
@@ -685,7 +685,7 @@ export class ContainerRunnerService extends EventEmitter {
         dockerArgs.push('-p', `${m.host}:${m.container}`);
       }
 
-      // Workspace mount and workdir
+      // Task mount and workdir
       dockerArgs.push('-v', `${absWorkspace}:/workspace`);
       const workdir = path.posix.join('/workspace', config.workdir.replace(/\\/g, '/'));
       dockerArgs.push('-w', workdir);
diff --git a/src/main/services/fsIpc.ts b/src/main/services/fsIpc.ts
index 5c8b42a9..b7cf2fbb 100644
--- a/src/main/services/fsIpc.ts
+++ b/src/main/services/fsIpc.ts
@@ -155,7 +155,7 @@ export function registerFsIpc(): void {
     }
   );
 
-  // Save an attachment (e.g., image) into a workspace-managed folder
+  // Save an attachment (e.g., image) into a task-managed folder
   ipcMain.handle(
     'fs:save-attachment',
     async (_event, args: { taskPath: string; srcPath: string; subdir?: string }) => {
diff --git a/src/main/services/hostPreviewService.ts b/src/main/services/hostPreviewService.ts
index a633368c..54a7972e 100644
--- a/src/main/services/hostPreviewService.ts
+++ b/src/main/services/hostPreviewService.ts
@@ -174,7 +174,7 @@ class HostPreviewService extends EventEmitter {
     }
 
     const pm = detectPackageManager(cwd);
-    // Preflight: if the workspace lacks node_modules but the parent has it, try linking
+    // Preflight: if the task lacks node_modules but the parent has it, try linking
     try {
       const parent = (opts?.parentProjectPath || '').trim();
       if (parent) {
diff --git a/src/main/services/iconService.ts b/src/main/services/iconService.ts
index c3a49ac6..1c0ebba0 100644
--- a/src/main/services/iconService.ts
+++ b/src/main/services/iconService.ts
@@ -132,7 +132,7 @@ export async function resolveServiceIcon(opts: {
   if (!service) return { ok: false };
   const slug = toSlug(service);
 
-  // 1) Workspace overrides
+  // 1) Task overrides
   if (opts.taskPath) {
     const p = path.join(opts.taskPath, '.emdash', 'service-icons');
     const candidates = ['.svg', '.png', '.jpg', '.jpeg', '.ico'].map((ext) =>
diff --git a/src/renderer/components/ActiveRuns.tsx b/src/renderer/components/ActiveRuns.tsx
index 7bc178e3..6830d44b 100644
--- a/src/renderer/components/ActiveRuns.tsx
+++ b/src/renderer/components/ActiveRuns.tsx
@@ -35,7 +35,7 @@ const ActiveRuns: React.FC<Props> = ({ projects, onSelectProject, onSelectTask }
 
   if (!activeRuns.length) return null;
 
-  // Resolve workspace/project mapping for display and navigation
+  // Resolve task/project mapping for display and navigation
   const byId = new Map<string, { project: any | null; task: any | null }>();
   for (const s of activeRuns) {
     let match: { project: any | null; task: any | null } | null = null;
diff --git a/src/renderer/components/ChatInterface.tsx b/src/renderer/components/ChatInterface.tsx
index 1da0ed6b..c4a618ef 100644
--- a/src/renderer/components/ChatInterface.tsx
+++ b/src/renderer/components/ChatInterface.tsx
@@ -62,10 +62,10 @@ const ChatInterface: React.FC<Props> = ({
   const [portsExpanded, setPortsExpanded] = useState(false);
   const { activeTerminalId } = useTaskTerminals(task.id, task.path);
 
-  // Auto-scroll to bottom when this workspace becomes active
+  // Auto-scroll to bottom when this task becomes active
   useAutoScrollOnTaskSwitch(true, task.id);
 
-  // Unified Plan Mode (per workspace)
+  // Unified Plan Mode (per task)
   const { enabled: planEnabled, setEnabled: setPlanEnabled } = usePlanMode(
     task.id,
     task.path
@@ -175,7 +175,7 @@ const ChatInterface: React.FC<Props> = ({
     if (!active) setPortsExpanded(false);
   }, [containerState?.status, containerState?.ports?.length]);
 
-  // On workspace change, restore last-selected provider (including Droid).
+  // On task change, restore last-selected provider (including Droid).
   // If a locked provider exists (including Droid), prefer locked.
   useEffect(() => {
     try {
@@ -212,7 +212,7 @@ const ChatInterface: React.FC<Props> = ({
     }
   }, [task.id, initialProvider]);
 
-  // Persist last-selected provider per workspace (including Droid)
+  // Persist last-selected provider per task (including Droid)
   useEffect(() => {
     try {
       window.localStorage.setItem(`provider:last:${task.id}`, provider);
@@ -453,7 +453,7 @@ const ChatInterface: React.FC<Props> = ({
     enabled: isTerminal && providerMeta[provider]?.initialPromptFlag === undefined,
   });
 
-  // Ensure a provider is stored for this workspace so fallbacks can subscribe immediately
+  // Ensure a provider is stored for this task so fallbacks can subscribe immediately
   useEffect(() => {
     try {
       localStorage.setItem(`workspaceProvider:${task.id}`, provider);
diff --git a/src/renderer/components/CommandPalette.tsx b/src/renderer/components/CommandPalette.tsx
index 5bb70f97..ea6e2d02 100644
--- a/src/renderer/components/CommandPalette.tsx
+++ b/src/renderer/components/CommandPalette.tsx
@@ -208,7 +208,7 @@ const CommandPalette: React.FC<CommandPaletteProps> = ({
         });
       }
 
-      // Workspace commands
+      // Task commands
       if (project.tasks && onSelectTask) {
         project.tasks.forEach((task) => {
           items.push({
diff --git a/src/renderer/components/MultiAgentTask.tsx b/src/renderer/components/MultiAgentTask.tsx
index b5d163b5..8ddcca05 100644
--- a/src/renderer/components/MultiAgentTask.tsx
+++ b/src/renderer/components/MultiAgentTask.tsx
@@ -56,7 +56,7 @@ const MultiAgentTask: React.FC<Props> = ({ task }) => {
     }
 
     // Multiple instances: extract instance number from variant name
-    // variant.name format: "workspace-provider-1", "workspace-provider-2", etc.
+    // variant.name format: "task-provider-1", "task-provider-2", etc.
     const match = variant.name.match(/-(\d+)$/);
     const instanceNum = match ? match[1] : String(providerVariants.indexOf(variant) + 1);
 
diff --git a/src/renderer/components/ProjectMainView.tsx b/src/renderer/components/ProjectMainView.tsx
index f35c9c7d..20f872a7 100644
--- a/src/renderer/components/ProjectMainView.tsx
+++ b/src/renderer/components/ProjectMainView.tsx
@@ -521,7 +521,7 @@ const ProjectMainView: React.FC<ProjectMainViewProps> = ({
           deletedNames.push(ws.name);
         }
       } catch {
-        // Continue deleting remaining workspaces
+        // Continue deleting remaining tasks
       }
     }
 
diff --git a/src/renderer/components/ProviderBar.tsx b/src/renderer/components/ProviderBar.tsx
index 047873b3..16c91819 100644
--- a/src/renderer/components/ProviderBar.tsx
+++ b/src/renderer/components/ProviderBar.tsx
@@ -76,7 +76,7 @@ export const ProviderBar: React.FC<Props> = ({
     };
   }, []);
 
-  // Per-workspace default OFF
+  // Per-task default OFF
   React.useEffect(() => {
     try {
       const key = `c7:ws:${taskId}`;
diff --git a/src/renderer/components/RightSidebar.tsx b/src/renderer/components/RightSidebar.tsx
index 307acc14..4a769abd 100644
--- a/src/renderer/components/RightSidebar.tsx
+++ b/src/renderer/components/RightSidebar.tsx
@@ -25,7 +25,7 @@ interface RightSidebarProps extends React.HTMLAttributes<HTMLElement> {
 const RightSidebar: React.FC<RightSidebarProps> = ({ task, className, ...rest }) => {
   const { collapsed } = useRightSidebar();
 
-  // Detect multi-agent variants in workspace metadata
+  // Detect multi-agent variants in task metadata
   const variants: Array<{ provider: Provider; name: string; path: string }> = (() => {
     try {
       const v = task?.metadata?.multiAgent?.variants || [];
@@ -52,7 +52,7 @@ const RightSidebar: React.FC<RightSidebarProps> = ({ task, className, ...rest })
     }
 
     // Multiple instances: extract instance number from variant name
-    // variant.name format: "workspace-provider-1", "workspace-provider-2", etc.
+    // variant.name format: "task-provider-1", "task-provider-2", etc.
     const match = variant.name.match(/-(\d+)$/);
     const instanceNum = match
       ? match[1]
diff --git a/src/renderer/components/kanban/KanbanBoard.tsx b/src/renderer/components/kanban/KanbanBoard.tsx
index 098102d8..f662a246 100644
--- a/src/renderer/components/kanban/KanbanBoard.tsx
+++ b/src/renderer/components/kanban/KanbanBoard.tsx
@@ -79,7 +79,7 @@ const KanbanBoard: React.FC<{
       offs.push(un);
     }
 
-    // Per-ws: when the PTY exits and workspace is not busy anymore, move to Done
+    // Per-task: when the PTY exits and task is not busy anymore, move to Done
     for (const ws of wsList) {
       try {
         const offExit = (window as any).electronAPI.onPtyExit?.(
@@ -106,7 +106,7 @@ const KanbanBoard: React.FC<{
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [project.id, project.tasks?.length]);
 
-  // Promote any workspace with local changes directly to "Ready for review" (done)
+  // Promote any task with local changes directly to "Ready for review" (done)
   React.useEffect(() => {
     let cancelled = false;
     const wsList = project.tasks || [];
@@ -145,7 +145,7 @@ const KanbanBoard: React.FC<{
             });
           }
         } catch {
-          // ignore per‑workspace errors
+          // ignore per-task errors
         }
       }
     };
@@ -157,7 +157,7 @@ const KanbanBoard: React.FC<{
     };
   }, [project.id, project.tasks?.length]);
 
-  // Promote any workspace with an open PR to "Ready for review" (done)
+  // Promote any task with an open PR to "Ready for review" (done)
   React.useEffect(() => {
     let cancelled = false;
     const wsList = project.tasks || [];
diff --git a/src/renderer/components/kanban/KanbanCard.tsx b/src/renderer/components/kanban/KanbanCard.tsx
index 0624743f..b88670c2 100644
--- a/src/renderer/components/kanban/KanbanCard.tsx
+++ b/src/renderer/components/kanban/KanbanCard.tsx
@@ -23,7 +23,7 @@ const KanbanCard: React.FC<{
   draggable?: boolean;
 }> = ({ ws, onOpen, draggable = true }) => {
   const SHOW_PROVIDER_LOGOS = false;
-  // Resolve single-provider from legacy localStorage (single‑agent workspaces)
+  // Resolve single-provider from legacy localStorage (single-agent tasks)
   const provider = resolveProvider(ws.id);
   const asset = provider ? providerAssets[provider] : null;
 
diff --git a/src/renderer/components/titlebar/BrowserToggleButton.tsx b/src/renderer/components/titlebar/BrowserToggleButton.tsx
index 5397e660..854f63c4 100644
--- a/src/renderer/components/titlebar/BrowserToggleButton.tsx
+++ b/src/renderer/components/titlebar/BrowserToggleButton.tsx
@@ -46,7 +46,7 @@ const BrowserToggleButton: React.FC<Props> = ({
     }
   }
 
-  // Auto-open when host preview emits a URL for this workspace
+  // Auto-open when host preview emits a URL for this task
   useEffect(() => {
     const off = (window as any).electronAPI?.onHostPreviewEvent?.((data: any) => {
       try {
diff --git a/src/renderer/hooks/useProviderPreference.ts b/src/renderer/hooks/useProviderPreference.ts
index cfcab763..4ab7c781 100644
--- a/src/renderer/hooks/useProviderPreference.ts
+++ b/src/renderer/hooks/useProviderPreference.ts
@@ -9,7 +9,7 @@ export function useProviderPreference(
 ) {
   const [provider, setProvider] = useState<ProviderId>(initial);
 
-  // Reset to initial when switching workspaces before conversation is available
+  // Reset to initial when switching tasks before conversation is available
   useEffect(() => {
     if (!conversationId) {
       setProvider(initial);
@@ -17,7 +17,7 @@ export function useProviderPreference(
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [taskId, conversationId]);
 
-  // Restore preferred provider for this conversation/workspace
+  // Restore preferred provider for this conversation/task
   useEffect(() => {
     if (!conversationId) return;
     try {
@@ -33,7 +33,7 @@ export function useProviderPreference(
     } catch {}
   }, [conversationId, taskId]);
 
-  // Persist provider selection per conversation and workspace
+  // Persist provider selection per conversation and task
   useEffect(() => {
     if (!conversationId) return;
     try {
diff --git a/src/renderer/lib/activityStore.ts b/src/renderer/lib/activityStore.ts
index 74fab4fe..becf111d 100644
--- a/src/renderer/lib/activityStore.ts
+++ b/src/renderer/lib/activityStore.ts
@@ -18,7 +18,7 @@ class ActivityStore {
     api?.onPtyActivity?.((info: { id: string; chunk?: string }) => {
       try {
         const id = String(info?.id || '');
-        // Match any subscribed workspace id by suffix
+        // Match any subscribed task id by suffix
         for (const wsId of this.subscribedIds) {
           if (!id.endsWith(wsId)) continue;
           const prov = id.includes('-main-') ? id.split('-main-')[0] || '' : '';
@@ -114,7 +114,7 @@ class ActivityStore {
     this.listeners.set(wsId, set);
     // emit current
     fn(this.states.get(wsId) || false);
-    // Fallback: also listen directly to this workspace's main PTY data in case global broadcast is missing
+    // Fallback: also listen directly to this task's main PTY data in case global broadcast is missing
     const offDirect: Array<() => void> = [];
     try {
       const api: any = (window as any).electronAPI;
diff --git a/src/renderer/terminal/TerminalSessionManager.ts b/src/renderer/terminal/TerminalSessionManager.ts
index fefe4d30..315bd1ed 100644
--- a/src/renderer/terminal/TerminalSessionManager.ts
+++ b/src/renderer/terminal/TerminalSessionManager.ts
@@ -368,7 +368,7 @@ export class TerminalSessionManager {
   /**
    * Restore the previously captured viewport position.
    * This ensures the terminal stays at the same scroll position when switching
-   * between workspaces or when the terminal is reattached.
+   * between tasks or when the terminal is reattached.
    */
   private restoreViewportPosition() {
     try {

From 52156b0753b27d30162a0f947cbfa70076d9c108 Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Mon, 15 Dec 2025 17:02:18 -0800
Subject: [PATCH 24/35] refactor: update workspace UI strings to task

---
 src/renderer/components/CommandPalette.tsx      | 2 +-
 src/renderer/components/LeftSidebar.tsx         | 2 +-
 src/renderer/components/ProjectDeleteButton.tsx | 2 +-
 src/renderer/components/ProjectMainView.tsx     | 4 ++--
 src/renderer/components/TaskList.tsx            | 4 ++--
 src/test/main/ContainerIpc.test.ts              | 2 +-
 6 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/renderer/components/CommandPalette.tsx b/src/renderer/components/CommandPalette.tsx
index ea6e2d02..40757772 100644
--- a/src/renderer/components/CommandPalette.tsx
+++ b/src/renderer/components/CommandPalette.tsx
@@ -294,7 +294,7 @@ const CommandPalette: React.FC<CommandPaletteProps> = ({
                 <Command.Input
                   value={search}
                   onValueChange={setSearch}
-                  placeholder="Search commands, projects, workspaces..."
+                  placeholder="Search commands, projects, tasks..."
                   className="flex h-12 w-full rounded-md bg-transparent text-sm text-foreground outline-none placeholder:text-muted-foreground disabled:cursor-not-allowed disabled:opacity-50"
                   autoFocus
                 />
diff --git a/src/renderer/components/LeftSidebar.tsx b/src/renderer/components/LeftSidebar.tsx
index 7b1d93be..d0a81d35 100644
--- a/src/renderer/components/LeftSidebar.tsx
+++ b/src/renderer/components/LeftSidebar.tsx
@@ -238,7 +238,7 @@ const LeftSidebar: React.FC<LeftSidebarProps> = ({
                               <CollapsibleTrigger asChild>
                                 <button
                                   type="button"
-                                  aria-label={`Toggle workspaces for ${typedProject.name}`}
+                                  aria-label={`Toggle tasks for ${typedProject.name}`}
                                   onClick={(e) => e.stopPropagation()}
                                   className="inline-flex h-5 w-5 items-center justify-center rounded p-0.5 text-muted-foreground transition-colors hover:bg-muted hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2"
                                 >
diff --git a/src/renderer/components/ProjectDeleteButton.tsx b/src/renderer/components/ProjectDeleteButton.tsx
index d7bef750..de8950c9 100644
--- a/src/renderer/components/ProjectDeleteButton.tsx
+++ b/src/renderer/components/ProjectDeleteButton.tsx
@@ -67,7 +67,7 @@ export const ProjectDeleteButton: React.FC<Props> = ({
         <AlertDialogHeader>
           <AlertDialogTitle>Delete project?</AlertDialogTitle>
           <AlertDialogDescription>
-            {`This removes "${projectName}" from emdash, including its saved workspaces and conversations. Files on disk are not deleted.`}
+            {`This removes "${projectName}" from emdash, including its saved tasks and conversations. Files on disk are not deleted.`}
           </AlertDialogDescription>
         </AlertDialogHeader>
         <AlertDialogFooter>
diff --git a/src/renderer/components/ProjectMainView.tsx b/src/renderer/components/ProjectMainView.tsx
index 20f872a7..49bcbea7 100644
--- a/src/renderer/components/ProjectMainView.tsx
+++ b/src/renderer/components/ProjectMainView.tsx
@@ -255,14 +255,14 @@ function TaskRow({
                     type="button"
                     disabled
                     className="inline-flex h-8 cursor-not-allowed items-center justify-center rounded-md border border-border/70 bg-background px-2.5 text-xs font-medium opacity-50"
-                    aria-label="Connect disabled for multi-agent workspaces"
+                    aria-label="Connect disabled for multi-agent tasks"
                   >
                     <img src={dockerLogo} alt="Docker" className="mr-1.5 h-3.5 w-3.5" />
                     Connect
                   </button>
                 </TooltipTrigger>
                 <TooltipContent side="top" className="max-w-[22rem] text-xs leading-snug">
-                  Docker containerization is not available for multi-agent workspaces.
+                  Docker containerization is not available for multi-agent tasks.
                 </TooltipContent>
               </Tooltip>
             </TooltipProvider>
diff --git a/src/renderer/components/TaskList.tsx b/src/renderer/components/TaskList.tsx
index 86f376c2..952dfacd 100644
--- a/src/renderer/components/TaskList.tsx
+++ b/src/renderer/components/TaskList.tsx
@@ -41,7 +41,7 @@ export const TaskList: React.FC<Props> = ({
   return (
     <div className="flex h-full flex-col p-4">
       <div className="mb-4 flex items-center justify-between">
-        <h2 className="text-xl font-semibold">Workspaces</h2>
+        <h2 className="text-xl font-semibold">Tasks</h2>
         <Button
           variant="default"
           size="sm"
@@ -64,7 +64,7 @@ export const TaskList: React.FC<Props> = ({
       {tasks.length === 0 ? (
         <div className="flex h-full flex-col items-center justify-center text-gray-500">
           <Bot className="mb-4 h-12 w-12" />
-          <p className="text-center">No workspaces yet. Create one to get started!</p>
+          <p className="text-center">No tasks yet. Create one to get started!</p>
         </div>
       ) : (
         <div className="flex-1 space-y-3 overflow-y-auto">
diff --git a/src/test/main/ContainerIpc.test.ts b/src/test/main/ContainerIpc.test.ts
index 85ffa2ca..fef68a68 100644
--- a/src/test/main/ContainerIpc.test.ts
+++ b/src/test/main/ContainerIpc.test.ts
@@ -152,7 +152,7 @@ describe('registerContainerIpc', () => {
       });
     });
 
-    it('rejects missing workspace path', async () => {
+    it('rejects missing task path', async () => {
       registerContainerIpc();
       const handler = getHandler('container:load-config');
 

From 3dbd9acb03e440f9387c65f306f8b887167301c6 Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Mon, 15 Dec 2025 17:04:33 -0800
Subject: [PATCH 25/35] refactor: rename absWorkspace to absTaskPath

---
 src/main/services/containerRunnerService.ts | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/main/services/containerRunnerService.ts b/src/main/services/containerRunnerService.ts
index 26ddd940..629a41d6 100644
--- a/src/main/services/containerRunnerService.ts
+++ b/src/main/services/containerRunnerService.ts
@@ -571,8 +571,8 @@ export class ContainerRunnerService extends EventEmitter {
 
     try {
       // Host-side preflight checks to prevent unintended task mutations
-      const absWorkspace = path.resolve(taskPath);
-      const workdirAbs = path.resolve(absWorkspace, config.workdir);
+      const absTaskPath = path.resolve(taskPath);
+      const workdirAbs = path.resolve(absTaskPath, config.workdir);
 
       if (!fs.existsSync(workdirAbs)) {
         const message = `Configured workdir does not exist: ${workdirAbs}`;
@@ -646,12 +646,12 @@ export class ContainerRunnerService extends EventEmitter {
       }
 
       // Prefer compose runner when a compose file exists at the task root
-      const composeBase = this.findComposeFile(absWorkspace);
+      const composeBase = this.findComposeFile(absTaskPath);
       if (composeBase) {
         log.info('[containers] compose detected; delegating to compose runner');
         return await this.startComposeRun({
           taskId,
-          taskPath: absWorkspace,
+          taskPath: absTaskPath,
           runId,
           mode,
           config,
@@ -686,7 +686,7 @@ export class ContainerRunnerService extends EventEmitter {
       }
 
       // Task mount and workdir
-      dockerArgs.push('-v', `${absWorkspace}:/workspace`);
+      dockerArgs.push('-v', `${absTaskPath}:/workspace`);
       const workdir = path.posix.join('/workspace', config.workdir.replace(/\\/g, '/'));
       dockerArgs.push('-w', workdir);
 

From 3e1891c8123be3696acde38ad8aff9a2f3586c8f Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Mon, 15 Dec 2025 17:06:53 -0800
Subject: [PATCH 26/35] refactor: rename workspace storage keys to task

---
 src/renderer/components/ChatInterface.tsx     | 2 +-
 src/renderer/components/kanban/KanbanCard.tsx | 2 +-
 src/renderer/hooks/useProviderPreference.ts   | 4 ++--
 src/renderer/lib/kanbanStore.ts               | 2 +-
 src/renderer/lib/taskTerminalsStore.ts        | 2 +-
 5 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/renderer/components/ChatInterface.tsx b/src/renderer/components/ChatInterface.tsx
index c4a618ef..ba954a6f 100644
--- a/src/renderer/components/ChatInterface.tsx
+++ b/src/renderer/components/ChatInterface.tsx
@@ -456,7 +456,7 @@ const ChatInterface: React.FC<Props> = ({
   // Ensure a provider is stored for this task so fallbacks can subscribe immediately
   useEffect(() => {
     try {
-      localStorage.setItem(`workspaceProvider:${task.id}`, provider);
+      localStorage.setItem(`taskProvider:${task.id}`, provider);
     } catch {}
   }, [provider, task.id]);
 
diff --git a/src/renderer/components/kanban/KanbanCard.tsx b/src/renderer/components/kanban/KanbanCard.tsx
index b88670c2..c7feee1d 100644
--- a/src/renderer/components/kanban/KanbanCard.tsx
+++ b/src/renderer/components/kanban/KanbanCard.tsx
@@ -8,7 +8,7 @@ import { Spinner } from '../ui/spinner';
 
 function resolveProvider(taskId: string): UiProvider | null {
   try {
-    const v = localStorage.getItem(`workspaceProvider:${taskId}`);
+    const v = localStorage.getItem(`taskProvider:${taskId}`);
     if (!v) return null;
     const id = v.trim() as UiProvider;
     return id in providerAssets ? id : null;
diff --git a/src/renderer/hooks/useProviderPreference.ts b/src/renderer/hooks/useProviderPreference.ts
index 4ab7c781..5d7e6a81 100644
--- a/src/renderer/hooks/useProviderPreference.ts
+++ b/src/renderer/hooks/useProviderPreference.ts
@@ -27,7 +27,7 @@ export function useProviderPreference(
         setProvider(saved);
         return;
       }
-      const wkKey = `workspaceProvider:${taskId}`;
+      const wkKey = `taskProvider:${taskId}`;
       const wkSaved = localStorage.getItem(wkKey) as ProviderId | null;
       if (wkSaved) setProvider(wkSaved);
     } catch {}
@@ -38,7 +38,7 @@ export function useProviderPreference(
     if (!conversationId) return;
     try {
       localStorage.setItem(`conversationProvider:${conversationId}`, provider);
-      localStorage.setItem(`workspaceProvider:${taskId}`, provider);
+      localStorage.setItem(`taskProvider:${taskId}`, provider);
     } catch {}
   }, [provider, conversationId, taskId]);
 
diff --git a/src/renderer/lib/kanbanStore.ts b/src/renderer/lib/kanbanStore.ts
index 898f533b..c646b987 100644
--- a/src/renderer/lib/kanbanStore.ts
+++ b/src/renderer/lib/kanbanStore.ts
@@ -1,6 +1,6 @@
 export type KanbanStatus = 'todo' | 'in-progress' | 'done';
 
-const STORAGE_KEY = 'emdash:kanban:statusByWorkspace';
+const STORAGE_KEY = 'emdash:kanban:statusByTask';
 
 type MapShape = Record<string, KanbanStatus>;
 
diff --git a/src/renderer/lib/taskTerminalsStore.ts b/src/renderer/lib/taskTerminalsStore.ts
index fe10e9ba..ad46906b 100644
--- a/src/renderer/lib/taskTerminalsStore.ts
+++ b/src/renderer/lib/taskTerminalsStore.ts
@@ -19,7 +19,7 @@ type TaskSnapshot = {
   activeTerminalId: string | null;
 };
 
-const STORAGE_PREFIX = 'emdash:workspaceTerminals:v1';
+const STORAGE_PREFIX = 'emdash:taskTerminals:v1';
 
 const taskStates = new Map<string, TaskTerminalsState>();
 const taskListeners = new Map<string, Set<() => void>>();

From 0772b325f2bc898562d89c41fb536d8d4564adee Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Mon, 15 Dec 2025 17:09:47 -0800
Subject: [PATCH 27/35] refactor: rename workspace local variables to task

---
 src/main/ipc/dbIpc.ts                       | 2 +-
 src/main/main.ts                            | 8 ++++----
 src/main/services/fsIpc.ts                  | 4 ++--
 src/renderer/components/ProjectMainView.tsx | 6 +++---
 4 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/main/ipc/dbIpc.ts b/src/main/ipc/dbIpc.ts
index 42497a71..f23b9a7c 100644
--- a/src/main/ipc/dbIpc.ts
+++ b/src/main/ipc/dbIpc.ts
@@ -27,7 +27,7 @@ export function registerDatabaseIpc() {
     try {
       return await databaseService.getTasks(projectId);
     } catch (error) {
-      log.error('Failed to get workspaces:', error);
+      log.error('Failed to get tasks:', error);
       return [];
     }
   });
diff --git a/src/main/main.ts b/src/main/main.ts
index 96c81cc5..f15be24f 100644
--- a/src/main/main.ts
+++ b/src/main/main.ts
@@ -148,19 +148,19 @@ app.whenReady().then(async () => {
 
   // Best-effort: capture a coarse snapshot of project/task counts (no names/paths)
   try {
-    const [projects, workspaces] = await Promise.all([
+    const [projects, tasks] = await Promise.all([
       databaseService.getProjects(),
       databaseService.getTasks(),
     ]);
     const projectCount = projects.length;
-    const workspaceCount = workspaces.length;
+    const taskCount = tasks.length;
     const toBucket = (n: number) =>
       n === 0 ? '0' : n <= 2 ? '1-2' : n <= 5 ? '3-5' : n <= 10 ? '6-10' : '>10';
     telemetry.capture('task_snapshot', {
       project_count: projectCount,
       project_count_bucket: toBucket(projectCount),
-      task_count: workspaceCount,
-      task_count_bucket: toBucket(workspaceCount),
+      task_count: taskCount,
+      task_count_bucket: toBucket(taskCount),
     } as any);
   } catch {
     // ignore errors — telemetry is best-effort only
diff --git a/src/main/services/fsIpc.ts b/src/main/services/fsIpc.ts
index b7cf2fbb..f1d34a0a 100644
--- a/src/main/services/fsIpc.ts
+++ b/src/main/services/fsIpc.ts
@@ -191,11 +191,11 @@ export function registerFsIpc(): void {
 
         fs.copyFileSync(srcPath, destAbs);
 
-        const relFromWorkspace = path.relative(taskPath, destAbs);
+        const relFromTask = path.relative(taskPath, destAbs);
         return {
           success: true,
           absPath: destAbs,
-          relPath: relFromWorkspace,
+          relPath: relFromTask,
           fileName: destName,
         };
       } catch (error) {
diff --git a/src/renderer/components/ProjectMainView.tsx b/src/renderer/components/ProjectMainView.tsx
index 49bcbea7..f69fe5c1 100644
--- a/src/renderer/components/ProjectMainView.tsx
+++ b/src/renderer/components/ProjectMainView.tsx
@@ -919,10 +919,10 @@ const ProjectMainView: React.FC<ProjectMainViewProps> = ({
 
             <AnimatePresence initial={false}>
               {(() => {
-                const prWorkspaces = selectedTasks
+                const prTasks = selectedTasks
                   .map((ws) => ({ name: ws.name, pr: deleteStatus[ws.id]?.pr }))
                   .filter((w) => w.pr);
-                return prWorkspaces.length ? (
+                return prTasks.length ? (
                   <motion.div
                     key="bulk-pr-notice"
                     initial={{ opacity: 0, y: 6, scale: 0.99 }}
@@ -930,7 +930,7 @@ const ProjectMainView: React.FC<ProjectMainViewProps> = ({
                     exit={{ opacity: 0, y: 6, scale: 0.99 }}
                     transition={{ duration: 0.2, ease: 'easeOut', delay: 0.02 }}
                   >
-                    <DeletePrNotice tasks={prWorkspaces as any} />
+                    <DeletePrNotice tasks={prTasks as any} />
                   </motion.div>
                 ) : null;
               })()}

From f0b3f54a97bfd34bab0c5514409516b5a872d161 Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Mon, 15 Dec 2025 17:13:47 -0800
Subject: [PATCH 28/35] refactor: rename workspace PTY IDs to task

---
 src/renderer/App.tsx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/renderer/App.tsx b/src/renderer/App.tsx
index efc4184a..b8991d57 100644
--- a/src/renderer/App.tsx
+++ b/src/renderer/App.tsx
@@ -1234,7 +1234,7 @@ const AppContent: React.FC = () => {
           } catch {}
         } catch {}
         try {
-          window.electronAPI.ptyKill?.(`workspace-${task.id}`);
+          window.electronAPI.ptyKill?.(`task-${task.id}`);
         } catch {}
         try {
           for (const provider of TERMINAL_PROVIDER_IDS) {
@@ -1244,7 +1244,7 @@ const AppContent: React.FC = () => {
           }
         } catch {}
         const sessionIds = [
-          `workspace-${task.id}`,
+          `task-${task.id}`,
           ...TERMINAL_PROVIDER_IDS.map((provider) => `${provider}-main-${task.id}`),
         ];
 

From 94ac7d0294cda301cf680f3aad66ae08c367d2c7 Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Mon, 15 Dec 2025 17:15:44 -0800
Subject: [PATCH 29/35] refactor: rename c7WorkspaceEnabled to c7TaskEnabled

---
 src/renderer/components/ProviderBar.tsx | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/renderer/components/ProviderBar.tsx b/src/renderer/components/ProviderBar.tsx
index 16c91819..86055fcb 100644
--- a/src/renderer/components/ProviderBar.tsx
+++ b/src/renderer/components/ProviderBar.tsx
@@ -59,7 +59,7 @@ export const ProviderBar: React.FC<Props> = ({
 }) => {
   const [c7Enabled, setC7Enabled] = React.useState<boolean>(false);
   const [c7Busy, setC7Busy] = React.useState<boolean>(false);
-  const [c7WorkspaceEnabled, setC7WorkspaceEnabled] = React.useState<boolean>(false);
+  const [c7TaskEnabled, setC7TaskEnabled] = React.useState<boolean>(false);
 
   React.useEffect(() => {
     let cancelled = false;
@@ -80,9 +80,9 @@ export const ProviderBar: React.FC<Props> = ({
   React.useEffect(() => {
     try {
       const key = `c7:ws:${taskId}`;
-      setC7WorkspaceEnabled(localStorage.getItem(key) === '1');
+      setC7TaskEnabled(localStorage.getItem(key) === '1');
     } catch {
-      setC7WorkspaceEnabled(false);
+      setC7TaskEnabled(false);
     }
   }, [taskId]);
 
@@ -91,12 +91,12 @@ export const ProviderBar: React.FC<Props> = ({
     try {
       if (!c7Enabled) return;
 
-      if (!c7WorkspaceEnabled) {
+      if (!c7TaskEnabled) {
         // Enable for this task and send invocation once
         try {
           localStorage.setItem(`c7:ws:${taskId}`, '1');
         } catch {}
-        setC7WorkspaceEnabled(true);
+        setC7TaskEnabled(true);
 
         const isTerminal = providerMeta[provider]?.terminalOnly === true;
         if (!isTerminal) return;
@@ -107,7 +107,7 @@ export const ProviderBar: React.FC<Props> = ({
         try {
           localStorage.removeItem(`c7:ws:${taskId}`);
         } catch {}
-        setC7WorkspaceEnabled(false);
+        setC7TaskEnabled(false);
       }
     } finally {
       setC7Busy(false);
@@ -401,13 +401,13 @@ export const ProviderBar: React.FC<Props> = ({
                       disabled={c7Busy || !c7Enabled}
                       className={[
                         'inline-flex h-7 items-center gap-1.5 rounded-md border px-2 text-xs',
-                        c7WorkspaceEnabled
+                        c7TaskEnabled
                           ? 'border-emerald-500/50 bg-emerald-500/10 text-foreground'
                           : 'border-gray-200 bg-gray-100 text-foreground dark:border-gray-700 dark:bg-gray-700',
                       ].join(' ')}
                       title={
                         c7Enabled
-                          ? c7WorkspaceEnabled
+                          ? c7TaskEnabled
                             ? 'Disable Context7 for this task'
                             : 'Enable for this task & send to terminal'
                           : 'Enable Context7 in Settings → MCP to use here'
@@ -431,7 +431,7 @@ export const ProviderBar: React.FC<Props> = ({
                     </button>
                   </TooltipTrigger>
                   <TooltipContent side="bottom" className="max-w-sm text-xs">
-                    <Context7Tooltip provider={provider} enabled={c7WorkspaceEnabled} />
+                    <Context7Tooltip provider={provider} enabled={c7TaskEnabled} />
                   </TooltipContent>
                 </Tooltip>
               </TooltipProvider>

From 44b741cc483f6a560259bea2224531431eb74595 Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Mon, 15 Dec 2025 17:54:27 -0800
Subject: [PATCH 30/35] format

---
 docs/sidebar-folders-plan.md                  | 116 ------------------
 drizzle/meta/0002_snapshot.json               |  46 ++-----
 drizzle/meta/_journal.json                    |   2 +-
 src/main/ipc/containerIpc.ts                  |   6 +-
 src/main/ipc/gitIpc.ts                        |  40 +++---
 src/main/ipc/hostPreviewIpc.ts                |  15 +--
 src/main/preload.ts                           |   6 +-
 src/main/services/GitService.ts               |   4 +-
 src/main/services/LinearService.ts            |   4 +-
 src/main/services/fsIpc.ts                    |   6 +-
 src/main/services/hostPreviewService.ts       |   5 +-
 src/renderer/App.tsx                          |  50 ++------
 .../components/AutoApproveIndicator.tsx       |   4 +-
 src/renderer/components/ChatInterface.tsx     |   5 +-
 src/renderer/components/FileChangesPanel.tsx  |   2 +-
 .../components/ProjectDeleteButton.tsx        |   2 +-
 src/renderer/components/RightSidebar.tsx      |   7 +-
 src/renderer/components/TaskDeleteButton.tsx  |   4 +-
 src/renderer/components/TaskItem.tsx          |  11 +-
 src/renderer/components/TaskList.tsx          |   7 +-
 src/renderer/components/TaskPorts.tsx         |   8 +-
 src/renderer/components/TaskTerminalPanel.tsx |   6 +-
 .../titlebar/BrowserToggleButton.tsx          |   6 +-
 src/renderer/hooks/useCreatePR.tsx            |   2 +-
 src/renderer/hooks/usePlanMode.ts             |   5 +-
 src/renderer/lib/containerRuns.ts             |   5 +-
 src/renderer/lib/taskTerminalsStore.ts        |   5 +-
 src/renderer/types/electron-api.d.ts          |   6 +-
 src/shared/container/mockRunner.ts            |   7 +-
 src/test/main/ContainerIpc.test.ts            |   5 +-
 30 files changed, 80 insertions(+), 317 deletions(-)
 delete mode 100644 docs/sidebar-folders-plan.md

diff --git a/docs/sidebar-folders-plan.md b/docs/sidebar-folders-plan.md
deleted file mode 100644
index 1dd1a87f..00000000
--- a/docs/sidebar-folders-plan.md
+++ /dev/null
@@ -1,116 +0,0 @@
-# Sidebar Task Folders Implementation Plan
-
-Issue: #390 - Worktree folders for short-term vs long-term tasks
-
-## Goal
-
-Allow users to organize tasks/workspaces into collapsible folders within each project.
-
-## Proposed Structure
-
-```
-📂 Project (SidebarGroup + Collapsible)
-├─ + Add Task
-├─ 📁 Folder "Active" (Collapsible) [optional]
-│  ├─ Task 1 (SidebarMenuSubItem)
-│  └─ Task 2
-├─ 📁 Folder "Backlog" (Collapsible) [optional]
-│  └─ Task 3
-├─ Task 4 (no folder - ungrouped)
-└─ Task 5 (no folder - ungrouped)
-```
-
-## Implementation Steps
-
-### Phase 1: UI Components ✅
-- [x] Add `SidebarMenuSub`, `SidebarMenuSubItem`, `SidebarMenuSubButton` to `sidebar.tsx`
-
-### Phase 2: Data Model ✅
-- [x] Add `folder` field to workspace schema (`src/main/db/schema.ts`)
-  ```typescript
-  folder: text('folder'), // null = ungrouped, string = folder name
-  ```
-- [ ] Create migration for the new field
-- [ ] Update `WorkspaceMetadata` type if needed
-- [ ] Update `DatabaseService` to handle folder field
-
-### Phase 3: Sidebar Rendering
-- [ ] Update `LeftSidebar.tsx` to group workspaces by folder
-- [ ] Render ungrouped tasks first (or last, TBD)
-- [ ] Render each folder as a collapsible section with `SidebarMenuSub`
-- [ ] Tasks inside folders use `SidebarMenuSubItem`
-
-### Phase 4: Folder Management UI
-- [ ] Add "Create Folder" button/option in project context menu
-- [ ] Add "Move to Folder" context menu on tasks
-- [ ] Allow renaming folders
-- [ ] Allow deleting folders (moves tasks to ungrouped)
-
-### Phase 5: Drag and Drop
-- [ ] Enable dragging tasks between folders
-- [ ] Enable dragging tasks out of folders (to ungrouped)
-- [ ] Enable reordering tasks within folders
-- [ ] Persist order in database
-
-### Phase 6: Polish
-- [ ] Remember folder collapsed/expanded state per project
-- [ ] Add folder icons
-- [ ] Keyboard navigation support
-
-## Component Hierarchy
-
-```tsx
-<Collapsible> {/* Project */}
-  <SidebarGroup>
-    <SidebarGroupLabel>
-      <CollapsibleTrigger>
-        Project Name <ChevronDown />
-      </CollapsibleTrigger>
-    </SidebarGroupLabel>
-    <CollapsibleContent>
-      <SidebarGroupContent>
-        <SidebarMenu>
-          {/* Add Task button */}
-          <SidebarMenuItem>...</SidebarMenuItem>
-
-          {/* Ungrouped tasks */}
-          <SidebarMenuItem>
-            <WorkspaceItem />
-          </SidebarMenuItem>
-
-          {/* Folder */}
-          <Collapsible>
-            <SidebarMenuItem>
-              <CollapsibleTrigger>
-                <SidebarMenuButton>
-                  Folder Name <ChevronDown />
-                </SidebarMenuButton>
-              </CollapsibleTrigger>
-              <CollapsibleContent>
-                <SidebarMenuSub>
-                  <SidebarMenuSubItem>
-                    <WorkspaceItem />
-                  </SidebarMenuSubItem>
-                </SidebarMenuSub>
-              </CollapsibleContent>
-            </SidebarMenuItem>
-          </Collapsible>
-        </SidebarMenu>
-      </SidebarGroupContent>
-    </CollapsibleContent>
-  </SidebarGroup>
-</Collapsible>
-```
-
-## Database Schema Change
-
-```sql
-ALTER TABLE workspaces ADD COLUMN folder TEXT;
-```
-
-## Notes
-
-- Folders are per-project (not global)
-- Folder names are simple strings (no separate folders table for MVP)
-- Empty folders can exist (user created but no tasks assigned)
-- Default folders could be suggested: "Active", "Backlog", "Done"
diff --git a/drizzle/meta/0002_snapshot.json b/drizzle/meta/0002_snapshot.json
index 3cb2e097..fc0d0457 100644
--- a/drizzle/meta/0002_snapshot.json
+++ b/drizzle/meta/0002_snapshot.json
@@ -48,9 +48,7 @@
       "indexes": {
         "idx_conversations_task_id": {
           "name": "idx_conversations_task_id",
-          "columns": [
-            "task_id"
-          ],
+          "columns": ["task_id"],
           "isUnique": false
         }
       },
@@ -59,12 +57,8 @@
           "name": "conversations_task_id_tasks_id_fk",
           "tableFrom": "conversations",
           "tableTo": "tasks",
-          "columnsFrom": [
-            "task_id"
-          ],
-          "columnsTo": [
-            "id"
-          ],
+          "columnsFrom": ["task_id"],
+          "columnsTo": ["id"],
           "onDelete": "cascade",
           "onUpdate": "no action"
         }
@@ -123,16 +117,12 @@
       "indexes": {
         "idx_messages_conversation_id": {
           "name": "idx_messages_conversation_id",
-          "columns": [
-            "conversation_id"
-          ],
+          "columns": ["conversation_id"],
           "isUnique": false
         },
         "idx_messages_timestamp": {
           "name": "idx_messages_timestamp",
-          "columns": [
-            "timestamp"
-          ],
+          "columns": ["timestamp"],
           "isUnique": false
         }
       },
@@ -141,12 +131,8 @@
           "name": "messages_conversation_id_conversations_id_fk",
           "tableFrom": "messages",
           "tableTo": "conversations",
-          "columnsFrom": [
-            "conversation_id"
-          ],
-          "columnsTo": [
-            "id"
-          ],
+          "columnsFrom": ["conversation_id"],
+          "columnsTo": ["id"],
           "onDelete": "cascade",
           "onUpdate": "no action"
         }
@@ -235,9 +221,7 @@
       "indexes": {
         "idx_projects_path": {
           "name": "idx_projects_path",
-          "columns": [
-            "path"
-          ],
+          "columns": ["path"],
           "isUnique": true
         }
       },
@@ -326,9 +310,7 @@
       "indexes": {
         "idx_tasks_project_id": {
           "name": "idx_tasks_project_id",
-          "columns": [
-            "project_id"
-          ],
+          "columns": ["project_id"],
           "isUnique": false
         }
       },
@@ -337,12 +319,8 @@
           "name": "tasks_project_id_projects_id_fk",
           "tableFrom": "tasks",
           "tableTo": "projects",
-          "columnsFrom": [
-            "project_id"
-          ],
-          "columnsTo": [
-            "id"
-          ],
+          "columnsFrom": ["project_id"],
+          "columnsTo": ["id"],
           "onDelete": "cascade",
           "onUpdate": "no action"
         }
@@ -366,4 +344,4 @@
   "internal": {
     "indexes": {}
   }
-}
\ No newline at end of file
+}
diff --git a/drizzle/meta/_journal.json b/drizzle/meta/_journal.json
index 82d78e8d..4f2cbf82 100644
--- a/drizzle/meta/_journal.json
+++ b/drizzle/meta/_journal.json
@@ -24,4 +24,4 @@
       "breakpoints": true
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/src/main/ipc/containerIpc.ts b/src/main/ipc/containerIpc.ts
index 330de69c..298eaa77 100644
--- a/src/main/ipc/containerIpc.ts
+++ b/src/main/ipc/containerIpc.ts
@@ -177,8 +177,7 @@ export function registerContainerIpc(): void {
       try {
         const service = typeof args?.service === 'string' ? args.service : '';
         const allowNetwork = args?.allowNetwork === true;
-        const taskPath =
-          typeof args?.taskPath === 'string' ? args.taskPath : undefined;
+        const taskPath = typeof args?.taskPath === 'string' ? args.taskPath : undefined;
         const res = await resolveServiceIcon({ service, allowNetwork, taskPath });
         if (res.ok) return { ok: true, dataUrl: res.dataUrl };
         return { ok: false };
@@ -229,8 +228,7 @@ function parseStartRunArgs(args: unknown): {
 
   const payload = args as Record<string, unknown>;
   const taskId = typeof payload.taskId === 'string' ? payload.taskId.trim() : '';
-  const taskPath =
-    typeof payload.taskPath === 'string' ? payload.taskPath.trim() : '';
+  const taskPath = typeof payload.taskPath === 'string' ? payload.taskPath.trim() : '';
   if (!taskId || !taskPath) {
     return null;
   }
diff --git a/src/main/ipc/gitIpc.ts b/src/main/ipc/gitIpc.ts
index a512f036..bc49b195 100644
--- a/src/main/ipc/gitIpc.ts
+++ b/src/main/ipc/gitIpc.ts
@@ -45,17 +45,14 @@ export function registerGitIpc() {
   });
 
   // Git: Per-file diff (moved from Codex IPC)
-  ipcMain.handle(
-    'git:get-file-diff',
-    async (_, args: { taskPath: string; filePath: string }) => {
-      try {
-        const diff = await gitGetFileDiff(args.taskPath, args.filePath);
-        return { success: true, diff };
-      } catch (error) {
-        return { success: false, error: error as string };
-      }
+  ipcMain.handle('git:get-file-diff', async (_, args: { taskPath: string; filePath: string }) => {
+    try {
+      const diff = await gitGetFileDiff(args.taskPath, args.filePath);
+      return { success: true, diff };
+    } catch (error) {
+      return { success: false, error: error as string };
     }
-  );
+  });
 
   // Git: Stage file
   ipcMain.handle('git:stage-file', async (_, args: { taskPath: string; filePath: string }) => {
@@ -71,20 +68,17 @@ export function registerGitIpc() {
   });
 
   // Git: Revert file
-  ipcMain.handle(
-    'git:revert-file',
-    async (_, args: { taskPath: string; filePath: string }) => {
-      try {
-        log.info('Reverting file:', { taskPath: args.taskPath, filePath: args.filePath });
-        const result = await gitRevertFile(args.taskPath, args.filePath);
-        log.info('File operation completed:', { filePath: args.filePath, action: result.action });
-        return { success: true, action: result.action };
-      } catch (error) {
-        log.error('Failed to revert file:', { filePath: args.filePath, error });
-        return { success: false, error: error instanceof Error ? error.message : String(error) };
-      }
+  ipcMain.handle('git:revert-file', async (_, args: { taskPath: string; filePath: string }) => {
+    try {
+      log.info('Reverting file:', { taskPath: args.taskPath, filePath: args.filePath });
+      const result = await gitRevertFile(args.taskPath, args.filePath);
+      log.info('File operation completed:', { filePath: args.filePath, action: result.action });
+      return { success: true, action: result.action };
+    } catch (error) {
+      log.error('Failed to revert file:', { filePath: args.filePath, error });
+      return { success: false, error: error instanceof Error ? error.message : String(error) };
     }
-  );
+  });
   // Git: Generate PR title and description
   ipcMain.handle(
     'git:generate-pr-content',
diff --git a/src/main/ipc/hostPreviewIpc.ts b/src/main/ipc/hostPreviewIpc.ts
index 8a5b6a97..7116d803 100644
--- a/src/main/ipc/hostPreviewIpc.ts
+++ b/src/main/ipc/hostPreviewIpc.ts
@@ -23,15 +23,12 @@ export function registerHostPreviewIpc() {
     }
   );
 
-  ipcMain.handle(
-    'preview:host:setup',
-    async (_e, args: { taskId: string; taskPath: string }) => {
-      const id = String(args?.taskId || '').trim();
-      const wp = String(args?.taskPath || '').trim();
-      if (!id || !wp) return { ok: false, error: 'taskId and taskPath are required' };
-      return hostPreviewService.setup(id, wp);
-    }
-  );
+  ipcMain.handle('preview:host:setup', async (_e, args: { taskId: string; taskPath: string }) => {
+    const id = String(args?.taskId || '').trim();
+    const wp = String(args?.taskPath || '').trim();
+    if (!id || !wp) return { ok: false, error: 'taskId and taskPath are required' };
+    return hostPreviewService.setup(id, wp);
+  });
 
   ipcMain.handle('preview:host:stop', async (_e, id: string) => {
     const wid = String(id || '').trim();
diff --git a/src/main/preload.ts b/src/main/preload.ts
index acb6d109..92cb40e1 100644
--- a/src/main/preload.ts
+++ b/src/main/preload.ts
@@ -161,10 +161,8 @@ contextBridge.exposeInMainWorld('electronAPI', {
     runId?: string;
     mode?: 'container' | 'host';
   }) => ipcRenderer.invoke('container:start-run', args),
-  stopContainerRun: (taskId: string) =>
-    ipcRenderer.invoke('container:stop-run', { taskId }),
-  inspectContainerRun: (taskId: string) =>
-    ipcRenderer.invoke('container:inspect-run', { taskId }),
+  stopContainerRun: (taskId: string) => ipcRenderer.invoke('container:stop-run', { taskId }),
+  inspectContainerRun: (taskId: string) => ipcRenderer.invoke('container:inspect-run', { taskId }),
   resolveServiceIcon: (args: { service: string; allowNetwork?: boolean; taskPath?: string }) =>
     ipcRenderer.invoke('icons:resolve-service', args),
   openExternal: (url: string) => ipcRenderer.invoke('app:openExternal', url),
diff --git a/src/main/services/GitService.ts b/src/main/services/GitService.ts
index 3f07fae7..dc13bb73 100644
--- a/src/main/services/GitService.ts
+++ b/src/main/services/GitService.ts
@@ -22,7 +22,7 @@ export async function getStatus(taskPath: string): Promise<GitChange[]> {
     return [];
   }
 
-const { stdout: statusOutput } = await execFileAsync(
+  const { stdout: statusOutput } = await execFileAsync(
     'git',
     ['status', '--porcelain', '--untracked-files=all'],
     {
@@ -136,7 +136,7 @@ export async function revertFile(
     }
   } catch {}
 
-// Check if file is tracked in git (exists in HEAD)
+  // Check if file is tracked in git (exists in HEAD)
   let fileExistsInHead = false;
   try {
     await execFileAsync('git', ['cat-file', '-e', `HEAD:${filePath}`], { cwd: taskPath });
diff --git a/src/main/services/LinearService.ts b/src/main/services/LinearService.ts
index 663c1b8e..08d4ebda 100644
--- a/src/main/services/LinearService.ts
+++ b/src/main/services/LinearService.ts
@@ -27,9 +27,7 @@ export class LinearService {
   private readonly SERVICE_NAME = 'emdash-linear';
   private readonly ACCOUNT_NAME = 'api-token';
 
-  async saveToken(
-    token: string
-  ): Promise<{ success: boolean; taskName?: string; error?: string }> {
+  async saveToken(token: string): Promise<{ success: boolean; taskName?: string; error?: string }> {
     try {
       const viewer = await this.fetchViewer(token);
       await this.storeToken(token);
diff --git a/src/main/services/fsIpc.ts b/src/main/services/fsIpc.ts
index f1d34a0a..44936bb9 100644
--- a/src/main/services/fsIpc.ts
+++ b/src/main/services/fsIpc.ts
@@ -171,11 +171,7 @@ export function registerFsIpc(): void {
           return { success: false, error: 'Unsupported attachment type' };
         }
 
-        const baseDir = path.join(
-          taskPath,
-          '.emdash',
-          args.subdir || DEFAULT_ATTACHMENTS_SUBDIR
-        );
+        const baseDir = path.join(taskPath, '.emdash', args.subdir || DEFAULT_ATTACHMENTS_SUBDIR);
         fs.mkdirSync(baseDir, { recursive: true });
 
         const baseName = path.basename(srcPath);
diff --git a/src/main/services/hostPreviewService.ts b/src/main/services/hostPreviewService.ts
index 54a7972e..f59227ee 100644
--- a/src/main/services/hostPreviewService.ts
+++ b/src/main/services/hostPreviewService.ts
@@ -40,10 +40,7 @@ class HostPreviewService extends EventEmitter {
   private procs = new Map<string, ChildProcessWithoutNullStreams>();
   private procCwds = new Map<string, string>(); // Track cwd for each taskId
 
-  async setup(
-    taskId: string,
-    taskPath: string
-  ): Promise<{ ok: boolean; error?: string }> {
+  async setup(taskId: string, taskPath: string): Promise<{ ok: boolean; error?: string }> {
     const cwd = path.resolve(taskPath);
     const pm = detectPackageManager(cwd);
     const cmd = pm;
diff --git a/src/renderer/App.tsx b/src/renderer/App.tsx
index 887c03dd..98a10b29 100644
--- a/src/renderer/App.tsx
+++ b/src/renderer/App.tsx
@@ -78,7 +78,6 @@ const RightSidebarBridge: React.FC<{
   return null;
 };
 
-
 const TITLEBAR_HEIGHT = '36px';
 const PANEL_LAYOUT_STORAGE_KEY = 'emdash.layout.left-main-right.v2';
 const DEFAULT_PANEL_LAYOUT: [number, number, number] = [20, 60, 20];
@@ -943,9 +942,7 @@ const AppContent: React.FC = () => {
       {
         if (taskMetadata?.linearIssue) {
           try {
-            const convoResult = await window.electronAPI.getOrCreateDefaultConversation(
-              newTask.id
-            );
+            const convoResult = await window.electronAPI.getOrCreateDefaultConversation(newTask.id);
 
             if (convoResult?.success && convoResult.conversation?.id) {
               const issue = taskMetadata.linearIssue;
@@ -995,9 +992,7 @@ const AppContent: React.FC = () => {
         }
         if (taskMetadata?.githubIssue) {
           try {
-            const convoResult = await window.electronAPI.getOrCreateDefaultConversation(
-              newTask.id
-            );
+            const convoResult = await window.electronAPI.getOrCreateDefaultConversation(newTask.id);
 
             if (convoResult?.success && convoResult.conversation?.id) {
               const issue = taskMetadata.githubIssue;
@@ -1053,9 +1048,7 @@ const AppContent: React.FC = () => {
         }
         if (taskMetadata?.jiraIssue) {
           try {
-            const convoResult = await window.electronAPI.getOrCreateDefaultConversation(
-              newTask.id
-            );
+            const convoResult = await window.electronAPI.getOrCreateDefaultConversation(newTask.id);
 
             if (convoResult?.success && convoResult.conversation?.id) {
               const issue: any = taskMetadata.jiraIssue;
@@ -1123,9 +1116,7 @@ const AppContent: React.FC = () => {
           setActiveTaskProvider(null);
         } else {
           // Use the saved agentId from the task, which should match primaryProvider
-          setActiveTaskProvider(
-            (newTask.agentId as Provider) || primaryProvider || 'codex'
-          );
+          setActiveTaskProvider((newTask.agentId as Provider) || primaryProvider || 'codex');
         }
       }
     } catch (error) {
@@ -1174,21 +1165,16 @@ const AppContent: React.FC = () => {
   );
 
   const removeTaskFromState = (projectId: string, taskId: string, wasActive: boolean) => {
-    const filterTasks = (list?: Task[]) =>
-      (list || []).filter((w) => w.id !== taskId);
+    const filterTasks = (list?: Task[]) => (list || []).filter((w) => w.id !== taskId);
 
     setProjects((prev) =>
       prev.map((project) =>
-        project.id === projectId
-          ? { ...project, tasks: filterTasks(project.tasks) }
-          : project
+        project.id === projectId ? { ...project, tasks: filterTasks(project.tasks) } : project
       )
     );
 
     setSelectedProject((prev) =>
-      prev && prev.id === projectId
-        ? { ...prev, tasks: filterTasks(prev.tasks) }
-        : prev
+      prev && prev.id === projectId ? { ...prev, tasks: filterTasks(prev.tasks) } : prev
     );
 
     if (wasActive) {
@@ -1312,15 +1298,11 @@ const AppContent: React.FC = () => {
           const refreshedTasks = await window.electronAPI.getTasks(targetProject.id);
           setProjects((prev) =>
             prev.map((project) =>
-              project.id === targetProject.id
-                ? { ...project, tasks: refreshedTasks }
-                : project
+              project.id === targetProject.id ? { ...project, tasks: refreshedTasks } : project
             )
           );
           setSelectedProject((prev) =>
-            prev && prev.id === targetProject.id
-              ? { ...prev, tasks: refreshedTasks }
-              : prev
+            prev && prev.id === targetProject.id ? { ...prev, tasks: refreshedTasks } : prev
           );
 
           if (wasActive) {
@@ -1337,18 +1319,14 @@ const AppContent: React.FC = () => {
               if (project.id !== targetProject.id) return project;
               const existing = project.tasks || [];
               const alreadyPresent = existing.some((w) => w.id === taskSnapshot.id);
-              return alreadyPresent
-                ? project
-                : { ...project, tasks: [taskSnapshot, ...existing] };
+              return alreadyPresent ? project : { ...project, tasks: [taskSnapshot, ...existing] };
             })
           );
           setSelectedProject((prev) => {
             if (!prev || prev.id !== targetProject.id) return prev;
             const existing = prev.tasks || [];
             const alreadyPresent = existing.some((w) => w.id === taskSnapshot.id);
-            return alreadyPresent
-              ? prev
-              : { ...prev, tasks: [taskSnapshot, ...existing] };
+            return alreadyPresent ? prev : { ...prev, tasks: [taskSnapshot, ...existing] };
           });
 
           if (wasActive) {
@@ -1657,9 +1635,7 @@ const AppContent: React.FC = () => {
                   : activeTask?.path || selectedProject?.path || null
               }
               defaultPreviewUrl={
-                activeTask?.id
-                  ? getContainerRunState(activeTask.id)?.previewUrl || null
-                  : null
+                activeTask?.id ? getContainerRunState(activeTask.id)?.previewUrl || null : null
               }
               taskId={activeTask?.id || null}
               taskPath={activeTask?.path || null}
@@ -1738,7 +1714,7 @@ const AppContent: React.FC = () => {
                   collapsible
                   order={3}
                 >
-<RightSidebar
+                  <RightSidebar
                     task={activeTask}
                     projectPath={selectedProject?.path || null}
                     className="lg:border-l-0"
diff --git a/src/renderer/components/AutoApproveIndicator.tsx b/src/renderer/components/AutoApproveIndicator.tsx
index 37ac7829..8e748ad6 100644
--- a/src/renderer/components/AutoApproveIndicator.tsx
+++ b/src/renderer/components/AutoApproveIndicator.tsx
@@ -31,8 +31,8 @@ const AutoApproveIndicator: React.FC<Props> = ({ enabled, className = '' }) => {
           <div>
             <span className="block font-medium">Auto-approve Enabled</span>
             <span className="block">
-              File operations are automatically approved without prompting. This task was
-              created with --dangerously-skip-permissions mode.
+              File operations are automatically approved without prompting. This task was created
+              with --dangerously-skip-permissions mode.
             </span>
           </div>
         </TooltipContent>
diff --git a/src/renderer/components/ChatInterface.tsx b/src/renderer/components/ChatInterface.tsx
index ba954a6f..4b5acc38 100644
--- a/src/renderer/components/ChatInterface.tsx
+++ b/src/renderer/components/ChatInterface.tsx
@@ -66,10 +66,7 @@ const ChatInterface: React.FC<Props> = ({
   useAutoScrollOnTaskSwitch(true, task.id);
 
   // Unified Plan Mode (per task)
-  const { enabled: planEnabled, setEnabled: setPlanEnabled } = usePlanMode(
-    task.id,
-    task.path
-  );
+  const { enabled: planEnabled, setEnabled: setPlanEnabled } = usePlanMode(task.id, task.path);
 
   // Log transitions for visibility
   useEffect(() => {
diff --git a/src/renderer/components/FileChangesPanel.tsx b/src/renderer/components/FileChangesPanel.tsx
index d3191215..808493aa 100644
--- a/src/renderer/components/FileChangesPanel.tsx
+++ b/src/renderer/components/FileChangesPanel.tsx
@@ -245,7 +245,7 @@ const FileChangesPanelComponent: React.FC<FileChangesPanelProps> = ({ taskId, cl
                   </span>
                 )}
               </div>
-<div className="flex items-center gap-2">
+              <div className="flex items-center gap-2">
                 <Button
                   variant="outline"
                   size="sm"
diff --git a/src/renderer/components/ProjectDeleteButton.tsx b/src/renderer/components/ProjectDeleteButton.tsx
index 406f3a44..07d0966d 100644
--- a/src/renderer/components/ProjectDeleteButton.tsx
+++ b/src/renderer/components/ProjectDeleteButton.tsx
@@ -107,7 +107,7 @@ export const ProjectDeleteButton: React.FC<Props> = ({
         <AlertDialogHeader>
           <AlertDialogTitle>Delete project?</AlertDialogTitle>
           <AlertDialogDescription>
-{`This removes "${projectName}" from Emdash, including its saved tasks and conversations. Files on disk are not deleted.`}
+            {`This removes "${projectName}" from Emdash, including its saved tasks and conversations. Files on disk are not deleted.`}
           </AlertDialogDescription>
         </AlertDialogHeader>
 
diff --git a/src/renderer/components/RightSidebar.tsx b/src/renderer/components/RightSidebar.tsx
index dbe9398b..8e2ab6f4 100644
--- a/src/renderer/components/RightSidebar.tsx
+++ b/src/renderer/components/RightSidebar.tsx
@@ -23,12 +23,7 @@ interface RightSidebarProps extends React.HTMLAttributes<HTMLElement> {
   projectPath?: string | null;
 }
 
-const RightSidebar: React.FC<RightSidebarProps> = ({
-  task,
-  projectPath,
-  className,
-  ...rest
-}) => {
+const RightSidebar: React.FC<RightSidebarProps> = ({ task, projectPath, className, ...rest }) => {
   const { collapsed } = useRightSidebar();
 
   // Detect multi-agent variants in task metadata
diff --git a/src/renderer/components/TaskDeleteButton.tsx b/src/renderer/components/TaskDeleteButton.tsx
index 2cb8016b..987b85da 100644
--- a/src/renderer/components/TaskDeleteButton.tsx
+++ b/src/renderer/components/TaskDeleteButton.tsx
@@ -148,9 +148,7 @@ export const TaskDeleteButton: React.FC<Props> = ({
                       'Status unavailable'}
                   </span>
                 </div>
-                {status.pr ? (
-                  <DeletePrNotice tasks={[{ name: taskName, pr: status.pr }]} />
-                ) : null}
+                {status.pr ? <DeletePrNotice tasks={[{ name: taskName, pr: status.pr }]} /> : null}
               </motion.div>
             ) : null}
           </AnimatePresence>
diff --git a/src/renderer/components/TaskItem.tsx b/src/renderer/components/TaskItem.tsx
index 063a2b0a..2e763849 100644
--- a/src/renderer/components/TaskItem.tsx
+++ b/src/renderer/components/TaskItem.tsx
@@ -23,15 +23,8 @@ interface TaskItemProps {
   showDelete?: boolean;
 }
 
-export const TaskItem: React.FC<TaskItemProps> = ({
-  task,
-  onDelete,
-  showDelete,
-}) => {
-  const { totalAdditions, totalDeletions, isLoading } = useTaskChanges(
-    task.path,
-    task.id
-  );
+export const TaskItem: React.FC<TaskItemProps> = ({ task, onDelete, showDelete }) => {
+  const { totalAdditions, totalDeletions, isLoading } = useTaskChanges(task.path, task.id);
   const { pr } = usePrStatus(task.path);
   const isRunning = useTaskBusy(task.id);
 
diff --git a/src/renderer/components/TaskList.tsx b/src/renderer/components/TaskList.tsx
index 952dfacd..5dc1fd9b 100644
--- a/src/renderer/components/TaskList.tsx
+++ b/src/renderer/components/TaskList.tsx
@@ -42,12 +42,7 @@ export const TaskList: React.FC<Props> = ({
     <div className="flex h-full flex-col p-4">
       <div className="mb-4 flex items-center justify-between">
         <h2 className="text-xl font-semibold">Tasks</h2>
-        <Button
-          variant="default"
-          size="sm"
-          onClick={onCreateTask}
-          disabled={isCreatingTask}
-        >
+        <Button variant="default" size="sm" onClick={onCreateTask} disabled={isCreatingTask}>
           {isCreatingTask ? (
             <>
               <Spinner size="sm" className="mr-2" />
diff --git a/src/renderer/components/TaskPorts.tsx b/src/renderer/components/TaskPorts.tsx
index ccd9d608..d5f8aea1 100644
--- a/src/renderer/components/TaskPorts.tsx
+++ b/src/renderer/components/TaskPorts.tsx
@@ -13,13 +13,7 @@ interface Props {
   previewService?: string;
 }
 
-const TaskPorts: React.FC<Props> = ({
-  taskId,
-  taskPath,
-  ports,
-  previewUrl,
-  previewService,
-}) => {
+const TaskPorts: React.FC<Props> = ({ taskId, taskPath, ports, previewUrl, previewService }) => {
   const [copiedKey, setCopiedKey] = useState<string | null>(null);
   const reduceMotion = useReducedMotion();
   const { toast } = useToast();
diff --git a/src/renderer/components/TaskTerminalPanel.tsx b/src/renderer/components/TaskTerminalPanel.tsx
index 2e2ed643..1047122a 100644
--- a/src/renderer/components/TaskTerminalPanel.tsx
+++ b/src/renderer/components/TaskTerminalPanel.tsx
@@ -39,7 +39,7 @@ const TaskTerminalPanelComponent: React.FC<Props> = ({
     }
   }, [task, mode]);
 
-const {
+  const {
     terminals,
     activeTerminalId,
     activeTerminal,
@@ -154,7 +154,7 @@ const {
     };
   }, [nativeTheme, defaultTheme]);
 
-if (!task && !projectPath) {
+  if (!task && !projectPath) {
     return (
       <div
         className={`flex h-full flex-col items-center justify-center bg-gray-50 dark:bg-gray-900 ${className}`}
@@ -299,7 +299,7 @@ if (!task && !projectPath) {
             : 'bg-white'
         )}
       >
-{terminals.map((terminal) => {
+        {terminals.map((terminal) => {
           const cwd =
             terminal.cwd ||
             (mode === 'global' ? projectPath || terminal.cwd : task?.path || terminal.cwd);
diff --git a/src/renderer/components/titlebar/BrowserToggleButton.tsx b/src/renderer/components/titlebar/BrowserToggleButton.tsx
index 854f63c4..2832b404 100644
--- a/src/renderer/components/titlebar/BrowserToggleButton.tsx
+++ b/src/renderer/components/titlebar/BrowserToggleButton.tsx
@@ -20,11 +20,7 @@ interface Props {
   parentProjectPath?: string | null;
 }
 
-const BrowserToggleButton: React.FC<Props> = ({
-  taskId,
-  taskPath,
-  parentProjectPath,
-}) => {
+const BrowserToggleButton: React.FC<Props> = ({ taskId, taskPath, parentProjectPath }) => {
   const browser = useBrowser();
   async function needsInstall(path?: string | null): Promise<boolean> {
     const p = (path || '').trim();
diff --git a/src/renderer/hooks/useCreatePR.tsx b/src/renderer/hooks/useCreatePR.tsx
index 7e4b73c5..c659fdc9 100644
--- a/src/renderer/hooks/useCreatePR.tsx
+++ b/src/renderer/hooks/useCreatePR.tsx
@@ -44,7 +44,7 @@ export function useCreatePR() {
         return { success: false, error: 'Electron bridge unavailable' } as any;
       }
 
-// Auto-generate PR title and description if not provided
+      // Auto-generate PR title and description if not provided
       let finalPrOptions = { ...(prOptions || {}) };
 
       if (!finalPrOptions.title || !finalPrOptions.body) {
diff --git a/src/renderer/hooks/usePlanMode.ts b/src/renderer/hooks/usePlanMode.ts
index a6303ede..3cdf05c9 100644
--- a/src/renderer/hooks/usePlanMode.ts
+++ b/src/renderer/hooks/usePlanMode.ts
@@ -181,10 +181,7 @@ export function usePlanMode(taskId: string, taskPath: string) {
           const lock = await (window as any).electronAPI.planApplyLock(taskPath);
           if (!lock?.success) log.warn('[plan] failed to apply lock', lock?.error);
           else
-            await logPlanEvent(
-              taskPath,
-              `Applied read-only lock (changed=${lock.changed ?? 0})`
-            );
+            await logPlanEvent(taskPath, `Applied read-only lock (changed=${lock.changed ?? 0})`);
         } catch (e) {
           log.warn('[plan] planApplyLock error', e);
         }
diff --git a/src/renderer/lib/containerRuns.ts b/src/renderer/lib/containerRuns.ts
index 526ef38f..b79cdd40 100644
--- a/src/renderer/lib/containerRuns.ts
+++ b/src/renderer/lib/containerRuns.ts
@@ -175,10 +175,7 @@ export function subscribeToContainerRuns(listener: Listener): () => void {
   };
 }
 
-export function subscribeToTaskRunState(
-  taskId: string,
-  listener: TaskListener
-): () => void {
+export function subscribeToTaskRunState(taskId: string, listener: TaskListener): () => void {
   ensureSubscribed();
   const set = taskListeners.get(taskId) ?? new Set<TaskListener>();
   set.add(listener);
diff --git a/src/renderer/lib/taskTerminalsStore.ts b/src/renderer/lib/taskTerminalsStore.ts
index 4ec71a39..1af5d1e1 100644
--- a/src/renderer/lib/taskTerminalsStore.ts
+++ b/src/renderer/lib/taskTerminalsStore.ts
@@ -158,10 +158,7 @@ function ensureSnapshot(taskId: string, state: TaskTerminalsState) {
   return taskSnapshots.get(taskId)!;
 }
 
-function ensureTaskState(
-  taskId: string,
-  taskPath?: string
-): TaskTerminalsState {
+function ensureTaskState(taskId: string, taskPath?: string): TaskTerminalsState {
   let state = taskStates.get(taskId);
   if (state) {
     ensureSnapshot(taskId, state);
diff --git a/src/renderer/types/electron-api.d.ts b/src/renderer/types/electron-api.d.ts
index 40c420ff..131b8103 100644
--- a/src/renderer/types/electron-api.d.ts
+++ b/src/renderer/types/electron-api.d.ts
@@ -435,11 +435,7 @@ declare global {
       ) => Promise<{ success: boolean; error?: string }>;
       fsRemove: (root: string, relPath: string) => Promise<{ success: boolean; error?: string }>;
       // Attachments
-      saveAttachment: (args: {
-        taskPath: string;
-        srcPath: string;
-        subdir?: string;
-      }) => Promise<{
+      saveAttachment: (args: { taskPath: string; srcPath: string; subdir?: string }) => Promise<{
         success: boolean;
         absPath?: string;
         relPath?: string;
diff --git a/src/shared/container/mockRunner.ts b/src/shared/container/mockRunner.ts
index eece9bdd..cf426a6a 100644
--- a/src/shared/container/mockRunner.ts
+++ b/src/shared/container/mockRunner.ts
@@ -39,12 +39,7 @@ function createTimestampGenerator(now: () => number): () => number {
   return () => now();
 }
 
-function createEventBase(
-  taskId: string,
-  runId: string,
-  mode: RunnerMode,
-  nextTs: () => number
-) {
+function createEventBase(taskId: string, runId: string, mode: RunnerMode, nextTs: () => number) {
   return {
     taskId,
     runId,
diff --git a/src/test/main/ContainerIpc.test.ts b/src/test/main/ContainerIpc.test.ts
index fef68a68..a5293421 100644
--- a/src/test/main/ContainerIpc.test.ts
+++ b/src/test/main/ContainerIpc.test.ts
@@ -209,10 +209,7 @@ describe('registerContainerIpc', () => {
       registerContainerIpc();
       const handler = getHandler('container:start-run');
 
-      const result = await handler(
-        {},
-        { taskId: ' ws-1 ', taskPath: ' /tmp/task ' }
-      );
+      const result = await handler({}, { taskId: ' ws-1 ', taskPath: ' /tmp/task ' });
 
       expect(startRunMock).toHaveBeenCalledWith({
         taskId: 'ws-1',

From 6ea4e3f51cafc049d2a16d7b4bd97b759b622039 Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Mon, 15 Dec 2025 18:10:56 -0800
Subject: [PATCH 31/35] refactor: rename generatePrContent workspacePath to
 taskPath

Updates the PR generation API to use taskPath consistently with other
git operations. Also renames getWorkspaceByPath to getTaskByPath in
DatabaseService.
---
 src/main/ipc/gitIpc.ts               | 20 ++++++++++----------
 src/main/preload.ts                  |  2 +-
 src/main/services/DatabaseService.ts |  8 ++++----
 src/renderer/hooks/useCreatePR.tsx   |  2 +-
 src/renderer/types/electron-api.d.ts |  2 +-
 5 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/src/main/ipc/gitIpc.ts b/src/main/ipc/gitIpc.ts
index bc49b195..9331b333 100644
--- a/src/main/ipc/gitIpc.ts
+++ b/src/main/ipc/gitIpc.ts
@@ -85,27 +85,27 @@ export function registerGitIpc() {
     async (
       _,
       args: {
-        workspacePath: string;
+        taskPath: string;
         base?: string;
       }
     ) => {
-      const { workspacePath, base = 'main' } =
-        args || ({} as { workspacePath: string; base?: string });
+      const { taskPath, base = 'main' } =
+        args || ({} as { taskPath: string; base?: string });
       try {
-        // Try to get the workspace to find which provider was used
+        // Try to get the task to find which provider was used
         let providerId: string | null = null;
         try {
-          const workspace = await databaseService.getWorkspaceByPath(workspacePath);
-          if (workspace?.agentId) {
-            providerId = workspace.agentId;
-            log.debug('Found workspace provider for PR generation', { workspacePath, providerId });
+          const task = await databaseService.getTaskByPath(taskPath);
+          if (task?.agentId) {
+            providerId = task.agentId;
+            log.debug('Found task provider for PR generation', { taskPath, providerId });
           }
         } catch (error) {
-          log.debug('Could not lookup workspace provider', { error });
+          log.debug('Could not lookup task provider', { error });
           // Non-fatal - continue without provider
         }
 
-        const result = await prGenerationService.generatePrContent(workspacePath, base, providerId);
+        const result = await prGenerationService.generatePrContent(taskPath, base, providerId);
         return { success: true, ...result };
       } catch (error) {
         log.error('Failed to generate PR content:', error);
diff --git a/src/main/preload.ts b/src/main/preload.ts
index 92cb40e1..513b241a 100644
--- a/src/main/preload.ts
+++ b/src/main/preload.ts
@@ -136,7 +136,7 @@ contextBridge.exposeInMainWorld('electronAPI', {
     createBranchIfOnDefault?: boolean;
     branchPrefix?: string;
   }) => ipcRenderer.invoke('git:commit-and-push', args),
-  generatePrContent: (args: { workspacePath: string; base?: string }) =>
+  generatePrContent: (args: { taskPath: string; base?: string }) =>
     ipcRenderer.invoke('git:generate-pr-content', args),
   createPullRequest: (args: {
     taskPath: string;
diff --git a/src/main/services/DatabaseService.ts b/src/main/services/DatabaseService.ts
index 9a7163b8..0f5f3d75 100644
--- a/src/main/services/DatabaseService.ts
+++ b/src/main/services/DatabaseService.ts
@@ -258,18 +258,18 @@ export class DatabaseService {
     return rows.map((row) => this.mapDrizzleTaskRow(row));
   }
 
-  async getWorkspaceByPath(workspacePath: string): Promise<Workspace | null> {
+  async getTaskByPath(taskPath: string): Promise<Task | null> {
     if (this.disabled) return null;
     const { db } = await getDrizzleClient();
 
     const rows = await db
       .select()
-      .from(workspacesTable)
-      .where(eq(workspacesTable.path, workspacePath))
+      .from(tasksTable)
+      .where(eq(tasksTable.path, taskPath))
       .limit(1);
 
     if (rows.length === 0) return null;
-    return this.mapDrizzleWorkspaceRow(rows[0]);
+    return this.mapDrizzleTaskRow(rows[0]);
   }
 
   async deleteProject(projectId: string): Promise<void> {
diff --git a/src/renderer/hooks/useCreatePR.tsx b/src/renderer/hooks/useCreatePR.tsx
index c659fdc9..a3319114 100644
--- a/src/renderer/hooks/useCreatePR.tsx
+++ b/src/renderer/hooks/useCreatePR.tsx
@@ -61,7 +61,7 @@ export function useCreatePR() {
           // Generate PR content
           if (api.generatePrContent) {
             const generated = await api.generatePrContent({
-              workspacePath: taskPath,
+              taskPath,
               base: finalPrOptions.base || defaultBranch,
             });
 
diff --git a/src/renderer/types/electron-api.d.ts b/src/renderer/types/electron-api.d.ts
index 131b8103..e6aef1e2 100644
--- a/src/renderer/types/electron-api.d.ts
+++ b/src/renderer/types/electron-api.d.ts
@@ -254,7 +254,7 @@ declare global {
         output?: string;
         error?: string;
       }>;
-      generatePrContent: (args: { workspacePath: string; base?: string }) => Promise<{
+      generatePrContent: (args: { taskPath: string; base?: string }) => Promise<{
         success: boolean;
         title?: string;
         description?: string;

From b8823fb5140aa3190ef7f14acf22e9193ae52b20 Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Mon, 15 Dec 2025 18:12:32 -0800
Subject: [PATCH 32/35] fix: revert Linear workspaceName rename

workspaceName refers to Linear's organization/workspace concept, not
emdash's task concept. Should not have been renamed.
---
 src/main/services/LinearService.ts | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/main/services/LinearService.ts b/src/main/services/LinearService.ts
index 08d4ebda..858c3acd 100644
--- a/src/main/services/LinearService.ts
+++ b/src/main/services/LinearService.ts
@@ -13,7 +13,7 @@ export interface LinearViewer {
 
 export interface LinearConnectionStatus {
   connected: boolean;
-  taskName?: string;
+  workspaceName?: string;
   viewer?: LinearViewer;
   error?: string;
 }
@@ -27,7 +27,7 @@ export class LinearService {
   private readonly SERVICE_NAME = 'emdash-linear';
   private readonly ACCOUNT_NAME = 'api-token';
 
-  async saveToken(token: string): Promise<{ success: boolean; taskName?: string; error?: string }> {
+  async saveToken(token: string): Promise<{ success: boolean; workspaceName?: string; error?: string }> {
     try {
       const viewer = await this.fetchViewer(token);
       await this.storeToken(token);
@@ -37,7 +37,7 @@ export class LinearService {
       });
       return {
         success: true,
-        taskName: viewer?.organization?.name ?? viewer?.displayName ?? undefined,
+        workspaceName: viewer?.organization?.name ?? viewer?.displayName ?? undefined,
       };
     } catch (error) {
       const message =
@@ -76,7 +76,7 @@ export class LinearService {
       const viewer = await this.fetchViewer(token);
       return {
         connected: true,
-        taskName: viewer?.organization?.name ?? viewer?.displayName ?? undefined,
+        workspaceName: viewer?.organization?.name ?? viewer?.displayName ?? undefined,
         viewer,
       };
     } catch (error) {

From 40a1fb0efeaa5eb0b8cfe82495837c0153d83792 Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Mon, 15 Dec 2025 18:12:51 -0800
Subject: [PATCH 33/35] format

---
 src/main/ipc/gitIpc.ts               | 3 +--
 src/main/services/DatabaseService.ts | 6 +-----
 src/main/services/LinearService.ts   | 4 +++-
 3 files changed, 5 insertions(+), 8 deletions(-)

diff --git a/src/main/ipc/gitIpc.ts b/src/main/ipc/gitIpc.ts
index 9331b333..629f7ceb 100644
--- a/src/main/ipc/gitIpc.ts
+++ b/src/main/ipc/gitIpc.ts
@@ -89,8 +89,7 @@ export function registerGitIpc() {
         base?: string;
       }
     ) => {
-      const { taskPath, base = 'main' } =
-        args || ({} as { taskPath: string; base?: string });
+      const { taskPath, base = 'main' } = args || ({} as { taskPath: string; base?: string });
       try {
         // Try to get the task to find which provider was used
         let providerId: string | null = null;
diff --git a/src/main/services/DatabaseService.ts b/src/main/services/DatabaseService.ts
index 0f5f3d75..bc548489 100644
--- a/src/main/services/DatabaseService.ts
+++ b/src/main/services/DatabaseService.ts
@@ -262,11 +262,7 @@ export class DatabaseService {
     if (this.disabled) return null;
     const { db } = await getDrizzleClient();
 
-    const rows = await db
-      .select()
-      .from(tasksTable)
-      .where(eq(tasksTable.path, taskPath))
-      .limit(1);
+    const rows = await db.select().from(tasksTable).where(eq(tasksTable.path, taskPath)).limit(1);
 
     if (rows.length === 0) return null;
     return this.mapDrizzleTaskRow(rows[0]);
diff --git a/src/main/services/LinearService.ts b/src/main/services/LinearService.ts
index 858c3acd..1cb5311c 100644
--- a/src/main/services/LinearService.ts
+++ b/src/main/services/LinearService.ts
@@ -27,7 +27,9 @@ export class LinearService {
   private readonly SERVICE_NAME = 'emdash-linear';
   private readonly ACCOUNT_NAME = 'api-token';
 
-  async saveToken(token: string): Promise<{ success: boolean; workspaceName?: string; error?: string }> {
+  async saveToken(
+    token: string
+  ): Promise<{ success: boolean; workspaceName?: string; error?: string }> {
     try {
       const viewer = await this.fetchViewer(token);
       await this.storeToken(token);

From dcbae423e116af8390edc7e4de85d9fcc8ba3ff6 Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Thu, 18 Dec 2025 13:05:19 -0800
Subject: [PATCH 34/35] fix: rename remaining workspace references to task
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- PrGenerationService: workspacePath → taskPath (all params & comments)
- ProjectDeleteButton: 'Checking workspaces...' → 'Checking tasks...'
- TerminalSessionManager: update comment workspaceId → taskId
- AllChangesDiffModal: workspacePath → taskPath (prop & all usages)
- FileChangesPanel: fix workspaceId → taskId in AllChangesDiffModal

These were introduced in the merge from origin/main and needed to
be updated to match the workspace→task rename refactor.
---
 src/main/services/PrGenerationService.ts      | 46 +++++++++----------
 .../components/AllChangesDiffModal.tsx        | 12 ++---
 src/renderer/components/FileChangesPanel.tsx  |  2 +-
 .../components/ProjectDeleteButton.tsx        |  2 +-
 .../terminal/TerminalSessionManager.ts        |  2 +-
 5 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/src/main/services/PrGenerationService.ts b/src/main/services/PrGenerationService.ts
index aff76fc3..8d22f484 100644
--- a/src/main/services/PrGenerationService.ts
+++ b/src/main/services/PrGenerationService.ts
@@ -17,34 +17,34 @@ export interface GeneratedPrContent {
 export class PrGenerationService {
   /**
    * Generate PR title and description based on git changes
-   * @param workspacePath - Path to the workspace
+   * @param taskPath - Path to the task
    * @param baseBranch - Base branch to compare against (default: 'main')
-   * @param preferredProviderId - Optional provider ID to use first (e.g., from workspace.agentId)
+   * @param preferredProviderId - Optional provider ID to use first (e.g., from task.agentId)
    */
   async generatePrContent(
-    workspacePath: string,
+    taskPath: string,
     baseBranch: string = 'main',
     preferredProviderId?: string | null
   ): Promise<GeneratedPrContent> {
     try {
       // Get git diff and commit messages
-      const { diff, commits, changedFiles } = await this.getGitContext(workspacePath, baseBranch);
+      const { diff, commits, changedFiles } = await this.getGitContext(taskPath, baseBranch);
 
       if (!diff && commits.length === 0) {
         return this.generateFallbackContent(changedFiles);
       }
 
-      // Try the workspace's provider first if specified
+      // Try the task's provider first if specified
       if (preferredProviderId && this.isValidProviderId(preferredProviderId)) {
         try {
           const preferredResult = await this.generateWithProvider(
             preferredProviderId as ProviderId,
-            workspacePath,
+            taskPath,
             diff,
             commits
           );
           if (preferredResult) {
-            log.info(`Generated PR content with workspace provider: ${preferredProviderId}`);
+            log.info(`Generated PR content with task provider: ${preferredProviderId}`);
             return {
               title: preferredResult.title,
               description: this.normalizeMarkdown(preferredResult.description),
@@ -52,7 +52,7 @@ export class PrGenerationService {
           }
         } catch (error) {
           log.debug(
-            `Workspace provider ${preferredProviderId} generation failed, trying fallbacks`,
+            `Task provider ${preferredProviderId} generation failed, trying fallbacks`,
             {
               error,
             }
@@ -64,7 +64,7 @@ export class PrGenerationService {
       try {
         const claudeResult = await this.generateWithProvider(
           'claude',
-          workspacePath,
+          taskPath,
           diff,
           commits
         );
@@ -81,7 +81,7 @@ export class PrGenerationService {
 
       // Try Codex as fallback
       try {
-        const codexResult = await this.generateWithProvider('codex', workspacePath, diff, commits);
+        const codexResult = await this.generateWithProvider('codex', taskPath, diff, commits);
         if (codexResult) {
           log.info('Generated PR content with Codex');
           return {
@@ -105,7 +105,7 @@ export class PrGenerationService {
    * Get git context (diff, commits, changed files) for PR generation
    */
   private async getGitContext(
-    workspacePath: string,
+    taskPath: string,
     baseBranch: string
   ): Promise<{ diff: string; commits: string[]; changedFiles: string[] }> {
     let diff = '';
@@ -116,11 +116,11 @@ export class PrGenerationService {
       // Check if base branch exists (local or remote)
       let baseBranchExists = false;
       try {
-        await execAsync(`git rev-parse --verify ${baseBranch}`, { cwd: workspacePath });
+        await execAsync(`git rev-parse --verify ${baseBranch}`, { cwd: taskPath });
         baseBranchExists = true;
       } catch {
         try {
-          await execAsync(`git rev-parse --verify origin/${baseBranch}`, { cwd: workspacePath });
+          await execAsync(`git rev-parse --verify origin/${baseBranch}`, { cwd: taskPath });
           baseBranchExists = true;
           baseBranch = `origin/${baseBranch}`;
         } catch {
@@ -132,7 +132,7 @@ export class PrGenerationService {
         // Get diff between base branch and current HEAD (committed changes)
         try {
           const { stdout: diffOut } = await execAsync(`git diff ${baseBranch}...HEAD --stat`, {
-            cwd: workspacePath,
+            cwd: taskPath,
             maxBuffer: 10 * 1024 * 1024,
           });
           diff = diffOut || '';
@@ -140,7 +140,7 @@ export class PrGenerationService {
           // Get list of changed files from commits
           const { stdout: filesOut } = await execAsync(
             `git diff --name-only ${baseBranch}...HEAD`,
-            { cwd: workspacePath }
+            { cwd: taskPath }
           );
           const committedFiles = (filesOut || '')
             .split('\n')
@@ -151,7 +151,7 @@ export class PrGenerationService {
           // Get commit messages
           const { stdout: commitsOut } = await execAsync(
             `git log ${baseBranch}..HEAD --pretty=format:"%s"`,
-            { cwd: workspacePath }
+            { cwd: taskPath }
           );
           commits = (commitsOut || '')
             .split('\n')
@@ -166,7 +166,7 @@ export class PrGenerationService {
       // This ensures PR description includes changes that will be committed
       try {
         const { stdout: workingDiff } = await execAsync('git diff --stat', {
-          cwd: workspacePath,
+          cwd: taskPath,
           maxBuffer: 10 * 1024 * 1024,
         });
         const workingDiffText = workingDiff || '';
@@ -182,7 +182,7 @@ export class PrGenerationService {
 
         // Get uncommitted changed files and merge with committed files
         const { stdout: filesOut } = await execAsync('git diff --name-only', {
-          cwd: workspacePath,
+          cwd: taskPath,
         });
         const uncommittedFiles = (filesOut || '')
           .split('\n')
@@ -200,13 +200,13 @@ export class PrGenerationService {
       if (commits.length === 0 && diff.length === 0) {
         try {
           const { stdout: stagedDiff } = await execAsync('git diff --cached --stat', {
-            cwd: workspacePath,
+            cwd: taskPath,
             maxBuffer: 10 * 1024 * 1024,
           });
           if (stagedDiff) {
             diff = stagedDiff;
             const { stdout: filesOut } = await execAsync('git diff --cached --name-only', {
-              cwd: workspacePath,
+              cwd: taskPath,
             });
             changedFiles = (filesOut || '')
               .split('\n')
@@ -227,7 +227,7 @@ export class PrGenerationService {
    */
   private async generateWithProvider(
     providerId: ProviderId,
-    workspacePath: string,
+    taskPath: string,
     diff: string,
     commits: string[]
   ): Promise<GeneratedPrContent | null> {
@@ -244,7 +244,7 @@ export class PrGenerationService {
     // Check if provider CLI is available
     try {
       await execFileAsync(cliCommand, provider.versionArgs || ['--version'], {
-        cwd: workspacePath,
+        cwd: taskPath,
       });
     } catch {
       log.debug(`Provider ${providerId} CLI not available`);
@@ -282,7 +282,7 @@ export class PrGenerationService {
 
       // Spawn the provider CLI
       const child = spawn(cliCommand, args, {
-        cwd: workspacePath,
+        cwd: taskPath,
         stdio: ['pipe', 'pipe', 'pipe'],
         env: {
           ...process.env,
diff --git a/src/renderer/components/AllChangesDiffModal.tsx b/src/renderer/components/AllChangesDiffModal.tsx
index 4a384274..aaf40a7b 100644
--- a/src/renderer/components/AllChangesDiffModal.tsx
+++ b/src/renderer/components/AllChangesDiffModal.tsx
@@ -18,7 +18,7 @@ import { useTheme } from '../hooks/useTheme';
 interface AllChangesDiffModalProps {
   open: boolean;
   onClose: () => void;
-  workspacePath: string;
+  taskPath: string;
   files: FileChange[];
   onRefreshChanges?: () => Promise<void> | void;
 }
@@ -35,7 +35,7 @@ interface FileDiffData {
 export const AllChangesDiffModal: React.FC<AllChangesDiffModalProps> = ({
   open,
   onClose,
-  workspacePath,
+  taskPath,
   files,
   onRefreshChanges,
 }) => {
@@ -91,7 +91,7 @@ export const AllChangesDiffModal: React.FC<AllChangesDiffModalProps> = ({
 
       try {
         // Get diff lines
-        const diffRes = await window.electronAPI.getFileDiff({ workspacePath, filePath });
+        const diffRes = await window.electronAPI.getFileDiff({ taskPath, filePath });
         if (!diffRes?.success || !diffRes.diff) {
           throw new Error(diffRes?.error || 'Failed to load diff');
         }
@@ -113,7 +113,7 @@ export const AllChangesDiffModal: React.FC<AllChangesDiffModalProps> = ({
           modifiedContent = '';
         } else if (file.status === 'added') {
           // Read current file content
-          const readRes = await window.electronAPI.fsRead(workspacePath, filePath, 2 * 1024 * 1024);
+          const readRes = await window.electronAPI.fsRead(taskPath, filePath, 2 * 1024 * 1024);
           if (readRes?.success && readRes.content) {
             modifiedContent = readRes.content;
             originalContent = '';
@@ -132,7 +132,7 @@ export const AllChangesDiffModal: React.FC<AllChangesDiffModalProps> = ({
           // Try to read actual current content for better accuracy
           try {
             const readRes = await window.electronAPI.fsRead(
-              workspacePath,
+              taskPath,
               filePath,
               2 * 1024 * 1024
             );
@@ -178,7 +178,7 @@ export const AllChangesDiffModal: React.FC<AllChangesDiffModalProps> = ({
         loadFileData(file);
       }
     });
-  }, [open, files, workspacePath]);
+  }, [open, files, taskPath]);
 
   // Add custom scrollbar styles and Monaco theme
   useEffect(() => {
diff --git a/src/renderer/components/FileChangesPanel.tsx b/src/renderer/components/FileChangesPanel.tsx
index 86d83df2..165ff90d 100644
--- a/src/renderer/components/FileChangesPanel.tsx
+++ b/src/renderer/components/FileChangesPanel.tsx
@@ -501,7 +501,7 @@ const FileChangesPanelComponent: React.FC<FileChangesPanelProps> = ({ taskId, cl
         <AllChangesDiffModal
           open={showAllChangesModal}
           onClose={() => setShowAllChangesModal(false)}
-          workspacePath={workspaceId}
+          taskPath={taskId}
           files={fileChanges}
           onRefreshChanges={refreshChanges}
         />
diff --git a/src/renderer/components/ProjectDeleteButton.tsx b/src/renderer/components/ProjectDeleteButton.tsx
index 56ae8be3..74a4619b 100644
--- a/src/renderer/components/ProjectDeleteButton.tsx
+++ b/src/renderer/components/ProjectDeleteButton.tsx
@@ -257,7 +257,7 @@ export const ProjectDeleteButton: React.FC<Props> = ({
               {disableDelete && !isDeleting ? (
                 <TooltipContent side="top" className="text-xs">
                   {loading
-                    ? 'Checking workspaces...'
+                    ? 'Checking tasks...'
                     : hasRisks && !acknowledge
                       ? 'Acknowledge the risks to delete'
                       : 'Delete is disabled'}
diff --git a/src/renderer/terminal/TerminalSessionManager.ts b/src/renderer/terminal/TerminalSessionManager.ts
index 6fb83485..2d65e4f0 100644
--- a/src/renderer/terminal/TerminalSessionManager.ts
+++ b/src/renderer/terminal/TerminalSessionManager.ts
@@ -471,7 +471,7 @@ export class TerminalSessionManager {
 
   /**
    * Check if this terminal ID is a provider CLI that supports native resume.
-   * Provider CLIs use the format: `${provider}-main-${workspaceId}`
+   * Provider CLIs use the format: `${provider}-main-${taskId}`
    * If the provider has a resumeFlag, we skip snapshot restoration to avoid duplicate history.
    */
   private isProviderWithResume(id: string): boolean {

From 277f8fa70a87aa2e49037c3ddbd92a305bd31600 Mon Sep 17 00:00:00 2001
From: Raban von Spiegel <rabanspiegel@gmail.com>
Date: Thu, 18 Dec 2025 13:20:12 -0800
Subject: [PATCH 35/35] format

---
 src/main/services/PrGenerationService.ts        | 16 ++++------------
 src/renderer/components/AllChangesDiffModal.tsx |  6 +-----
 src/renderer/components/ChangesDiffModal.tsx    |  6 +-----
 3 files changed, 6 insertions(+), 22 deletions(-)

diff --git a/src/main/services/PrGenerationService.ts b/src/main/services/PrGenerationService.ts
index 8d22f484..24f0a28b 100644
--- a/src/main/services/PrGenerationService.ts
+++ b/src/main/services/PrGenerationService.ts
@@ -51,23 +51,15 @@ export class PrGenerationService {
             };
           }
         } catch (error) {
-          log.debug(
-            `Task provider ${preferredProviderId} generation failed, trying fallbacks`,
-            {
-              error,
-            }
-          );
+          log.debug(`Task provider ${preferredProviderId} generation failed, trying fallbacks`, {
+            error,
+          });
         }
       }
 
       // Try Claude Code as fallback (preferred default)
       try {
-        const claudeResult = await this.generateWithProvider(
-          'claude',
-          taskPath,
-          diff,
-          commits
-        );
+        const claudeResult = await this.generateWithProvider('claude', taskPath, diff, commits);
         if (claudeResult) {
           log.info('Generated PR content with Claude Code');
           return {
diff --git a/src/renderer/components/AllChangesDiffModal.tsx b/src/renderer/components/AllChangesDiffModal.tsx
index aaf40a7b..fdf2bcd3 100644
--- a/src/renderer/components/AllChangesDiffModal.tsx
+++ b/src/renderer/components/AllChangesDiffModal.tsx
@@ -131,11 +131,7 @@ export const AllChangesDiffModal: React.FC<AllChangesDiffModalProps> = ({
 
           // Try to read actual current content for better accuracy
           try {
-            const readRes = await window.electronAPI.fsRead(
-              taskPath,
-              filePath,
-              2 * 1024 * 1024
-            );
+            const readRes = await window.electronAPI.fsRead(taskPath, filePath, 2 * 1024 * 1024);
             if (readRes?.success && readRes.content) {
               modifiedContent = readRes.content;
             }
diff --git a/src/renderer/components/ChangesDiffModal.tsx b/src/renderer/components/ChangesDiffModal.tsx
index 79919942..2e19a776 100644
--- a/src/renderer/components/ChangesDiffModal.tsx
+++ b/src/renderer/components/ChangesDiffModal.tsx
@@ -132,11 +132,7 @@ export const ChangesDiffModal: React.FC<ChangesDiffModalProps> = ({
 
           // Try to read actual current content for better accuracy
           try {
-            const readRes = await window.electronAPI.fsRead(
-              taskPath,
-              filePath,
-              2 * 1024 * 1024
-            );
+            const readRes = await window.electronAPI.fsRead(taskPath, filePath, 2 * 1024 * 1024);
             if (readRes?.success && readRes.content) {
               modifiedContent = readRes.content;
             }