diff --git a/apps/backend/cmd/kandev/adapters.go b/apps/backend/cmd/kandev/adapters.go
index 6882bcb572..8c8aa91517 100644
--- a/apps/backend/cmd/kandev/adapters.go
+++ b/apps/backend/cmd/kandev/adapters.go
@@ -115,6 +115,11 @@ func (a *lifecycleAdapter) LaunchAgent(ctx context.Context, req *executor.Launch
 	}, nil
 }
 
+// SetExecutionDescription updates the task description in an existing execution's metadata.
+func (a *lifecycleAdapter) SetExecutionDescription(ctx context.Context, agentExecutionID string, description string) error {
+	return a.mgr.SetExecutionDescription(ctx, agentExecutionID, description)
+}
+
 // StartAgentProcess starts the agent subprocess for an instance.
 // The command is built internally based on the instance's agent profile.
 func (a *lifecycleAdapter) StartAgentProcess(ctx context.Context, agentInstanceID string) error {
@@ -232,6 +237,12 @@ func (w *orchestratorWrapper) ResumeTaskSession(ctx context.Context, taskID, tas
 	return err
 }
 
+// StartCreatedSession forwards to the orchestrator service, discarding the TaskExecution result.
+func (w *orchestratorWrapper) StartCreatedSession(ctx context.Context, taskID, sessionID, agentProfileID, prompt string) error {
+	_, err := w.svc.StartCreatedSession(ctx, taskID, sessionID, agentProfileID, prompt)
+	return err
+}
+
 // messageCreatorAdapter adapts the task service to the orchestrator.MessageCreator interface
 type messageCreatorAdapter struct {
 	svc    *taskservice.Service
diff --git a/apps/backend/internal/agent/lifecycle/manager.go b/apps/backend/internal/agent/lifecycle/manager.go
index 5cf058763f..5b7e9b15f4 100644
--- a/apps/backend/internal/agent/lifecycle/manager.go
+++ b/apps/backend/internal/agent/lifecycle/manager.go
@@ -867,6 +867,20 @@ func (m *Manager) Launch(ctx context.Context, req *LaunchRequest) (*AgentExecuti
 	return execution, nil
 }
 
+// SetExecutionDescription updates the task description stored in an execution's metadata.
+// This is used when starting an agent on a workspace that was launched without a prompt.
+func (m *Manager) SetExecutionDescription(_ context.Context, executionID string, description string) error {
+	execution, exists := m.executionStore.Get(executionID)
+	if !exists {
+		return fmt.Errorf("execution %q not found", executionID)
+	}
+	if execution.Metadata == nil {
+		execution.Metadata = make(map[string]interface{})
+	}
+	execution.Metadata["task_description"] = description
+	return nil
+}
+
 // StartAgentProcess configures and starts the agent subprocess for an execution.
 // This must be called after Launch() to actually start the agent (e.g., auggie, codex).
 // The command is built internally based on the execution's agent profile.
diff --git a/apps/backend/internal/integration/orchestrator_test.go b/apps/backend/internal/integration/orchestrator_test.go
index 675d438355..efb953d3df 100644
--- a/apps/backend/internal/integration/orchestrator_test.go
+++ b/apps/backend/internal/integration/orchestrator_test.go
@@ -151,6 +151,11 @@ func (s *SimulatedAgentManagerClient) LaunchAgent(ctx context.Context, req *exec
 	}, nil
 }
 
+// SetExecutionDescription updates the task description for an execution
+func (s *SimulatedAgentManagerClient) SetExecutionDescription(ctx context.Context, agentExecutionID string, description string) error {
+	return nil
+}
+
 // StartAgentProcess simulates starting the agent subprocess
 func (s *SimulatedAgentManagerClient) StartAgentProcess(ctx context.Context, agentExecutionID string) error {
 	s.logger.Info("simulated: starting agent process",
diff --git a/apps/backend/internal/orchestrator/executor/executor.go b/apps/backend/internal/orchestrator/executor/executor.go
index 67eec03d38..3b4b69c2b0 100644
--- a/apps/backend/internal/orchestrator/executor/executor.go
+++ b/apps/backend/internal/orchestrator/executor/executor.go
@@ -62,6 +62,10 @@ type AgentManagerClient interface {
 
 	// ResolveAgentProfile resolves an agent profile ID to profile information
 	ResolveAgentProfile(ctx context.Context, profileID string) (*AgentProfileInfo, error)
+
+	// SetExecutionDescription updates the task description in an existing execution's metadata.
+	// Used when starting an agent on a session whose workspace was already launched.
+	SetExecutionDescription(ctx context.Context, agentExecutionID string, description string) error
 }
 
 // AgentProfileInfo contains resolved profile information
@@ -150,6 +154,11 @@ func agentSessionStateToV1(state models.TaskSessionState) v1.TaskSessionState {
 	return v1.TaskSessionState(state)
 }
 
+// TaskStateChangeFunc is called when the executor needs to update a task's state.
+// When set, it replaces direct repo.UpdateTaskState calls so the caller can
+// publish events (e.g. WebSocket notifications) alongside the DB update.
+type TaskStateChangeFunc func(ctx context.Context, taskID string, state v1.TaskState) error
+
 // Executor manages agent execution for tasks
 type Executor struct {
 	agentManager AgentManagerClient
@@ -161,6 +170,10 @@ type Executor struct {
 	retryLimit int
 	retryDelay time.Duration
 
+	// Callback for task state changes that need event publishing.
+	// Set by the orchestrator to route through the task service layer.
+	onTaskStateChange TaskStateChangeFunc
+
 	// Per-session locks to prevent concurrent resume/launch operations on the same session.
 	// This prevents race conditions when the backend restarts and multiple resume requests
 	// arrive simultaneously (e.g., from frontend auto-resume).
@@ -188,6 +201,57 @@ func NewExecutor(agentManager AgentManagerClient, repo repository.Repository, lo
 	}
 }
 
+// SetOnTaskStateChange sets a callback for task state changes.
+// This allows the orchestrator to route state changes through the task service layer
+// which publishes WebSocket events. Without this, async goroutines would only update
+// the database, leaving the frontend out of sync.
+func (e *Executor) SetOnTaskStateChange(fn TaskStateChangeFunc) {
+	e.onTaskStateChange = fn
+}
+
+// startAgentProcessAsync starts the agent subprocess in a background goroutine.
+// On success it transitions the task to IN_PROGRESS; on failure it marks both the
+// session and task as FAILED.
+func (e *Executor) startAgentProcessAsync(taskID, sessionID, agentExecutionID string) {
+	go func() {
+		startCtx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+		defer cancel()
+
+		if err := e.agentManager.StartAgentProcess(startCtx, agentExecutionID); err != nil {
+			e.logger.Error("failed to start agent process",
+				zap.String("task_id", taskID),
+				zap.String("agent_execution_id", agentExecutionID),
+				zap.Error(err))
+			if updateErr := e.repo.UpdateTaskSessionState(context.Background(), sessionID, models.TaskSessionStateFailed, err.Error()); updateErr != nil {
+				e.logger.Warn("failed to mark session as failed after start error",
+					zap.String("session_id", sessionID),
+					zap.Error(updateErr))
+			}
+			if updateErr := e.updateTaskState(context.Background(), taskID, v1.TaskStateFailed); updateErr != nil {
+				e.logger.Warn("failed to mark task as failed after start error",
+					zap.String("task_id", taskID),
+					zap.Error(updateErr))
+			}
+			return
+		}
+
+		if updateErr := e.updateTaskState(context.Background(), taskID, v1.TaskStateInProgress); updateErr != nil {
+			e.logger.Warn("failed to update task state to IN_PROGRESS after agent start",
+				zap.String("task_id", taskID),
+				zap.Error(updateErr))
+		}
+	}()
+}
+
+// updateTaskState updates a task's state, using the callback if set for event publishing,
+// or falling back to the raw repository.
+func (e *Executor) updateTaskState(ctx context.Context, taskID string, state v1.TaskState) error {
+	if e.onTaskStateChange != nil {
+		return e.onTaskStateChange(ctx, taskID, state)
+	}
+	return e.repo.UpdateTaskState(ctx, taskID, state)
+}
+
 // shouldUseWorktree returns true if the given executor type should use Git worktrees.
 func shouldUseWorktree(executorType string) bool {
 	return models.ExecutorType(executorType) == models.ExecutorTypeWorktree
@@ -260,7 +324,7 @@ func (e *Executor) ExecuteWithProfile(ctx context.Context, task *v1.Task, agentP
 	}
 
 	// Launch the agent for the prepared session
-	return e.LaunchPreparedSession(ctx, task, sessionID, agentProfileID, executorID, prompt, workflowStepID)
+	return e.LaunchPreparedSession(ctx, task, sessionID, agentProfileID, executorID, prompt, workflowStepID, true)
 }
 
 // PrepareSession creates a session entry in the database without launching the agent.
@@ -357,9 +421,13 @@ func (e *Executor) PrepareSession(ctx context.Context, task *v1.Task, agentProfi
 	return sessionID, nil
 }
 
-// LaunchPreparedSession launches the agent for a pre-created session.
+// LaunchPreparedSession launches the workspace (and optionally the agent) for a pre-created session.
 // The session must have been created using PrepareSession.
-func (e *Executor) LaunchPreparedSession(ctx context.Context, task *v1.Task, sessionID string, agentProfileID string, executorID string, prompt string, workflowStepID string) (*TaskExecution, error) {
+// When startAgent is false, only the workspace infrastructure (agentctl) is launched; the agent
+// subprocess is not started and the session state remains CREATED.
+// When startAgent is true and the workspace was already launched (AgentExecutionID set), only the
+// agent subprocess is started.
+func (e *Executor) LaunchPreparedSession(ctx context.Context, task *v1.Task, sessionID string, agentProfileID string, executorID string, prompt string, workflowStepID string, startAgent bool) (*TaskExecution, error) {
 	// Fetch the session to get its configuration
 	session, err := e.repo.GetTaskSession(ctx, sessionID)
 	if err != nil {
@@ -373,6 +441,12 @@ func (e *Executor) LaunchPreparedSession(ctx context.Context, task *v1.Task, ses
 		return nil, fmt.Errorf("session does not belong to task")
 	}
 
+	// Fast path: workspace already launched (e.g., from PrepareSession with workspace).
+	// Only start the agent subprocess if requested; otherwise return early.
+	if session.AgentExecutionID != "" {
+		return e.startAgentOnExistingWorkspace(ctx, task, session, prompt, startAgent)
+	}
+
 	metadata := cloneMetadata(task.Metadata)
 	var repositoryPath string
 	var repositoryID string
@@ -469,7 +543,7 @@ func (e *Executor) LaunchPreparedSession(ctx context.Context, task *v1.Task, ses
 				zap.String("session_id", sessionID),
 				zap.Error(updateErr))
 		}
-		if updateErr := e.repo.UpdateTaskState(ctx, task.ID, v1.TaskStateFailed); updateErr != nil {
+		if updateErr := e.updateTaskState(ctx, task.ID, v1.TaskStateFailed); updateErr != nil {
 			e.logger.Warn("failed to mark task as failed after launch error",
 				zap.String("task_id", task.ID),
 				zap.Error(updateErr))
@@ -480,7 +554,9 @@ func (e *Executor) LaunchPreparedSession(ctx context.Context, task *v1.Task, ses
 	now := time.Now().UTC()
 	session.AgentExecutionID = resp.AgentExecutionID
 	session.ContainerID = resp.ContainerID
-	session.State = models.TaskSessionStateStarting
+	if startAgent {
+		session.State = models.TaskSessionStateStarting
+	}
 	session.ErrorMessage = ""
 	session.UpdatedAt = now
 
@@ -535,47 +611,25 @@ func (e *Executor) LaunchPreparedSession(ctx context.Context, task *v1.Task, ses
 		}
 	}
 
+	sessionState := v1.TaskSessionStateCreated
+	if startAgent {
+		sessionState = v1.TaskSessionStateStarting
+	}
 	execution := &TaskExecution{
 		TaskID:           task.ID,
 		AgentExecutionID: resp.AgentExecutionID,
 		AgentProfileID:   agentProfileID,
 		StartedAt:        session.StartedAt,
-		SessionState:     v1.TaskSessionStateStarting,
+		SessionState:     sessionState,
 		LastUpdate:       now,
 		SessionID:        sessionID,
 		WorktreePath:     resp.WorktreePath,
 		WorktreeBranch:   resp.WorktreeBranch,
 	}
 
-	// Start the agent process asynchronously
-	go func() {
-		startCtx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
-		defer cancel()
-
-		if err := e.agentManager.StartAgentProcess(startCtx, resp.AgentExecutionID); err != nil {
-			e.logger.Error("failed to start agent process",
-				zap.String("task_id", task.ID),
-				zap.String("agent_execution_id", resp.AgentExecutionID),
-				zap.Error(err))
-			if updateErr := e.repo.UpdateTaskSessionState(context.Background(), sessionID, models.TaskSessionStateFailed, err.Error()); updateErr != nil {
-				e.logger.Warn("failed to mark session as failed after start error",
-					zap.String("session_id", sessionID),
-					zap.Error(updateErr))
-			}
-			if updateErr := e.repo.UpdateTaskState(context.Background(), task.ID, v1.TaskStateFailed); updateErr != nil {
-				e.logger.Warn("failed to mark task as failed after start error",
-					zap.String("task_id", task.ID),
-					zap.Error(updateErr))
-			}
-			return
-		}
-
-		if updateErr := e.repo.UpdateTaskState(context.Background(), task.ID, v1.TaskStateInProgress); updateErr != nil {
-			e.logger.Warn("failed to update task state to IN_PROGRESS after agent start",
-				zap.String("task_id", task.ID),
-				zap.Error(updateErr))
-		}
-	}()
+	if startAgent {
+		e.startAgentProcessAsync(task.ID, sessionID, resp.AgentExecutionID)
+	}
 
 	e.logger.Info("agent launched for prepared session",
 		zap.String("task_id", task.ID),
@@ -585,6 +639,66 @@ func (e *Executor) LaunchPreparedSession(ctx context.Context, task *v1.Task, ses
 	return execution, nil
 }
 
+// startAgentOnExistingWorkspace handles the case where LaunchPreparedSession is called on a session
+// whose workspace (agentctl) was already launched. It optionally starts just the agent subprocess.
+func (e *Executor) startAgentOnExistingWorkspace(ctx context.Context, task *v1.Task, session *models.TaskSession, prompt string, startAgent bool) (*TaskExecution, error) {
+	if !startAgent {
+		// Workspace already launched, nothing else to do
+		now := time.Now().UTC()
+		return &TaskExecution{
+			TaskID:           task.ID,
+			AgentExecutionID: session.AgentExecutionID,
+			AgentProfileID:   session.AgentProfileID,
+			StartedAt:        session.StartedAt,
+			SessionState:     v1.TaskSessionState(session.State),
+			LastUpdate:       now,
+			SessionID:        session.ID,
+		}, nil
+	}
+
+	// Update the task description in the existing execution so StartAgentProcess picks it up
+	if prompt != "" {
+		if err := e.agentManager.SetExecutionDescription(ctx, session.AgentExecutionID, prompt); err != nil {
+			e.logger.Warn("failed to set execution description for existing workspace",
+				zap.String("session_id", session.ID),
+				zap.String("agent_execution_id", session.AgentExecutionID),
+				zap.Error(err))
+			// Non-fatal: agent may start without description
+		}
+	}
+
+	// Transition session to STARTING
+	now := time.Now().UTC()
+	session.State = models.TaskSessionStateStarting
+	session.ErrorMessage = ""
+	session.UpdatedAt = now
+	if err := e.repo.UpdateTaskSession(ctx, session); err != nil {
+		e.logger.Error("failed to update session state for agent start",
+			zap.String("session_id", session.ID),
+			zap.Error(err))
+	}
+
+	execution := &TaskExecution{
+		TaskID:           task.ID,
+		AgentExecutionID: session.AgentExecutionID,
+		AgentProfileID:   session.AgentProfileID,
+		StartedAt:        now,
+		SessionState:     v1.TaskSessionStateStarting,
+		LastUpdate:       now,
+		SessionID:        session.ID,
+	}
+
+	// Start the agent process asynchronously
+	e.startAgentProcessAsync(task.ID, session.ID, session.AgentExecutionID)
+
+	e.logger.Info("agent starting on existing workspace",
+		zap.String("task_id", task.ID),
+		zap.String("session_id", session.ID),
+		zap.String("agent_execution_id", session.AgentExecutionID))
+
+	return execution, nil
+}
+
 // ResumeSession restarts an existing task session using its stored worktree.
 // When startAgent is false, only the executor runtime is started (agent process is not launched).
 func (e *Executor) ResumeSession(ctx context.Context, session *models.TaskSession, startAgent bool) (*TaskExecution, error) {
@@ -858,7 +972,7 @@ func (e *Executor) ResumeSession(ctx context.Context, session *models.TaskSessio
 						zap.String("session_id", session.ID),
 						zap.Error(updateErr))
 				}
-				if updateErr := e.repo.UpdateTaskState(context.Background(), task.ID, v1.TaskStateFailed); updateErr != nil {
+				if updateErr := e.updateTaskState(context.Background(), task.ID, v1.TaskStateFailed); updateErr != nil {
 					e.logger.Warn("failed to mark task as failed after start error on resume",
 						zap.String("task_id", task.ID),
 						zap.Error(updateErr))
@@ -870,7 +984,7 @@ func (e *Executor) ResumeSession(ctx context.Context, session *models.TaskSessio
 			// If the session is waiting for input, the task should be in REVIEW state.
 			// This ensures the task state reflects the actual agent status.
 			if session.State == models.TaskSessionStateWaitingForInput {
-				if updateErr := e.repo.UpdateTaskState(context.Background(), task.ID, v1.TaskStateReview); updateErr != nil {
+				if updateErr := e.updateTaskState(context.Background(), task.ID, v1.TaskStateReview); updateErr != nil {
 					e.logger.Warn("failed to update task state to REVIEW after resume",
 						zap.String("task_id", task.ID),
 						zap.Error(updateErr))
diff --git a/apps/backend/internal/orchestrator/executor/executor_test.go b/apps/backend/internal/orchestrator/executor/executor_test.go
index db1652c1b0..8aa336529a 100644
--- a/apps/backend/internal/orchestrator/executor/executor_test.go
+++ b/apps/backend/internal/orchestrator/executor/executor_test.go
@@ -12,9 +12,10 @@ import (
 
 // mockAgentManager implements AgentManagerClient for testing
 type mockAgentManager struct {
-	launchAgentFunc         func(ctx context.Context, req *LaunchAgentRequest) (*LaunchAgentResponse, error)
-	startAgentProcessFunc   func(ctx context.Context, agentExecutionID string) error
-	resolveAgentProfileFunc func(ctx context.Context, profileID string) (*AgentProfileInfo, error)
+	launchAgentFunc               func(ctx context.Context, req *LaunchAgentRequest) (*LaunchAgentResponse, error)
+	startAgentProcessFunc         func(ctx context.Context, agentExecutionID string) error
+	resolveAgentProfileFunc       func(ctx context.Context, profileID string) (*AgentProfileInfo, error)
+	setExecutionDescriptionFunc   func(ctx context.Context, agentExecutionID string, description string) error
 }
 
 func (m *mockAgentManager) LaunchAgent(ctx context.Context, req *LaunchAgentRequest) (*LaunchAgentResponse, error) {
@@ -28,6 +29,13 @@ func (m *mockAgentManager) LaunchAgent(ctx context.Context, req *LaunchAgentRequ
 	}, nil
 }
 
+func (m *mockAgentManager) SetExecutionDescription(ctx context.Context, agentExecutionID string, description string) error {
+	if m.setExecutionDescriptionFunc != nil {
+		return m.setExecutionDescriptionFunc(ctx, agentExecutionID, description)
+	}
+	return nil
+}
+
 func (m *mockAgentManager) StartAgentProcess(ctx context.Context, agentExecutionID string) error {
 	if m.startAgentProcessFunc != nil {
 		return m.startAgentProcessFunc(ctx, agentExecutionID)
@@ -611,7 +619,7 @@ func TestLaunchPreparedSession_Success(t *testing.T) {
 		Description: "Test description",
 	}
 
-	execution, err := executor.LaunchPreparedSession(context.Background(), task, "session-123", "profile-123", "", "test prompt", "")
+	execution, err := executor.LaunchPreparedSession(context.Background(), task, "session-123", "profile-123", "", "test prompt", "", true)
 	if err != nil {
 		t.Fatalf("LaunchPreparedSession failed: %v", err)
 	}
@@ -651,12 +659,146 @@ func TestLaunchPreparedSession_SessionNotBelongsToTask(t *testing.T) {
 		WorkspaceID: "workspace-123",
 	}
 
-	_, err := executor.LaunchPreparedSession(context.Background(), task, "session-123", "profile-123", "", "test prompt", "")
+	_, err := executor.LaunchPreparedSession(context.Background(), task, "session-123", "profile-123", "", "test prompt", "", true)
 	if err == nil {
 		t.Error("Expected error when session doesn't belong to task")
 	}
 }
 
+func TestLaunchPreparedSession_WorkspaceOnly(t *testing.T) {
+	repo := newMockRepository()
+
+	// Pre-create session (as PrepareSession would)
+	session := &models.TaskSession{
+		ID:             "session-123",
+		TaskID:         "task-123",
+		AgentProfileID: "profile-123",
+		State:          models.TaskSessionStateCreated,
+		StartedAt:      time.Now(),
+		UpdatedAt:      time.Now(),
+	}
+	repo.sessions[session.ID] = session
+
+	launchCalled := false
+	startAgentCalled := false
+	agentManager := &mockAgentManager{
+		launchAgentFunc: func(ctx context.Context, req *LaunchAgentRequest) (*LaunchAgentResponse, error) {
+			launchCalled = true
+			return &LaunchAgentResponse{
+				AgentExecutionID: "exec-123",
+				ContainerID:      "container-123",
+				Status:           v1.AgentStatusStarting,
+			}, nil
+		},
+		startAgentProcessFunc: func(ctx context.Context, id string) error {
+			startAgentCalled = true
+			return nil
+		},
+	}
+
+	executor := newTestExecutor(t, agentManager, repo)
+
+	task := &v1.Task{
+		ID:          "task-123",
+		WorkspaceID: "workspace-123",
+		Title:       "Test Task",
+		Description: "Test description",
+	}
+
+	// startAgent=false: should launch workspace but NOT start agent
+	execution, err := executor.LaunchPreparedSession(context.Background(), task, "session-123", "profile-123", "", "", "", false)
+	if err != nil {
+		t.Fatalf("LaunchPreparedSession(startAgent=false) failed: %v", err)
+	}
+
+	if !launchCalled {
+		t.Error("Expected LaunchAgent to be called (workspace setup)")
+	}
+
+	// Give goroutines a moment to run (there shouldn't be any)
+	time.Sleep(50 * time.Millisecond)
+
+	if startAgentCalled {
+		t.Error("Expected StartAgentProcess NOT to be called when startAgent=false")
+	}
+
+	if execution.SessionState != v1.TaskSessionStateCreated {
+		t.Errorf("Expected session state CREATED, got %s", execution.SessionState)
+	}
+
+	// Session in DB should remain CREATED
+	updatedSession := repo.sessions["session-123"]
+	if updatedSession.State != models.TaskSessionStateCreated {
+		t.Errorf("Expected DB session state CREATED, got %s", updatedSession.State)
+	}
+}
+
+func TestLaunchPreparedSession_ExistingWorkspace_StartAgent(t *testing.T) {
+	repo := newMockRepository()
+
+	// Session already has an AgentExecutionID (workspace previously launched)
+	session := &models.TaskSession{
+		ID:               "session-123",
+		TaskID:           "task-123",
+		AgentProfileID:   "profile-123",
+		AgentExecutionID: "exec-existing",
+		State:            models.TaskSessionStateCreated,
+		StartedAt:        time.Now(),
+		UpdatedAt:        time.Now(),
+	}
+	repo.sessions[session.ID] = session
+
+	startAgentCalled := false
+	descriptionSet := ""
+	agentManager := &mockAgentManager{
+		startAgentProcessFunc: func(ctx context.Context, id string) error {
+			startAgentCalled = true
+			if id != "exec-existing" {
+				t.Errorf("Expected execution ID exec-existing, got %s", id)
+			}
+			return nil
+		},
+	}
+	agentManager.setExecutionDescriptionFunc = func(ctx context.Context, id, desc string) error {
+		descriptionSet = desc
+		return nil
+	}
+
+	executor := newTestExecutor(t, agentManager, repo)
+
+	task := &v1.Task{
+		ID:          "task-123",
+		WorkspaceID: "workspace-123",
+		Title:       "Test Task",
+	}
+
+	execution, err := executor.LaunchPreparedSession(context.Background(), task, "session-123", "profile-123", "", "build the feature", "", true)
+	if err != nil {
+		t.Fatalf("LaunchPreparedSession(existing workspace) failed: %v", err)
+	}
+
+	// Should use the existing execution ID
+	if execution.AgentExecutionID != "exec-existing" {
+		t.Errorf("Expected agent execution ID exec-existing, got %s", execution.AgentExecutionID)
+	}
+
+	if execution.SessionState != v1.TaskSessionStateStarting {
+		t.Errorf("Expected session state STARTING, got %s", execution.SessionState)
+	}
+
+	// Description should have been set
+	if descriptionSet != "build the feature" {
+		t.Errorf("Expected description 'build the feature', got %q", descriptionSet)
+	}
+
+	// Wait for async goroutine
+	time.Sleep(100 * time.Millisecond)
+
+	if !startAgentCalled {
+		t.Error("Expected StartAgentProcess to be called")
+	}
+}
+
 func TestExecuteWithProfile_UsesPrepareThenLaunch(t *testing.T) {
 	repo := newMockRepository()
 
diff --git a/apps/backend/internal/orchestrator/handlers/handlers.go b/apps/backend/internal/orchestrator/handlers/handlers.go
index bdbeffce57..bb4ea44d65 100644
--- a/apps/backend/internal/orchestrator/handlers/handlers.go
+++ b/apps/backend/internal/orchestrator/handlers/handlers.go
@@ -116,8 +116,8 @@ func (h *Handlers) wsStartTask(ctx context.Context, msg *ws.Message) (*ws.Messag
 		return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeValidation, "agent_profile_id is required when creating a new session", nil)
 	}
 
-	// If session_id is provided, resume existing session with workflow step config
-	if req.SessionID != "" {
+	// If session_id is provided with a workflow step, resume with step config
+	if req.SessionID != "" && req.WorkflowStepID != "" {
 		err := h.service.StartSessionForWorkflowStep(ctx, req.TaskID, req.SessionID, req.WorkflowStepID)
 		if err != nil {
 			h.logger.Error("failed to start task", zap.String("task_id", req.TaskID), zap.Error(err))
@@ -132,6 +132,29 @@ func (h *Handlers) wsStartTask(ctx context.Context, msg *ws.Message) (*ws.Messag
 		return ws.NewResponse(msg.ID, msg.Action, resp)
 	}
 
+	// If session_id is provided without a workflow step, start a CREATED session with prompt
+	if req.SessionID != "" {
+		execution, err := h.service.StartCreatedSession(ctx, req.TaskID, req.SessionID, req.AgentProfileID, req.Prompt)
+		if err != nil {
+			h.logger.Error("failed to start created session", zap.String("task_id", req.TaskID), zap.String("session_id", req.SessionID), zap.Error(err))
+			return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeInternalError, "Failed to start session: "+err.Error(), nil)
+		}
+		resp := dto.StartTaskResponse{
+			Success:          true,
+			TaskID:           execution.TaskID,
+			AgentExecutionID: execution.AgentExecutionID,
+			TaskSessionID:    execution.SessionID,
+			State:            string(execution.SessionState),
+		}
+		if execution.WorktreePath != "" {
+			resp.WorktreePath = &execution.WorktreePath
+		}
+		if execution.WorktreeBranch != "" {
+			resp.WorktreeBranch = &execution.WorktreeBranch
+		}
+		return ws.NewResponse(msg.ID, msg.Action, resp)
+	}
+
 	// Otherwise, create a new session
 	execution, err := h.service.StartTask(ctx, req.TaskID, req.AgentProfileID, req.ExecutorID, req.Priority, req.Prompt, req.WorkflowStepID, false)
 	if err != nil {
diff --git a/apps/backend/internal/orchestrator/scheduler/scheduler_test.go b/apps/backend/internal/orchestrator/scheduler/scheduler_test.go
index 314267a209..2b1c8ebde4 100644
--- a/apps/backend/internal/orchestrator/scheduler/scheduler_test.go
+++ b/apps/backend/internal/orchestrator/scheduler/scheduler_test.go
@@ -43,6 +43,10 @@ func (m *mockAgentManager) LaunchAgent(ctx context.Context, req *executor.Launch
 	}, nil
 }
 
+func (m *mockAgentManager) SetExecutionDescription(ctx context.Context, agentExecutionID string, description string) error {
+	return nil
+}
+
 func (m *mockAgentManager) StartAgentProcess(ctx context.Context, agentExecutionID string) error {
 	return nil
 }
diff --git a/apps/backend/internal/orchestrator/service.go b/apps/backend/internal/orchestrator/service.go
index a324fed322..75e344ec56 100644
--- a/apps/backend/internal/orchestrator/service.go
+++ b/apps/backend/internal/orchestrator/service.go
@@ -199,6 +199,12 @@ func NewService(
 	}
 	exec := executor.NewExecutor(agentManager, repo, log, execCfg)
 
+	// Wire executor task state changes through the task service layer so
+	// events are published (e.g. WebSocket notifications to the frontend).
+	exec.SetOnTaskStateChange(func(ctx context.Context, taskID string, state v1.TaskState) error {
+		return taskRepo.UpdateTaskState(ctx, taskID, state)
+	})
+
 	// Create the scheduler with queue, executor, and task repository
 	sched := scheduler.NewScheduler(taskQueue, exec, taskRepo, log, cfg.Scheduler)
 
diff --git a/apps/backend/internal/orchestrator/task_operations.go b/apps/backend/internal/orchestrator/task_operations.go
index b087941bdc..b5a9bfbabe 100644
--- a/apps/backend/internal/orchestrator/task_operations.go
+++ b/apps/backend/internal/orchestrator/task_operations.go
@@ -6,9 +6,12 @@ import (
 	"fmt"
 	"os"
 	"strings"
+	"time"
 
 	"go.uber.org/zap"
 
+	"github.com/kandev/kandev/internal/events"
+	"github.com/kandev/kandev/internal/events/bus"
 	"github.com/kandev/kandev/internal/orchestrator/dto"
 	"github.com/kandev/kandev/internal/orchestrator/executor"
 	"github.com/kandev/kandev/internal/orchestrator/queue"
@@ -71,6 +74,16 @@ func (s *Service) PrepareTaskSession(ctx context.Context, taskID string, agentPr
 		return "", err
 	}
 
+	// Launch workspace infrastructure (agentctl) without starting the agent subprocess.
+	// This enables file browsing, editing, etc. while the session is in CREATED state.
+	if _, err := s.executor.LaunchPreparedSession(ctx, task, sessionID, agentProfileID, executorID, "", workflowStepID, false); err != nil {
+		s.logger.Warn("failed to launch workspace for prepared session (file browsing may be unavailable)",
+			zap.String("task_id", taskID),
+			zap.String("session_id", sessionID),
+			zap.Error(err))
+		// Non-fatal: session is still usable, workspace will be launched when agent starts
+	}
+
 	s.logger.Info("task session prepared",
 		zap.String("task_id", taskID),
 		zap.String("session_id", sessionID))
@@ -111,7 +124,7 @@ func (s *Service) StartTaskWithSession(ctx context.Context, taskID string, sessi
 
 	effectivePrompt, planModeActive := s.applyWorkflowAndPlanMode(ctx, effectivePrompt, task.ID, workflowStepID, planMode)
 
-	execution, err := s.executor.LaunchPreparedSession(ctx, task, sessionID, agentProfileID, executorID, effectivePrompt, workflowStepID)
+	execution, err := s.executor.LaunchPreparedSession(ctx, task, sessionID, agentProfileID, executorID, effectivePrompt, workflowStepID, true)
 	if err != nil {
 		return nil, err
 	}
@@ -123,6 +136,67 @@ func (s *Service) StartTaskWithSession(ctx context.Context, taskID string, sessi
 	return execution, nil
 }
 
+// StartCreatedSession starts agent execution for a task using a session that is in CREATED state.
+// This is used when a session was prepared (via PrepareSession) but the agent was not launched,
+// and the user now wants to start the agent with a prompt (e.g., from the plan panel or chat).
+func (s *Service) StartCreatedSession(ctx context.Context, taskID, sessionID, agentProfileID, prompt string) (*executor.TaskExecution, error) {
+	s.logger.Debug("starting created session",
+		zap.String("task_id", taskID),
+		zap.String("session_id", sessionID),
+		zap.String("agent_profile_id", agentProfileID))
+
+	// Load and verify session
+	session, err := s.repo.GetTaskSession(ctx, sessionID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get session: %w", err)
+	}
+	if session.TaskID != taskID {
+		return nil, fmt.Errorf("session does not belong to task")
+	}
+	if session.State != models.TaskSessionStateCreated {
+		return nil, fmt.Errorf("session is not in CREATED state (current: %s)", session.State)
+	}
+
+	// Use agent profile from request, fall back to session's stored value
+	effectiveProfileID := agentProfileID
+	if effectiveProfileID == "" {
+		effectiveProfileID = session.AgentProfileID
+	}
+	if effectiveProfileID == "" {
+		return nil, fmt.Errorf("agent_profile_id is required")
+	}
+
+	// Transition task state: CREATED → SCHEDULING → (IN_PROGRESS via executor)
+	if err := s.taskRepo.UpdateTaskState(ctx, taskID, v1.TaskStateScheduling); err != nil {
+		s.logger.Warn("failed to update task state to SCHEDULING",
+			zap.String("task_id", taskID),
+			zap.Error(err))
+	}
+
+	task, err := s.scheduler.GetTask(ctx, taskID)
+	if err != nil {
+		return nil, err
+	}
+
+	effectivePrompt := prompt
+	if effectivePrompt == "" {
+		effectivePrompt = task.Description
+	}
+
+	executorID := session.ExecutorID
+
+	execution, err := s.executor.LaunchPreparedSession(ctx, task, sessionID, effectiveProfileID, executorID, effectivePrompt, "", true)
+	if err != nil {
+		return nil, err
+	}
+
+	if execution.SessionID != "" {
+		s.recordInitialMessage(ctx, taskID, execution.SessionID, effectivePrompt, false)
+	}
+
+	return execution, nil
+}
+
 // StartTask manually starts agent execution for a task.
 // If workflowStepID is provided and workflowStepGetter is set, the prompt will be built
 // using the step's prompt_prefix + base prompt + prompt_suffix, and plan mode will be
@@ -145,6 +219,36 @@ func (s *Service) StartTask(ctx context.Context, taskID string, agentProfileID s
 			zap.Error(err))
 	}
 
+	// Move task to the target workflow step if provided and different from current
+	if workflowStepID != "" {
+		dbTask, err := s.repo.GetTask(ctx, taskID)
+		if err == nil && dbTask.WorkflowStepID != workflowStepID {
+			dbTask.WorkflowStepID = workflowStepID
+			dbTask.UpdatedAt = time.Now().UTC()
+			if err := s.repo.UpdateTask(ctx, dbTask); err != nil {
+				s.logger.Warn("failed to move task to workflow step",
+					zap.String("task_id", taskID),
+					zap.String("workflow_step_id", workflowStepID),
+					zap.Error(err))
+			} else if s.eventBus != nil {
+				_ = s.eventBus.Publish(ctx, events.TaskUpdated, bus.NewEvent(
+					events.TaskUpdated,
+					"orchestrator",
+					map[string]interface{}{
+						"task_id":          dbTask.ID,
+						"board_id":         dbTask.BoardID,
+						"workflow_step_id": dbTask.WorkflowStepID,
+						"title":            dbTask.Title,
+						"description":      dbTask.Description,
+						"state":            string(dbTask.State),
+						"priority":         dbTask.Priority,
+						"position":         dbTask.Position,
+					},
+				))
+			}
+		}
+	}
+
 	// Fetch the task from the repository to get complete task info
 	task, err := s.scheduler.GetTask(ctx, taskID)
 	if err != nil {
diff --git a/apps/backend/internal/task/handlers/message_handlers.go b/apps/backend/internal/task/handlers/message_handlers.go
index 6d4fe318c1..2b7a161184 100644
--- a/apps/backend/internal/task/handlers/message_handlers.go
+++ b/apps/backend/internal/task/handlers/message_handlers.go
@@ -26,6 +26,7 @@ import (
 type OrchestratorService interface {
 	PromptTask(ctx context.Context, taskID, sessionID, prompt, model string, planMode bool, attachments []v1.MessageAttachment) (*orchestrator.PromptResult, error)
 	ResumeTaskSession(ctx context.Context, taskID, taskSessionID string) error
+	StartCreatedSession(ctx context.Context, taskID, sessionID, agentProfileID, prompt string) error
 }
 
 // MessageHandlers handles WebSocket requests for messages
@@ -162,6 +163,9 @@ func (h *MessageHandlers) wsAddMessage(ctx context.Context, msg *ws.Message) (*w
 			"Session has ended. Please create a new session to continue.", nil)
 	}
 
+	// Handle CREATED sessions: save the message, then start the agent with it as the prompt
+	isCreatedSession := sessionResp.Session.State == models.TaskSessionStateCreated
+
 	// Get the current task state to determine if we need to transition
 	task, err := h.taskController.GetTask(ctx, dto.GetTaskRequest{ID: req.TaskID})
 	if err != nil {
@@ -217,8 +221,39 @@ func (h *MessageHandlers) wsAddMessage(ctx context.Context, msg *ws.Message) (*w
 		model := req.Model
 		planMode := req.PlanMode
 		attachments := req.Attachments
+		startCreated := isCreatedSession
+		agentProfileID := sessionResp.Session.AgentProfileID
 		go func() {
 			promptCtx := context.WithoutCancel(ctx)
+
+			// For CREATED sessions, start the agent with this message as the initial prompt
+			if startCreated {
+				if err := h.orchestrator.StartCreatedSession(promptCtx, taskID, sessionID, agentProfileID, content); err != nil {
+					h.logger.Warn("failed to start created session from message",
+						zap.String("task_id", taskID),
+						zap.String("session_id", sessionID),
+						zap.Error(err))
+
+					errorMsg := "Failed to start agent"
+					if _, createErr := h.messageController.CreateMessage(promptCtx, dto.CreateMessageRequest{
+						TaskSessionID: sessionID,
+						TaskID:        taskID,
+						Content:       errorMsg,
+						AuthorType:    "agent",
+						Type:          string(v1.MessageTypeError),
+						Metadata: map[string]interface{}{
+							"error": err.Error(),
+						},
+					}); createErr != nil {
+						h.logger.Error("failed to create error message",
+							zap.String("task_id", taskID),
+							zap.String("session_id", sessionID),
+							zap.Error(createErr))
+					}
+				}
+				return
+			}
+
 			_, err := h.orchestrator.PromptTask(promptCtx, taskID, sessionID, content, model, planMode, attachments)
 			if err != nil {
 				if errors.Is(err, executor.ErrExecutionNotFound) {
diff --git a/apps/backend/internal/task/handlers/task_handlers.go b/apps/backend/internal/task/handlers/task_handlers.go
index b3c6dc32a2..17d2c66ef0 100644
--- a/apps/backend/internal/task/handlers/task_handlers.go
+++ b/apps/backend/internal/task/handlers/task_handlers.go
@@ -228,6 +228,7 @@ type httpCreateTaskRequest struct {
 	Position       int                       `json:"position,omitempty"`
 	Metadata       map[string]interface{}    `json:"metadata,omitempty"`
 	StartAgent     bool                      `json:"start_agent,omitempty"`
+	PrepareSession bool                      `json:"prepare_session,omitempty"`
 	AgentProfileID string                    `json:"agent_profile_id,omitempty"`
 	ExecutorID     string                    `json:"executor_id,omitempty"`
 	PlanMode       bool                      `json:"plan_mode,omitempty"`
@@ -249,7 +250,7 @@ func (h *TaskHandlers) httpCreateTask(c *gin.Context) {
 		c.JSON(http.StatusBadRequest, gin.H{"error": "workspace_id is required"})
 		return
 	}
-	if body.StartAgent && body.AgentProfileID == "" {
+	if (body.StartAgent || body.PrepareSession) && body.AgentProfileID == "" {
 		c.JSON(http.StatusBadRequest, gin.H{"error": "agent_profile_id is required to start agent"})
 		return
 	}
@@ -289,7 +290,16 @@ func (h *TaskHandlers) httpCreateTask(c *gin.Context) {
 	}
 
 	response := createTaskResponse{TaskDTO: resp}
-	if body.StartAgent && body.AgentProfileID != "" && h.orchestrator != nil {
+	if body.PrepareSession && !body.StartAgent && body.AgentProfileID != "" && h.orchestrator != nil {
+		// Create session entry without launching the agent.
+		// The session stays in CREATED state until the user triggers it.
+		sessionID, err := h.orchestrator.PrepareTaskSession(reqCtx, resp.ID, body.AgentProfileID, body.ExecutorID, body.WorkflowStepID)
+		if err != nil {
+			h.logger.Error("failed to prepare session for task", zap.Error(err), zap.String("task_id", resp.ID))
+		} else {
+			response.TaskSessionID = sessionID
+		}
+	} else if body.StartAgent && body.AgentProfileID != "" && h.orchestrator != nil {
 		// Create session entry synchronously so we can return the session ID immediately
 		sessionID, err := h.orchestrator.PrepareTaskSession(reqCtx, resp.ID, body.AgentProfileID, body.ExecutorID, body.WorkflowStepID)
 		if err != nil {
diff --git a/apps/backend/internal/task/service/service.go b/apps/backend/internal/task/service/service.go
index 6ff722fc90..4e3d0196fe 100644
--- a/apps/backend/internal/task/service/service.go
+++ b/apps/backend/internal/task/service/service.go
@@ -487,12 +487,66 @@ func (s *Service) UpdateTask(ctx context.Context, id string, req *UpdateTaskRequ
 			return nil, err
 		}
 
+		// Resolve local paths to repository IDs (same logic as CreateTask)
+		var repoByPath map[string]*models.Repository
+		for _, repoInput := range req.Repositories {
+			if repoInput.RepositoryID == "" && repoInput.LocalPath != "" {
+				repos, err := s.repo.ListRepositories(ctx, task.WorkspaceID)
+				if err != nil {
+					s.logger.Error("failed to list repositories", zap.Error(err))
+					return nil, err
+				}
+				repoByPath = make(map[string]*models.Repository, len(repos))
+				for _, repo := range repos {
+					if repo.LocalPath == "" {
+						continue
+					}
+					repoByPath[repo.LocalPath] = repo
+				}
+				break
+			}
+		}
+
 		// Create new repositories
 		for i, repoInput := range req.Repositories {
+			repositoryID := repoInput.RepositoryID
+			baseBranch := repoInput.BaseBranch
+			if repositoryID == "" && repoInput.LocalPath != "" {
+				repo := repoByPath[repoInput.LocalPath]
+				if repo == nil {
+					name := strings.TrimSpace(repoInput.Name)
+					if name == "" {
+						name = filepath.Base(repoInput.LocalPath)
+					}
+					defaultBranch := repoInput.DefaultBranch
+					if defaultBranch == "" {
+						defaultBranch = repoInput.BaseBranch
+					}
+					created, err := s.CreateRepository(ctx, &CreateRepositoryRequest{
+						WorkspaceID:   task.WorkspaceID,
+						Name:          name,
+						SourceType:    "local",
+						LocalPath:     repoInput.LocalPath,
+						DefaultBranch: defaultBranch,
+					})
+					if err != nil {
+						return nil, err
+					}
+					repo = created
+					if repoByPath == nil {
+						repoByPath = make(map[string]*models.Repository)
+					}
+					repoByPath[repoInput.LocalPath] = repo
+				}
+				repositoryID = repo.ID
+				if baseBranch == "" {
+					baseBranch = repo.DefaultBranch
+				}
+			}
 			taskRepo := &models.TaskRepository{
 				TaskID:       task.ID,
-				RepositoryID: repoInput.RepositoryID,
-				BaseBranch:   repoInput.BaseBranch,
+				RepositoryID: repositoryID,
+				BaseBranch:   baseBranch,
 				Position:     i,
 				Metadata:     make(map[string]interface{}),
 			}
@@ -1651,6 +1705,10 @@ func (s *Service) publishTaskEvent(ctx context.Context, eventType string, task *
 		}
 	}
 
+	if len(task.Repositories) > 0 {
+		data["repository_id"] = task.Repositories[0].RepositoryID
+	}
+
 	if task.Metadata != nil {
 		data["metadata"] = task.Metadata
 	}
diff --git a/apps/web/app/tasks/tasks-page-client.tsx b/apps/web/app/tasks/tasks-page-client.tsx
index 493159e53b..8757d8ef17 100644
--- a/apps/web/app/tasks/tasks-page-client.tsx
+++ b/apps/web/app/tasks/tasks-page-client.tsx
@@ -199,7 +199,6 @@ export function TasksPageClient({
             setCreateDialogOpen(false)
             fetchTasks()
           }}
-          navigateOnSessionCreate={false}
         />
       )}
     </div>
diff --git a/apps/web/components/combobox.tsx b/apps/web/components/combobox.tsx
index 8dfbb64df4..d70fa510d4 100644
--- a/apps/web/components/combobox.tsx
+++ b/apps/web/components/combobox.tsx
@@ -54,11 +54,17 @@ export const Combobox = memo(function Combobox({
   showSearch = true,
 }: ComboboxProps) {
   const [open, setOpen] = useState(false)
+  // Track the highlighted item. Defaults to the selected value so the current
+  // selection is highlighted when the popover opens (not the first item).
+  const [highlighted, setHighlighted] = useState("")
 
   const selectedOption = options.find((option) => option.value === value)
 
   return (
-    <Popover open={open} onOpenChange={setOpen}>
+    <Popover open={open} onOpenChange={(next) => {
+      setOpen(next)
+      if (next) setHighlighted(value)
+    }}>
       <PopoverTrigger asChild>
         <Button
           variant="ghost"
@@ -78,7 +84,7 @@ export const Combobox = memo(function Combobox({
         </Button>
       </PopoverTrigger>
       <PopoverContent className={cn("w-[var(--radix-popover-trigger-width)] min-w-[300px] max-w-none p-0", className)} align="start">
-        <Command>
+        <Command value={highlighted} onValueChange={setHighlighted}>
           {dropdownLabel ? (
             <div className="text-muted-foreground px-2 py-1.5 text-xs border-b">
               {dropdownLabel}
diff --git a/apps/web/components/kanban-board.tsx b/apps/web/components/kanban-board.tsx
index 2a87c37535..536ef312dc 100644
--- a/apps/web/components/kanban-board.tsx
+++ b/apps/web/components/kanban-board.tsx
@@ -61,7 +61,7 @@ export function KanbanBoard({ onPreviewTask, onOpenTask }: KanbanBoardProps = {}
     handleWorkspaceChange,
     handleBoardChange,
     deletingTaskId,
-  } = useKanbanActions({ kanban, workspaceState, boardsState });
+  } = useKanbanActions({ workspaceState, boardsState });
 
   // Data fetching and derived state
   const {
@@ -215,7 +215,6 @@ export function KanbanBoard({ onPreviewTask, onOpenTask }: KanbanBoardProps = {}
         onSearchChange={setSearchQuery}
       />
       <TaskCreateDialog
-        key={isDialogOpen ? 'open' : 'closed'}
         open={isDialogOpen}
         onOpenChange={handleDialogOpenChange}
         workspaceId={workspaceState.activeId}
@@ -235,7 +234,6 @@ export function KanbanBoard({ onPreviewTask, onOpenTask }: KanbanBoardProps = {}
             : null
         }
         onSuccess={handleDialogSuccess}
-        navigateOnSessionCreate={false}
         initialValues={
           editingTask
             ? {
@@ -246,11 +244,10 @@ export function KanbanBoard({ onPreviewTask, onOpenTask }: KanbanBoardProps = {}
             }
             : undefined
         }
-        submitLabel={editingTask ? 'Update' : 'Create'}
+        mode={editingTask ? 'edit' : 'create'}
       />
       {/* Workflow automation session creation dialog */}
       <TaskCreateDialog
-        key={isWorkflowDialogOpen ? 'workflow-open' : 'workflow-closed'}
         open={isWorkflowDialogOpen}
         onOpenChange={(open) => {
           setIsWorkflowDialogOpen(open);
@@ -267,7 +264,6 @@ export function KanbanBoard({ onPreviewTask, onOpenTask }: KanbanBoardProps = {}
           title: '',
           description: workflowAutomation?.taskDescription ?? '',
         }}
-        submitLabel="Start Agent"
       />
       {/* Approval warning modal */}
       <AlertDialog open={!!moveError} onOpenChange={(open) => !open && setMoveError(null)}>
diff --git a/apps/web/components/kanban-card.tsx b/apps/web/components/kanban-card.tsx
index e1143a7233..72ac3ed04f 100644
--- a/apps/web/components/kanban-card.tsx
+++ b/apps/web/components/kanban-card.tsx
@@ -138,7 +138,7 @@ export function KanbanCard({ task, repositoryName, onClick, onEdit, onDelete, on
       style={style}
       className={cn(
         'max-h-48 bg-card rounded-sm data-[size=sm]:py-1 cursor-pointer mb-2 w-full py-0 relative border border-border overflow-visible shadow-none ring-0',
-        task.state === 'IN_PROGRESS' && 'kanban-task-pulse',
+        (task.state === 'IN_PROGRESS' || task.state === 'SCHEDULING') && 'kanban-task-pulse',
         isDragging && 'opacity-50 z-50'
       )}
       onClick={() => onClick?.(task)}
@@ -151,7 +151,7 @@ export function KanbanCard({ task, repositoryName, onClick, onEdit, onDelete, on
           repoName={repositoryName ?? null}
           actions={
             <div className="flex items-center gap-2">
-              {task.state === 'IN_PROGRESS' && statusIcon}
+              {(task.state === 'IN_PROGRESS' || task.state === 'SCHEDULING') && statusIcon}
               {showMaximizeButton && onOpenFullPage && task.hasSession !== false && (
                 <button
                   type="button"
diff --git a/apps/web/components/task-create-dialog.tsx b/apps/web/components/task-create-dialog.tsx
index 4e63789570..828e5fccae 100644
--- a/apps/web/components/task-create-dialog.tsx
+++ b/apps/web/components/task-create-dialog.tsx
@@ -3,7 +3,7 @@
 import { useEffect, useRef, useState, FormEvent, memo, useMemo, useCallback } from 'react';
 import Link from 'next/link';
 import { useRouter } from 'next/navigation';
-import { IconLoader2, IconGitBranch, IconListCheck } from '@tabler/icons-react';
+import { IconLoader2, IconGitBranch, IconFileInvoice, IconSend, IconChevronDown } from '@tabler/icons-react';
 import {
   Dialog,
   DialogContent,
@@ -12,13 +12,16 @@ import {
   DialogFooter,
   DialogClose,
 } from '@kandev/ui/dialog';
-import { Label } from '@kandev/ui/label';
-import { Input } from '@kandev/ui/input';
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from '@kandev/ui/dropdown-menu';
 import { Textarea } from '@kandev/ui/textarea';
 import { Button } from '@kandev/ui/button';
 import { Combobox } from './combobox';
 import { Badge } from '@kandev/ui/badge';
-import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@kandev/ui/tooltip';
 import type { LocalRepository, Task, Workspace, Repository, Environment, Executor, Branch } from '@/lib/types/http';
 import type { AgentProfileOption } from '@/lib/state/slices';
 import {
@@ -44,12 +47,12 @@ import { STORAGE_KEYS } from '@/lib/settings/constants';
 import { linkToSession } from '@/lib/links';
 import { getExecutorIcon } from '@/lib/executor-icons';
 
-import { usePanelActions } from '@/hooks/use-panel-actions';
+import { useDockviewStore } from '@/lib/state/dockview-store';
 
 interface TaskCreateDialogProps {
   open: boolean;
   onOpenChange: (open: boolean) => void;
-  mode?: 'task' | 'session';
+  mode?: 'create' | 'edit' | 'session';
   workspaceId: string | null;
   boardId: string | null;
   defaultColumnId: string | null;
@@ -69,10 +72,30 @@ interface TaskCreateDialogProps {
     branch?: string;
     state?: Task['state'];
   };
-  submitLabel?: string;
   taskId?: string | null;
-  /** Whether to navigate to the new session after task creation. Defaults to true. */
-  navigateOnSessionCreate?: boolean;
+}
+
+interface OrchestratorStartResponse {
+  success: boolean;
+  task_id: string;
+  agent_instance_id: string;
+  session_id?: string;
+  state: string;
+}
+
+function autoSelectBranch(branchList: Branch[], setBranch: (value: string) => void): void {
+  const lastUsedBranch = getLocalStorage<string | null>(STORAGE_KEYS.LAST_BRANCH, null);
+  if (lastUsedBranch && branchList.some((b) => {
+    const displayName = b.type === 'remote' && b.remote ? `${b.remote}/${b.name}` : b.name;
+    return displayName === lastUsedBranch;
+  })) {
+    setBranch(lastUsedBranch);
+    return;
+  }
+  const preferredBranch = selectPreferredBranch(branchList);
+  if (preferredBranch) {
+    setBranch(preferredBranch);
+  }
 }
 
 type RepositoryOption = {
@@ -257,52 +280,35 @@ const InlineTaskName = memo(function InlineTaskName({
   );
 });
 
-// Memoized text inputs to prevent re-rendering the entire dialog on every keystroke
+// Memoized description input to prevent re-rendering the entire dialog on every keystroke
 type TaskFormInputsProps = {
   isSessionMode: boolean;
-  showTitleInput: boolean;
-  initialTitle: string;
+  autoFocus?: boolean;
   initialDescription: string;
-  onTitleChange: (hasContent: boolean) => void;
   onDescriptionChange: (hasContent: boolean) => void;
   onKeyDown: (e: React.KeyboardEvent) => void;
-  titleValueRef: React.RefObject<{ getValue: () => string } | null>;
   descriptionValueRef: React.RefObject<{ getValue: () => string } | null>;
 };
 
 const TaskFormInputs = memo(function TaskFormInputs({
   isSessionMode,
-  showTitleInput,
-  initialTitle,
+  autoFocus,
   initialDescription,
-  onTitleChange,
   onDescriptionChange,
   onKeyDown,
-  titleValueRef,
   descriptionValueRef,
 }: TaskFormInputsProps) {
-  const [title, setTitle] = useState(initialTitle);
   const [description, setDescription] = useState(initialDescription);
   const textareaRef = useRef<HTMLTextAreaElement>(null);
 
-  // Expose getValue methods via refs passed from parent
-  // This is an imperative handle pattern - refs are intentionally mutated
-  useEffect(() => {
-    const ref = titleValueRef as React.MutableRefObject<{ getValue: () => string } | null>;
-    if (ref) {
-      ref.current = { getValue: () => title };
-    }
-  }, [title, titleValueRef]);
-
   useEffect(() => {
     const ref = descriptionValueRef as React.MutableRefObject<{ getValue: () => string } | null>;
     if (ref) {
-      // eslint-disable-next-line react-hooks/immutability
       ref.current = { getValue: () => description };
     }
   }, [description, descriptionValueRef]);
 
-  // Auto-resize textarea
+  // Auto-resize textarea + optional auto-focus with cursor at end
   useEffect(() => {
     const textarea = textareaRef.current;
     if (!textarea) return;
@@ -310,15 +316,13 @@ const TaskFormInputs = memo(function TaskFormInputs({
     textarea.style.height = `${textarea.scrollHeight}px`;
   }, [description]);
 
-  const handleTitleChange = useCallback((e: React.ChangeEvent<HTMLInputElement>) => {
-    const newValue = e.target.value;
-    const hadContent = title.trim().length > 0;
-    const hasContent = newValue.trim().length > 0;
-    setTitle(newValue);
-    if (hadContent !== hasContent) {
-      onTitleChange(hasContent);
-    }
-  }, [title, onTitleChange]);
+  useEffect(() => {
+    if (!autoFocus) return;
+    const textarea = textareaRef.current;
+    if (!textarea) return;
+    textarea.focus();
+    textarea.setSelectionRange(textarea.value.length, textarea.value.length);
+  }, [autoFocus]);
 
   const handleDescriptionChange = useCallback((e: React.ChangeEvent<HTMLTextAreaElement>) => {
     const newValue = e.target.value;
@@ -331,38 +335,25 @@ const TaskFormInputs = memo(function TaskFormInputs({
   }, [description, onDescriptionChange]);
 
   return (
-    <>
-      {showTitleInput && !isSessionMode && (
-        <div>
-          <Input
-            required
-            placeholder="Enter task title..."
-            value={title}
-            onChange={handleTitleChange}
-            disabled={isSessionMode}
-          />
-        </div>
-      )}
-      <div>
-        <Textarea
-          ref={textareaRef}
-          placeholder={isSessionMode ? 'Describe what you want the agent to do...' : 'Write a prompt for the agent...'}
-          value={description}
-          onChange={handleDescriptionChange}
-          onKeyDown={onKeyDown}
-          rows={2}
-          className={isSessionMode ? 'min-h-[120px] max-h-[240px] resize-none overflow-auto' : 'min-h-[96px] max-h-[240px] resize-y overflow-auto'}
-          required={isSessionMode}
-        />
-      </div>
-    </>
+    <div>
+      <Textarea
+        ref={textareaRef}
+        placeholder={isSessionMode ? 'Describe what you want the agent to do...' : 'Write a prompt for the agent...'}
+        value={description}
+        onChange={handleDescriptionChange}
+        onKeyDown={onKeyDown}
+        rows={2}
+        className={isSessionMode ? 'min-h-[120px] max-h-[240px] resize-none overflow-auto' : 'min-h-[96px] max-h-[240px] resize-y overflow-auto'}
+        required={isSessionMode}
+      />
+    </div>
   );
 });
 
 export function TaskCreateDialog({
   open,
   onOpenChange,
-  mode = 'task',
+  mode = 'create',
   workspaceId,
   boardId,
   defaultColumnId,
@@ -371,26 +362,21 @@ export function TaskCreateDialog({
   onSuccess,
   onCreateSession,
   initialValues,
-  submitLabel = 'Create',
   taskId = null,
-  navigateOnSessionCreate = true,
 }: TaskCreateDialogProps) {
   const router = useRouter();
   const isSessionMode = mode === 'session';
-  const isEditMode = submitLabel !== 'Create';
-  const isCreateMode = !isEditMode && !isSessionMode;
+  const isEditMode = mode === 'edit';
+  const isCreateMode = mode === 'create';
   const [isCreatingSession, setIsCreatingSession] = useState(false);
   const [isCreatingTask, setIsCreatingTask] = useState(false);
   const [taskName, setTaskName] = useState('');
   // Track only whether inputs have content (not the actual values) to minimize re-renders
   const [hasTitle, setHasTitle] = useState(Boolean(initialValues?.title?.trim()));
   const [hasDescription, setHasDescription] = useState(Boolean(initialValues?.description?.trim()));
-  // Refs to get actual values when needed
-  const titleInputRef = useRef<{ getValue: () => string } | null>(null);
   const descriptionInputRef = useRef<{ getValue: () => string } | null>(null);
   const [repositoryId, setRepositoryId] = useState(initialValues?.repositoryId ?? '');
   const [branch, setBranch] = useState(initialValues?.branch ?? '');
-  const [startAgent, setStartAgent] = useState(!isEditMode);
   const [agentProfileId, setAgentProfileId] = useState('');
   const [environmentId, setEnvironmentId] = useState('');
   const [executorId, setExecutorId] = useState('');
@@ -433,23 +419,16 @@ export function TaskCreateDialog({
 
   useEffect(() => {
     if (!open) return;
-    if (isCreateMode) {
-      const name = initialValues?.title || '';
-      setTaskName(name);
-      setHasTitle(name.trim().length > 0);
-    } else {
-      setHasTitle(Boolean(initialValues?.title?.trim()));
-    }
+    const name = initialValues?.title || '';
+    setTaskName(name);
+    setHasTitle(name.trim().length > 0);
     setHasDescription(Boolean(initialValues?.description?.trim()));
     setRepositoryId(initialValues?.repositoryId ?? '');
     setBranch(initialValues?.branch ?? '');
-    setStartAgent(!isEditMode);
     setAgentProfileId('');
     setEnvironmentId('');
     setExecutorId('');
   }, [
-    isCreateMode,
-    isEditMode,
     initialValues?.branch,
     initialValues?.description,
     initialValues?.repositoryId,
@@ -519,24 +498,8 @@ export function TaskCreateDialog({
   ]);
 
   useEffect(() => {
-    if (!repositoryId) return;
-    if (branch) return;
-
-    // Priority 1: Last used branch
-    const lastUsedBranch = getLocalStorage<string | null>(STORAGE_KEYS.LAST_BRANCH, null);
-    if (lastUsedBranch && branches.some((b: Branch) => {
-      const displayName = b.type === 'remote' && b.remote ? `${b.remote}/${b.name}` : b.name;
-      return displayName === lastUsedBranch;
-    })) {
-      setBranch(lastUsedBranch);
-      return;
-    }
-
-    // Priority 2: Preferred branch (main/master)
-    const preferredBranch = selectPreferredBranch(branches);
-    if (preferredBranch) {
-      setBranch(preferredBranch);
-    }
+    if (!repositoryId || branch) return;
+    autoSelectBranch(branches, setBranch);
   }, [branch, branches, repositoryId]);
 
   const handleSelectLocalRepository = useCallback((path: string) => {
@@ -734,30 +697,12 @@ export function TaskCreateDialog({
   }, [open, selectedLocalRepo, toast, workspaceId]);
 
   useEffect(() => {
-    if (repositoryId || localBranches.length === 0) return;
-    if (branch) return;
-
-    // Priority 1: Last used branch
-    const lastUsedBranch = getLocalStorage<string | null>(STORAGE_KEYS.LAST_BRANCH, null);
-    if (lastUsedBranch && localBranches.some((b: Branch) => {
-      const displayName = b.type === 'remote' && b.remote ? `${b.remote}/${b.name}` : b.name;
-      return displayName === lastUsedBranch;
-    })) {
-      setBranch(lastUsedBranch);
-      return;
-    }
-
-    // Priority 2: Preferred branch (main/master)
-    const preferredBranch = selectPreferredBranch(localBranches);
-    if (preferredBranch) {
-      setBranch(preferredBranch);
-    }
+    if (repositoryId || localBranches.length === 0 || branch) return;
+    autoSelectBranch(localBranches, setBranch);
   }, [branch, localBranches, repositoryId]);
 
   useEffect(() => {
     if (!open || agentProfileId || agentProfiles.length === 0) return;
-    if (!isSessionMode && !startAgent) return;
-    if (isEditMode && agentProfiles.length > 1) return;
 
     // Priority: last used → workspace default → first available
     const lastUsedProfileId = getLocalStorage<string | null>(STORAGE_KEYS.LAST_AGENT_PROFILE_ID, null);
@@ -772,11 +717,10 @@ export function TaskCreateDialog({
       return;
     }
     setAgentProfileId(agentProfiles[0].id);
-  }, [open, isEditMode, agentProfileId, agentProfiles, workspaceDefaults, isSessionMode, startAgent]);
+  }, [open, agentProfileId, agentProfiles, workspaceDefaults]);
 
   useEffect(() => {
-    if (!open || isEditMode || environmentId || environments.length === 0) return;
-    if (!isSessionMode && !startAgent) return;
+    if (!open || environmentId || environments.length === 0) return;
     const defaultEnvironmentId = workspaceDefaults?.default_environment_id ?? null;
     if (
       defaultEnvironmentId &&
@@ -789,11 +733,10 @@ export function TaskCreateDialog({
       (environment: Environment) => environment.kind === DEFAULT_LOCAL_ENVIRONMENT_KIND
     );
     setEnvironmentId(localEnvironment?.id ?? environments[0].id);
-  }, [open, isEditMode, environmentId, environments, workspaceDefaults, isSessionMode, startAgent]);
+  }, [open, environmentId, environments, workspaceDefaults]);
 
   useEffect(() => {
-    if (!open || isEditMode || executorId || executors.length === 0) return;
-    if (!isSessionMode && !startAgent) return;
+    if (!open || executorId || executors.length === 0) return;
     const defaultExecutorId = workspaceDefaults?.default_executor_id ?? null;
     if (defaultExecutorId && executors.some((executor: Executor) => executor.id === defaultExecutorId)) {
       setExecutorId(defaultExecutorId);
@@ -803,334 +746,297 @@ export function TaskCreateDialog({
       (executor: Executor) => executor.type === DEFAULT_LOCAL_EXECUTOR_TYPE
     );
     setExecutorId(localExecutor?.id ?? executors[0].id);
-  }, [open, isEditMode, executorId, executors, workspaceDefaults, isSessionMode, startAgent]);
+  }, [open, executorId, executors, workspaceDefaults]);
+
+  // Access layout/UI store for plan mode creation
+  const setActiveDocument = useAppStore((state) => state.setActiveDocument);
+  const setPlanMode = useAppStore((state) => state.setPlanMode);
+
+  const resetForm = useCallback(() => {
+    setHasTitle(false);
+    setHasDescription(false);
+    setTaskName('');
+    setRepositoryId('');
+    setBranch('');
+    setAgentProfileId('');
+    setEnvironmentId('');
+    setExecutorId('');
+  }, []);
+
+  const getRepositoriesPayload = useCallback(() => {
+    if (repositoryId) {
+      return [{ repository_id: repositoryId, base_branch: branch || undefined }];
+    }
+    if (selectedLocalRepo) {
+      return [{
+        repository_id: '',
+        base_branch: branch || undefined,
+        local_path: selectedLocalRepo.path,
+        default_branch: selectedLocalRepo.default_branch || undefined,
+      }];
+    }
+    return [];
+  }, [repositoryId, branch, selectedLocalRepo]);
+
+  // --- Submit handlers (one per mode) ---
+
+  const handleSessionSubmit = useCallback(async () => {
+    const description = descriptionInputRef.current?.getValue() ?? '';
+    const trimmedDescription = description.trim();
+    if (!trimmedDescription || !agentProfileId) return;
+
+    // Legacy mode: delegate to parent
+    if (onCreateSession) {
+      onCreateSession({ prompt: trimmedDescription, agentProfileId, executorId, environmentId });
+      resetForm();
+      onOpenChange(false);
+      return;
+    }
+
+    if (!taskId) return;
+
+    setIsCreatingSession(true);
+    try {
+      const client = getWebSocketClient();
+      if (!client) throw new Error('WebSocket client not available');
+
+      const response = await client.request<OrchestratorStartResponse>(
+        'orchestrator.start',
+        { task_id: taskId, agent_profile_id: agentProfileId, executor_id: executorId, prompt: trimmedDescription },
+        15000,
+      );
+
+      resetForm();
+      const newSessionId = response?.session_id;
+      if (newSessionId) {
+        router.push(linkToSession(newSessionId));
+      } else {
+        onOpenChange(false);
+      }
+    } catch (error) {
+      toast({ title: 'Failed to create session', description: error instanceof Error ? error.message : 'An error occurred', variant: 'error' });
+    } finally {
+      setIsCreatingSession(false);
+    }
+  }, [agentProfileId, environmentId, executorId, onCreateSession, onOpenChange, resetForm, router, taskId, toast]);
+
+  const performTaskUpdate = useCallback(async () => {
+    if (!editingTask) return null;
+    const trimmedTitle = taskName.trim();
+    if (!trimmedTitle) return null;
+    const description = descriptionInputRef.current?.getValue() ?? '';
+    const trimmedDescription = description.trim();
+    const repositoriesPayload = getRepositoriesPayload();
+
+    const updatePayload: Parameters<typeof updateTask>[1] = {
+      title: trimmedTitle,
+      description: trimmedDescription,
+      ...(repositoriesPayload.length > 0 && { repositories: repositoriesPayload }),
+    };
+
+    const updatedTask = await updateTask(editingTask.id, updatePayload);
+    return { updatedTask, trimmedDescription };
+  }, [editingTask, taskName, getRepositoriesPayload]);
+
+  const handleEditSubmit = useCallback(async () => {
+    setIsCreatingTask(true);
+    try {
+      const result = await performTaskUpdate();
+      if (!result) return;
+      const { updatedTask, trimmedDescription } = result;
+
+      let taskSessionId: string | null = null;
+      if (agentProfileId) {
+        const autoStartStep = columns.find((column) => column.autoStartAgent);
+        const client = getWebSocketClient();
+        if (client) {
+          try {
+            const response = await client.request<OrchestratorStartResponse>(
+              'orchestrator.start',
+              {
+                task_id: updatedTask.id,
+                agent_profile_id: agentProfileId,
+                executor_id: executorId,
+                prompt: trimmedDescription || '',
+                ...(autoStartStep && { workflow_step_id: autoStartStep.id }),
+              },
+              15000,
+            );
+            taskSessionId = response?.session_id ?? null;
+          } catch (error) {
+            console.error('[TaskCreateDialog] failed to start agent:', error);
+          }
+        }
+      }
+
+      onSuccess?.(updatedTask, 'edit', { taskSessionId });
+    } catch (error) {
+      toast({ title: 'Failed to update task', description: error instanceof Error ? error.message : 'An error occurred', variant: 'error' });
+    } finally {
+      resetForm();
+      setIsCreatingTask(false);
+      onOpenChange(false);
+    }
+  }, [performTaskUpdate, agentProfileId, executorId, columns, onSuccess, resetForm, onOpenChange, toast]);
+
+  const handleUpdateWithoutAgent = useCallback(async () => {
+    setIsCreatingTask(true);
+    try {
+      const result = await performTaskUpdate();
+      if (!result) return;
+      onSuccess?.(result.updatedTask, 'edit');
+    } catch (error) {
+      toast({ title: 'Failed to update task', description: error instanceof Error ? error.message : 'An error occurred', variant: 'error' });
+    } finally {
+      resetForm();
+      setIsCreatingTask(false);
+      onOpenChange(false);
+    }
+  }, [performTaskUpdate, onSuccess, onOpenChange, resetForm, toast]);
+
+  const handleCreateSubmit = useCallback(async () => {
+    const trimmedTitle = taskName.trim();
+    if (!trimmedTitle) return;
+    if (!workspaceId || !boardId) return;
+    if (!repositoryId && !selectedLocalRepo) return;
+    if (!agentProfileId) return;
+    const columnId = editingTask?.workflowStepId ?? defaultColumnId;
+    if (!columnId) return;
+
+    const description = descriptionInputRef.current?.getValue() ?? '';
+    const trimmedDescription = description.trim();
+    const repositoriesPayload = getRepositoriesPayload();
+
+    setIsCreatingTask(true);
+    try {
+      if (trimmedDescription) {
+        // "Start" mode: create task + start agent in background, stay on board
+        const autoStartStep = columns.find((column) => column.autoStartAgent);
+        const targetColumnId = autoStartStep?.id ?? columnId;
+
+        const taskResponse = await createTask({
+          workspace_id: workspaceId,
+          board_id: boardId,
+          workflow_step_id: targetColumnId,
+          title: trimmedTitle,
+          description: trimmedDescription,
+          repositories: repositoriesPayload,
+          state: 'IN_PROGRESS',
+          start_agent: true,
+          agent_profile_id: agentProfileId || undefined,
+          executor_id: executorId || undefined,
+        });
+        const newSessionId = taskResponse.session_id ?? taskResponse.primary_session_id ?? null;
+        onSuccess?.(taskResponse, 'create', { taskSessionId: newSessionId });
+        resetForm();
+        onOpenChange(false);
+      } else {
+        // "Plan" mode: create task + session only (no agent), navigate to session
+        const taskResponse = await createTask({
+          workspace_id: workspaceId,
+          board_id: boardId,
+          workflow_step_id: columnId,
+          title: trimmedTitle,
+          description: '',
+          repositories: repositoriesPayload,
+          state: 'CREATED',
+          prepare_session: true,
+          agent_profile_id: agentProfileId || undefined,
+          executor_id: executorId || undefined,
+        });
+        const newSessionId = taskResponse.session_id ?? taskResponse.primary_session_id ?? null;
+        const newTaskId = taskResponse.id;
+        onSuccess?.(taskResponse, 'create', { taskSessionId: newSessionId });
+        resetForm();
+
+        if (newSessionId) {
+          setActiveDocument(newSessionId, { type: 'plan', taskId: newTaskId });
+          useDockviewStore.getState().queuePanelAction({
+            id: 'plan',
+            component: 'plan',
+            title: 'Plan',
+            placement: 'right',
+            referencePanel: 'chat',
+          });
+          setPlanMode(newSessionId, true);
+          router.push(linkToSession(newSessionId));
+        } else {
+          onOpenChange(false);
+        }
+      }
+    } catch (error) {
+      toast({ title: 'Failed to create task', description: error instanceof Error ? error.message : 'An error occurred', variant: 'error' });
+    } finally {
+      setIsCreatingTask(false);
+    }
+  }, [
+    taskName, workspaceId, boardId, repositoryId, selectedLocalRepo, agentProfileId, executorId,
+    editingTask, defaultColumnId, columns, getRepositoriesPayload, onSuccess, resetForm, onOpenChange,
+    setActiveDocument, setPlanMode, router, toast,
+  ]);
+
+  const handleCreateWithoutAgent = useCallback(async () => {
+    const trimmedTitle = taskName.trim();
+    const description = descriptionInputRef.current?.getValue() ?? '';
+    const trimmedDescription = description.trim();
+    if (!trimmedTitle || !trimmedDescription) return;
+    if (!workspaceId || !boardId) return;
+    if (!repositoryId && !selectedLocalRepo) return;
+    if (!agentProfileId) return;
+    const columnId = defaultColumnId;
+    if (!columnId) return;
+
+    setIsCreatingTask(true);
+    try {
+      const reposPayload = getRepositoriesPayload();
+      const taskResponse = await createTask({
+        workspace_id: workspaceId,
+        board_id: boardId,
+        workflow_step_id: columnId,
+        title: trimmedTitle,
+        description: trimmedDescription,
+        repositories: reposPayload,
+        state: 'CREATED',
+        agent_profile_id: agentProfileId || undefined,
+        executor_id: executorId || undefined,
+      });
+      onSuccess?.(taskResponse, 'create');
+      resetForm();
+      onOpenChange(false);
+    } catch (error) {
+      toast({ title: 'Failed to create task', description: error instanceof Error ? error.message : 'An error occurred', variant: 'error' });
+    } finally {
+      setIsCreatingTask(false);
+    }
+  }, [
+    taskName, workspaceId, boardId, repositoryId, selectedLocalRepo,
+    agentProfileId, defaultColumnId, executorId, getRepositoriesPayload,
+    onSuccess, onOpenChange, resetForm, toast,
+  ]);
+
+  // Dispatch to the correct handler based on mode
+  const handleSubmit = useCallback(async (e: FormEvent) => {
+    e.preventDefault();
+    if (isSessionMode) return handleSessionSubmit();
+    if (isEditMode) return handleEditSubmit();
+    return handleCreateSubmit();
+  }, [isSessionMode, isEditMode, handleSessionSubmit, handleEditSubmit, handleCreateSubmit]);
 
   // Use keyboard shortcut hook for Cmd+Enter / Ctrl+Enter
   const handleKeyDown = useKeyboardShortcutHandler(SHORTCUTS.SUBMIT, (event) => {
     handleSubmit(event as unknown as FormEvent);
   });
 
-  const handleSubmit = async (e: FormEvent) => {
-    e.preventDefault();
-
-    // Get values from refs
-    const title = titleInputRef.current?.getValue() ?? '';
-    const description = descriptionInputRef.current?.getValue() ?? '';
-
-    // Session mode - create a new session
-    if (isSessionMode) {
-      const trimmedDescription = description.trim();
-      if (!trimmedDescription || !agentProfileId) return;
-
-      // If onCreateSession is provided (legacy mode), delegate to parent
-      if (onCreateSession) {
-        onCreateSession({
-          prompt: trimmedDescription,
-          agentProfileId,
-          executorId,
-          environmentId,
-        });
-        // Reset form
-        setHasDescription(false);
-        setAgentProfileId('');
-        setExecutorId('');
-        setEnvironmentId('');
-        onOpenChange(false);
-        return;
-      }
-
-      // Handle session creation directly with spinner and navigation
-      if (!taskId) return;
-
-      setIsCreatingSession(true);
-      try {
-        const client = getWebSocketClient();
-        if (!client) {
-          throw new Error('WebSocket client not available');
-        }
-
-        interface StartResponse {
-          success: boolean;
-          task_id: string;
-          agent_instance_id: string;
-          session_id?: string;
-          state: string;
-        }
-
-        const response = await client.request<StartResponse>(
-          'orchestrator.start',
-          {
-            task_id: taskId,
-            agent_profile_id: agentProfileId,
-            executor_id: executorId,
-            prompt: trimmedDescription,
-          },
-          15000
-        );
-
-        const newSessionId = response?.session_id;
-
-        // Reset form
-        setHasDescription(false);
-        setAgentProfileId('');
-        setExecutorId('');
-        setEnvironmentId('');
-
-        // Navigate to the new session (this will unmount the dialog)
-        if (newSessionId) {
-          router.push(linkToSession(newSessionId));
-        } else {
-          onOpenChange(false);
-        }
-      } catch (error) {
-        toast({
-          title: 'Failed to create session',
-          description: error instanceof Error ? error.message : 'An error occurred while creating the session',
-          variant: 'error',
-        });
-      } finally {
-        setIsCreatingSession(false);
-      }
-      return;
-    }
-
-    // Task mode - create or edit task
-    const trimmedTitle = isEditMode
-      ? title.trim()
-      : taskName.trim();
-    if (!trimmedTitle) return;
-    if (isEditMode && editingTask) {
-      try {
-        const updatePayload: Parameters<typeof updateTask>[1] = {
-          title: trimmedTitle,
-          description: description.trim(),
-        };
-
-        const needsRepository = startAgent && !editingTask.repositoryId;
-        if (repositoryId) {
-          updatePayload.repositories = [{ repository_id: repositoryId, base_branch: branch || undefined }];
-        } else if (selectedLocalRepo && needsRepository) {
-          console.warn('[TaskCreateDialog] Local repo selection in edit mode not fully supported');
-        }
-
-        const updatedTask = await updateTask(editingTask.id, updatePayload);
-
-        let taskSessionId: string | null = null;
-        if (startAgent && agentProfileId) {
-          const client = getWebSocketClient();
-          if (client) {
-            try {
-              interface StartResponse {
-                success: boolean;
-                task_id: string;
-                agent_instance_id: string;
-                session_id?: string;
-                state: string;
-              }
-              const response = await client.request<StartResponse>(
-                'orchestrator.start',
-                {
-                  task_id: editingTask.id,
-                  agent_profile_id: agentProfileId,
-                  prompt: description.trim() || '',
-                },
-                15000
-              );
-              taskSessionId = response?.session_id ?? null;
-            } catch (error) {
-              console.error('[TaskCreateDialog] failed to start agent:', error);
-            }
-          }
-        }
-
-        onSuccess?.(updatedTask, 'edit', { taskSessionId });
-      } finally {
-        setHasTitle(false);
-        setHasDescription(false);
-        setRepositoryId('');
-        setBranch('');
-        setStartAgent(false);
-        setAgentProfileId('');
-        onOpenChange(false);
-      }
-      return;
-    }
-    if (!workspaceId || !boardId) return;
-    if (!repositoryId && !selectedLocalRepo) return;
-    const columnId = editingTask?.workflowStepId ?? defaultColumnId;
-    if (!columnId) return;
-    let targetColumnId = columnId;
-    let targetState: Task['state'] = 'CREATED';
-    if (startAgent && !isEditMode) {
-      // Find the first step that has auto_start_agent enabled
-      const autoStartStep = columns.find((column) => column.autoStartAgent);
-      targetColumnId = autoStartStep?.id ?? columnId;
-      targetState = 'IN_PROGRESS';
-    }
-
-    setIsCreatingTask(true);
-    try {
-      const taskResponse = await createTask({
-        workspace_id: workspaceId,
-        board_id: boardId,
-        workflow_step_id: targetColumnId,
-        title: trimmedTitle,
-        description: description.trim(),
-        repositories: repositoryId
-          ? [
-            {
-              repository_id: repositoryId,
-              base_branch: branch || undefined,
-            },
-          ]
-          : selectedLocalRepo
-            ? [
-              {
-                repository_id: '',
-                base_branch: branch || undefined,
-                local_path: selectedLocalRepo.path,
-                default_branch: selectedLocalRepo.default_branch || undefined,
-              },
-            ]
-            : [],
-        state: targetState,
-        start_agent: Boolean(startAgent && !isEditMode && agentProfileId),
-        agent_profile_id: startAgent ? agentProfileId || undefined : undefined,
-        executor_id: startAgent ? executorId || undefined : undefined,
-      });
-      // Try session_id first, then primary_session_id as fallback
-      const newSessionId = taskResponse.session_id ?? taskResponse.primary_session_id ?? null;
-      onSuccess?.(taskResponse, 'create', {
-        taskSessionId: newSessionId,
-      });
-
-      // Reset form and close dialog
-      setHasTitle(false);
-      setHasDescription(false);
-      setTaskName('');
-      setRepositoryId('');
-      setBranch('');
-      setStartAgent(!isEditMode);
-      setAgentProfileId('');
-      setEnvironmentId('');
-      setExecutorId('');
-
-      // Navigate to the new session if one was created and navigation is enabled
-      if (newSessionId && navigateOnSessionCreate) {
-        router.push(linkToSession(newSessionId));
-      } else {
-        onOpenChange(false);
-      }
-    } catch (error) {
-      toast({
-        title: 'Failed to create task',
-        description: error instanceof Error ? error.message : 'An error occurred while creating the task',
-        variant: 'error',
-      });
-    } finally {
-      setIsCreatingTask(false);
-    }
-  };
-
-  // Access layout/UI store for plan mode creation
-  const setActiveDocument = useAppStore((state) => state.setActiveDocument);
-  const setPlanMode = useAppStore((state) => state.setPlanMode);
-  const { addPlan } = usePanelActions();
-
-  const handleCreateInPlanMode = async () => {
-    if (!workspaceId || !boardId) return;
-    if (!repositoryId && !selectedLocalRepo) return;
-    const columnId = defaultColumnId;
-    if (!columnId) return;
-    if (!agentProfileId) return;
-
-    const trimmedTitle = taskName.trim();
-    if (!trimmedTitle) return;
-
-    const description = (descriptionInputRef.current?.getValue() ?? '').trim();
-
-    // Find auto-start step
-    const autoStartStep = columns.find((column) => column.autoStartAgent);
-    const targetColumnId = autoStartStep?.id ?? columnId;
-
-    setIsCreatingTask(true);
-    try {
-      const taskResponse = await createTask({
-        workspace_id: workspaceId,
-        board_id: boardId,
-        workflow_step_id: targetColumnId,
-        title: trimmedTitle,
-        description,
-        repositories: repositoryId
-          ? [{ repository_id: repositoryId, base_branch: branch || undefined }]
-          : selectedLocalRepo
-            ? [{
-                repository_id: '',
-                base_branch: branch || undefined,
-                local_path: selectedLocalRepo.path,
-                default_branch: selectedLocalRepo.default_branch || undefined,
-              }]
-            : [],
-        state: 'IN_PROGRESS',
-        start_agent: true,
-        agent_profile_id: agentProfileId || undefined,
-        executor_id: executorId || undefined,
-        plan_mode: true,
-      });
-
-      const newSessionId = taskResponse.session_id ?? taskResponse.primary_session_id ?? null;
-      const newTaskId = taskResponse.id;
-      onSuccess?.(taskResponse, 'create', { taskSessionId: newSessionId });
-
-      // Reset form
-      setHasTitle(false);
-      setHasDescription(false);
-      setTaskName('');
-      setRepositoryId('');
-      setBranch('');
-      setStartAgent(true);
-      setAgentProfileId('');
-      setEnvironmentId('');
-      setExecutorId('');
-
-      // Set document panel state before navigation
-      if (newSessionId) {
-        setActiveDocument(newSessionId, { type: 'plan', taskId: newTaskId });
-        addPlan();
-        setPlanMode(newSessionId, true);
-        router.push(linkToSession(newSessionId));
-      } else {
-        onOpenChange(false);
-      }
-    } catch (error) {
-      toast({
-        title: 'Failed to create task',
-        description: error instanceof Error ? error.message : 'An error occurred while creating the task',
-        variant: 'error',
-      });
-    } finally {
-      setIsCreatingTask(false);
-    }
-  };
-
-  const handleCancel = () => {
-    setHasTitle(false);
-    setHasDescription(false);
-    setTaskName('');
-    setRepositoryId('');
-    setBranch('');
-    setStartAgent(!isEditMode);
-    setAgentProfileId('');
-    setEnvironmentId('');
-    setExecutorId('');
+  const handleCancel = useCallback(() => {
+    resetForm();
     onOpenChange(false);
-  };
+  }, [resetForm, onOpenChange]);
 
   return (
     <Dialog open={open} onOpenChange={onOpenChange}>
       <DialogContent className="w-full h-full max-w-full max-h-full rounded-none sm:w-[900px] sm:h-auto sm:max-w-none sm:max-h-[85vh] sm:rounded-lg flex flex-col bg-card">
         <DialogHeader>
-          {isCreateMode ? (
+          {isCreateMode || isEditMode ? (
             <DialogTitle asChild>
               <div className="flex items-center gap-1 min-w-0 text-sm font-medium">
                 <RepositorySelector
@@ -1154,10 +1060,10 @@ export function TaskCreateDialog({
                   triggerClassName="w-auto text-sm"
                 />
                 <span className="text-muted-foreground mr-2">/</span>
-                <InlineTaskName value={taskName} onChange={handleTaskNameChange} autoFocus />
+                <InlineTaskName value={taskName} onChange={handleTaskNameChange} autoFocus={!isEditMode} />
               </div>
             </DialogTitle>
-          ) : isSessionMode ? (
+          ) : (
             <DialogTitle asChild>
               <div className="flex items-center gap-1 min-w-0 text-sm font-medium">
                 {sessionRepoName && (
@@ -1171,49 +1077,21 @@ export function TaskCreateDialog({
                 <span className="text-muted-foreground whitespace-nowrap">new session</span>
               </div>
             </DialogTitle>
-          ) : (
-            <DialogTitle>Edit Task</DialogTitle>
           )}
         </DialogHeader>
         <form onSubmit={handleSubmit} className="flex flex-col gap-4 overflow-hidden">
           <div className="flex-1 space-y-4 overflow-y-auto pr-1">
             <TaskFormInputs
-              key={`${open}-${initialValues?.title ?? ''}-${initialValues?.description ?? ''}`}
+              key={`${open}-${initialValues?.description ?? ''}`}
               isSessionMode={isSessionMode}
-              showTitleInput={isEditMode}
-              initialTitle={initialValues?.title ?? ''}
+              autoFocus={isEditMode}
               initialDescription={initialValues?.description ?? ''}
-              onTitleChange={setHasTitle}
               onDescriptionChange={setHasDescription}
               onKeyDown={handleKeyDown}
-              titleValueRef={titleInputRef}
               descriptionValueRef={descriptionInputRef}
             />
             {!isSessionMode && (
-              <div className={`grid gap-4 grid-cols-1 ${isEditMode ? 'sm:grid-cols-4' : 'sm:grid-cols-3'}`}>
-                {isEditMode && (
-                  <div>
-                    <RepositorySelector
-                      options={repositoryOptions}
-                      value={repositoryId || discoveredRepoPath}
-                      onValueChange={handleRepositoryChange}
-                      placeholder={
-                        !workspaceId
-                          ? 'Select workspace first'
-                          : repositoriesLoading || discoverReposLoading
-                            ? 'Loading repositories...'
-                            : 'Select repository'
-                      }
-                      searchPlaceholder="Search repositories..."
-                      emptyMessage={
-                        repositoriesLoading || discoverReposLoading
-                          ? 'Loading repositories...'
-                          : 'No repositories found.'
-                      }
-                      disabled={!workspaceId || repositoriesLoading || discoverReposLoading || isEditMode}
-                    />
-                  </div>
-                )}
+              <div className="grid gap-4 grid-cols-1 sm:grid-cols-3">
                 <div>
                   <BranchSelector
                     options={branchOptions}
@@ -1235,54 +1113,49 @@ export function TaskCreateDialog({
                     searchPlaceholder="Search branches..."
                     emptyMessage="No branch found."
                     disabled={
-                      isEditMode ||
                       !hasRepositorySelection ||
                       (repositoryId && branchesLoading) ||
                       (!repositoryId && (localBranchesLoading || branchOptions.length === 0))
                     }
                   />
                 </div>
-                {startAgent && (
-                  <div>
-                    {agentProfiles.length === 0 && !agentProfilesLoading ? (
-                      <div className="flex h-7 items-center justify-center gap-2 rounded-sm border border-input px-3 text-xs text-muted-foreground">
-                        <span>No agents found.</span>
-                        <Link href="/settings/agents" className="text-primary hover:underline">
-                          Add agent
-                        </Link>
-                      </div>
-                    ) : (
-                      <AgentSelector
-                        options={agentProfileOptions}
-                        value={agentProfileId}
-                        onValueChange={handleAgentProfileChange}
-                        placeholder={
-                          agentProfilesLoading
-                            ? 'Loading agents...'
-                            : agentProfiles.length === 0
-                              ? 'No agents available'
-                              : 'Select agent'
-                        }
-                        disabled={agentProfilesLoading || isCreatingSession}
-                      />
-                    )}
-                  </div>
-                )}
-                {startAgent && (
-                  <div>
-                    <ExecutorSelector
-                      options={executorOptions}
-                      value={executorId}
-                      onValueChange={setExecutorId}
+                <div>
+                  {agentProfiles.length === 0 && !agentProfilesLoading ? (
+                    <div className="flex h-7 items-center justify-center gap-2 rounded-sm border border-input px-3 text-xs text-muted-foreground">
+                      <span>No agents found.</span>
+                      <Link href="/settings/agents" className="text-primary hover:underline">
+                        Add agent
+                      </Link>
+                    </div>
+                  ) : (
+                    <AgentSelector
+                      options={agentProfileOptions}
+                      value={agentProfileId}
+                      onValueChange={handleAgentProfileChange}
                       placeholder={
-                        executorsLoading
-                          ? 'Loading executors...'
-                          : 'Select executor'
+                        agentProfilesLoading
+                          ? 'Loading agents...'
+                          : agentProfiles.length === 0
+                            ? 'No agents available'
+                            : 'Select agent'
                       }
-                      disabled={executorsLoading || isEditMode}
+                      disabled={agentProfilesLoading || isCreatingSession}
                     />
-                  </div>
-                )}
+                  )}
+                </div>
+                <div>
+                  <ExecutorSelector
+                    options={executorOptions}
+                    value={executorId}
+                    onValueChange={setExecutorId}
+                    placeholder={
+                      executorsLoading
+                        ? 'Loading executors...'
+                        : 'Select executor'
+                    }
+                    disabled={executorsLoading}
+                  />
+                </div>
               </div>
             )}
 
@@ -1308,94 +1181,81 @@ export function TaskCreateDialog({
 
           </div>
           <DialogFooter className="border-t border-border pt-3 flex-col gap-3 sm:flex-row sm:gap-2">
-            {!isSessionMode && (
+            {!isSessionMode && executorHint && (
               <div className="flex flex-1 items-center gap-3 text-sm text-muted-foreground">
-                <div className="flex items-center gap-2">
-                  <input
-                    id="start-agent"
-                    type="checkbox"
-                    checked={startAgent}
-                    onChange={(e) => setStartAgent(e.target.checked)}
-                    className="h-4 w-4 rounded border border-input text-primary focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
-                  />
-                  <TooltipProvider>
-                    <Tooltip>
-                      <TooltipTrigger asChild>
-                        <Label htmlFor="start-agent" className="cursor-pointer">
-                          Start Agent
-                        </Label>
-                      </TooltipTrigger>
-                      <TooltipContent>
-                        {isEditMode
-                          ? 'Start the agent after saving changes.'
-                          : 'Start the agent on task creation.'}
-                      </TooltipContent>
-                    </Tooltip>
-                  </TooltipProvider>
-                </div>
-                {startAgent && executorHint && (
-                  <span className="text-xs text-muted-foreground">
-                    {executorHint}
-                  </span>
-                )}
+                <span className="text-xs text-muted-foreground">
+                  {executorHint}
+                </span>
               </div>
             )}
             <DialogClose asChild>
-              <Button type="button" variant="outline" onClick={handleCancel} disabled={isCreatingSession || isCreatingTask} className="w-full h-10 border-0 sm:w-auto sm:h-7 sm:border">
+              <Button type="button" variant="outline" onClick={handleCancel} disabled={isCreatingSession || isCreatingTask} className="w-full h-10 border-0 cursor-pointer sm:w-auto sm:h-7 sm:border">
                 Cancel
               </Button>
             </DialogClose>
-            {isCreateMode && startAgent && (
-              <Tooltip>
-                <TooltipTrigger asChild>
-                  <Button
-                    type="button"
-                    variant="outline"
-                    className="w-full h-10 sm:w-auto sm:h-7 gap-1.5"
-                    disabled={
-                      isCreatingSession ||
-                      isCreatingTask ||
-                      !hasTitle ||
-                      (!repositoryId && !selectedLocalRepo) ||
-                      !branch ||
-                      !agentProfileId
-                    }
-                    onClick={handleCreateInPlanMode}
-                  >
-                    <IconListCheck className="h-3.5 w-3.5" />
-                    Plan
-                  </Button>
-                </TooltipTrigger>
-                <TooltipContent>Create task and open in plan mode (no description needed)</TooltipContent>
-              </Tooltip>
-            )}
             <KeyboardShortcutTooltip shortcut={SHORTCUTS.SUBMIT}>
-              <Button
-                type="submit"
-                className="w-full h-10 sm:w-auto sm:h-7"
-                disabled={
-                  isCreatingSession ||
-                  isCreatingTask ||
-                  (isSessionMode
-                    ? !hasDescription || !agentProfileId
-                    : !hasTitle ||
-                    !hasDescription ||
-                    (!isEditMode && !repositoryId && !selectedLocalRepo) ||
-                    (startAgent && !agentProfileId) ||
-                    (isEditMode && startAgent && !editingTask?.repositoryId && !repositoryId))
-                }
-              >
-                {isCreatingSession || isCreatingTask ? (
-                  <>
-                    <IconLoader2 className="mr-2 h-4 w-4 animate-spin" />
-                    Creating...
-                  </>
-                ) : isSessionMode ? (
-                  'Create Session'
-                ) : (
-                  submitLabel
-                )}
-              </Button>
+              {(isCreateMode && hasDescription) || (isEditMode && agentProfileId) ? (
+                <div className="inline-flex rounded-md border border-border overflow-hidden sm:h-7 h-10">
+                  <Button
+                    type="submit"
+                    variant="default"
+                    className="rounded-none border-0 cursor-pointer gap-1.5 h-full"
+                    disabled={isCreatingTask || !hasTitle || (!repositoryId && !selectedLocalRepo) || !branch || !agentProfileId}
+                  >
+                    {isCreatingTask ? <IconLoader2 className="h-3.5 w-3.5 animate-spin" /> : <IconSend className="h-3.5 w-3.5" />}
+                    {isCreatingTask ? 'Starting...' : 'Start task'}
+                  </Button>
+                  <DropdownMenu>
+                    <DropdownMenuTrigger asChild>
+                      <Button
+                        type="button"
+                        variant="default"
+                        className="rounded-none border-0 border-l border-primary-foreground/20 px-2 cursor-pointer h-full"
+                        disabled={isCreatingTask || !hasTitle || (!repositoryId && !selectedLocalRepo) || !branch || !agentProfileId}
+                      >
+                        <IconChevronDown className="h-3.5 w-3.5" />
+                      </Button>
+                    </DropdownMenuTrigger>
+                    <DropdownMenuContent align="end" className="w-auto min-w-max">
+                      <DropdownMenuItem
+                        onClick={isEditMode ? handleUpdateWithoutAgent : handleCreateWithoutAgent}
+                        className="cursor-pointer whitespace-nowrap focus:bg-muted/80 hover:bg-muted/80"
+                      >
+                        {isEditMode ? 'Update task' : 'Create without starting agent'}
+                      </DropdownMenuItem>
+                    </DropdownMenuContent>
+                  </DropdownMenu>
+                </div>
+              ) : (
+                <Button
+                  type="submit"
+                  variant={'default'}
+                  className={`w-full h-10 cursor-pointer sm:w-auto sm:h-7 gap-1.5 ${isCreateMode && !hasDescription ? 'bg-blue-600 border-blue-500 text-white hover:bg-blue-700 hover:text-white' : ''}`}
+                  disabled={
+                    isCreatingSession ||
+                    isCreatingTask ||
+                    (isSessionMode
+                      ? !hasDescription || !agentProfileId
+                      : !hasTitle || (!repositoryId && !selectedLocalRepo) || !branch)
+                  }
+                >
+                  {isCreatingSession || isCreatingTask ? (
+                    <>
+                      <IconLoader2 className="h-3.5 w-3.5 animate-spin" />
+                      {isEditMode ? 'Updating...' : 'Starting...'}
+                    </>
+                  ) : isSessionMode ? (
+                    'Create Session'
+                  ) : isCreateMode ? (
+                    <>
+                      <IconFileInvoice className="h-3.5 w-3.5" />
+                      Start Plan Mode
+                    </>
+                  ) : (
+                    'Update task'
+                  )}
+                </Button>
+              )}
             </KeyboardShortcutTooltip>
           </DialogFooter>
         </form>
diff --git a/apps/web/components/task/chat/messages/agent-status.tsx b/apps/web/components/task/chat/messages/agent-status.tsx
index 646d3da23c..0ccee1883c 100644
--- a/apps/web/components/task/chat/messages/agent-status.tsx
+++ b/apps/web/components/task/chat/messages/agent-status.tsx
@@ -14,7 +14,7 @@ type AgentStatusProps = {
 };
 
 const STATE_CONFIG: Record<TaskSessionState, { label: string; icon: 'spinner' | 'error' | 'warning' | null }> = {
-  CREATED: { label: 'Agent is being created', icon: 'spinner' },
+  CREATED: { label: '', icon: null },
   STARTING: { label: 'Agent is starting', icon: 'spinner' },
   RUNNING: { label: 'Agent is running', icon: 'spinner' },
   WAITING_FOR_INPUT: { label: '', icon: null },
diff --git a/apps/web/components/task/chat/virtualized-message-list.tsx b/apps/web/components/task/chat/virtualized-message-list.tsx
index 1700da16ef..c5953d3231 100644
--- a/apps/web/components/task/chat/virtualized-message-list.tsx
+++ b/apps/web/components/task/chat/virtualized-message-list.tsx
@@ -43,7 +43,8 @@ export const VirtualizedMessageList = memo(function VirtualizedMessageList({
   const previousHeightRef = useRef(0);
 
   const isInitialLoading = messagesLoading && messages.length === 0;
-  const showLoadingState = (messagesLoading || isInitialLoading) && !isWorking;
+  const isCreatedSession = sessionState === 'CREATED';
+  const showLoadingState = (messagesLoading || isInitialLoading) && !isWorking && !isCreatedSession;
   const { loadMore, hasMore, isLoading: isLoadingMore } = useLazyLoadMessages(sessionId);
 
   const itemCount = items.length;
diff --git a/apps/web/components/task/mobile/session-task-switcher-sheet.tsx b/apps/web/components/task/mobile/session-task-switcher-sheet.tsx
index be962eac1e..e7d8b9b43e 100644
--- a/apps/web/components/task/mobile/session-task-switcher-sheet.tsx
+++ b/apps/web/components/task/mobile/session-task-switcher-sheet.tsx
@@ -454,7 +454,7 @@ export const SessionTaskSwitcherSheet = memo(function SessionTaskSwitcherSheet({
       <TaskCreateDialog
         open={dialogOpen}
         onOpenChange={setDialogOpen}
-        mode="task"
+        mode="create"
         workspaceId={workspaceId}
         boardId={boardId}
         defaultColumnId={dialogColumns[0]?.id ?? null}
diff --git a/apps/web/components/task/task-item.tsx b/apps/web/components/task/task-item.tsx
index e5158c69f1..dbb010b5ce 100644
--- a/apps/web/components/task/task-item.tsx
+++ b/apps/web/components/task/task-item.tsx
@@ -64,7 +64,7 @@ export const TaskItem = memo(function TaskItem({
   // Effective open state: keep menu open while deleting
   const effectiveMenuOpen = menuOpen || isDeleting;
 
-  const isInProgress = state === 'IN_PROGRESS' || state === 'SCHEDULING' || state === 'CREATED';
+  const isInProgress = state === 'IN_PROGRESS' || state === 'SCHEDULING';
   const hasDiffStats = diffStats && (diffStats.additions > 0 || diffStats.deletions > 0);
 
   // Determine what to show on the right side
diff --git a/apps/web/components/task/task-session-sidebar.tsx b/apps/web/components/task/task-session-sidebar.tsx
index 84de4ffa77..7559834aa3 100644
--- a/apps/web/components/task/task-session-sidebar.tsx
+++ b/apps/web/components/task/task-session-sidebar.tsx
@@ -46,7 +46,7 @@ export const NewTaskButton = memo(function NewTaskButton({
       <TaskCreateDialog
         open={dialogOpen}
         onOpenChange={setDialogOpen}
-        mode="task"
+        mode="create"
         workspaceId={workspaceId}
         boardId={boardId}
         defaultColumnId={columns[0]?.id ?? null}
diff --git a/apps/web/hooks/domains/kanban/use-kanban-actions.ts b/apps/web/hooks/domains/kanban/use-kanban-actions.ts
index 2756e90f14..c743c250de 100644
--- a/apps/web/hooks/domains/kanban/use-kanban-actions.ts
+++ b/apps/web/hooks/domains/kanban/use-kanban-actions.ts
@@ -8,12 +8,11 @@ import type { Task as BackendTask } from '@/lib/types/http';
 import type { KanbanState, WorkspaceState, BoardState } from '@/lib/state/slices';
 
 type UseKanbanActionsOptions = {
-  kanban: KanbanState;
   workspaceState: WorkspaceState;
   boardsState: BoardState;
 };
 
-export function useKanbanActions({ kanban, workspaceState, boardsState }: UseKanbanActionsOptions) {
+export function useKanbanActions({ workspaceState, boardsState }: UseKanbanActionsOptions) {
   const router = useRouter();
   const store = useAppStoreApi();
 
@@ -31,40 +30,64 @@ export function useKanbanActions({ kanban, workspaceState, boardsState }: UseKan
   } = useTaskCRUD();
 
   // Handle task dialog success (create/update)
+  // Read current kanban state at call time (not from closure) to avoid
+  // overwriting WebSocket-driven updates that arrived while the dialog was open.
   const handleDialogSuccess = useCallback(
     (task: BackendTask, mode: 'create' | 'edit') => {
+      const currentKanban = store.getState().kanban;
       if (mode === 'create') {
-        store.getState().hydrate({
-          kanban: {
-            ...kanban,
-            tasks: [
-              ...kanban.tasks,
-              {
-                id: task.id,
-                workflowStepId: task.workflow_step_id,
-                title: task.title,
-                description: task.description ?? undefined,
-                position: task.position ?? 0,
-                state: task.state,
-                repositoryId: task.repositories?.[0]?.repository_id ?? undefined,
+        const repoId = task.repositories?.[0]?.repository_id ?? undefined;
+        const existing = currentKanban.tasks.find((t: KanbanState['tasks'][number]) => t.id === task.id);
+        if (existing) {
+          // WebSocket may have added the task already but without repositoryId.
+          // Merge in any missing fields from the API response.
+          if (repoId && !existing.repositoryId) {
+            store.getState().hydrate({
+              kanban: {
+                ...currentKanban,
+                tasks: currentKanban.tasks.map((t: KanbanState['tasks'][number]) =>
+                  t.id === task.id ? { ...t, repositoryId: repoId } : t
+                ),
               },
-            ],
-          },
-        });
+            });
+          }
+        } else {
+          store.getState().hydrate({
+            kanban: {
+              ...currentKanban,
+              tasks: [
+                ...currentKanban.tasks,
+                {
+                  id: task.id,
+                  workflowStepId: task.workflow_step_id,
+                  title: task.title,
+                  description: task.description ?? undefined,
+                  position: task.position ?? 0,
+                  state: task.state,
+                  repositoryId: repoId,
+                },
+              ],
+            },
+          });
+        }
+        // Invalidate workspace repos cache so newly created repos show up in the edit dialog
+        if (task.workspace_id) {
+          store.getState().invalidateRepositories(task.workspace_id);
+        }
         return;
       }
+      // Only update fields that the edit dialog changes (title, description, repositories).
+      // State and workflowStepId are managed by the backend via WebSocket events
+      // (e.g. orchestrator.start moves the task to the auto-start column).
       store.getState().hydrate({
         kanban: {
-          ...kanban,
-          tasks: kanban.tasks.map((item: KanbanState['tasks'][number]) =>
+          ...currentKanban,
+          tasks: currentKanban.tasks.map((item: KanbanState['tasks'][number]) =>
             item.id === task.id
               ? {
                   ...item,
                   title: task.title,
                   description: task.description ?? undefined,
-                  workflowStepId: task.workflow_step_id ?? item.workflowStepId,
-                  position: task.position ?? item.position,
-                  state: task.state ?? item.state,
                   repositoryId: task.repositories?.[0]?.repository_id ?? item.repositoryId,
                 }
               : item
@@ -72,7 +95,7 @@ export function useKanbanActions({ kanban, workspaceState, boardsState }: UseKan
         },
       });
     },
-    [kanban, store]
+    [store]
   );
 
   // Handle workspace change with navigation
diff --git a/apps/web/hooks/domains/session/use-session-state.ts b/apps/web/hooks/domains/session/use-session-state.ts
index 616c59d346..1c84179484 100644
--- a/apps/web/hooks/domains/session/use-session-state.ts
+++ b/apps/web/hooks/domains/session/use-session-state.ts
@@ -13,7 +13,7 @@ export function useSessionState(sessionId: string | null) {
   const taskDescription = task?.description ?? null;
   const isStarting = session?.state === 'STARTING';
   const isWorking = isStarting || session?.state === 'RUNNING';
-  const isAgentBusy = session?.state === 'CREATED' || session?.state === 'RUNNING';
+  const isAgentBusy = session?.state === 'RUNNING';
   const isFailed = session?.state === 'FAILED' || session?.state === 'CANCELLED';
 
   return {
diff --git a/apps/web/hooks/domains/session/use-session.ts b/apps/web/hooks/domains/session/use-session.ts
index 5fd3a81721..fad9aa9eb5 100644
--- a/apps/web/hooks/domains/session/use-session.ts
+++ b/apps/web/hooks/domains/session/use-session.ts
@@ -15,11 +15,17 @@ export function useSession(sessionId: string | null): UseSessionResult {
     sessionId ? state.taskSessions.items[sessionId] ?? null : null
   );
   const connectionStatus = useAppStore((state) => state.connection.status);
+  const agentctlReady = useAppStore((state) =>
+    sessionId ? state.sessionAgentctl.itemsBySessionId[sessionId]?.status === 'ready' : false
+  );
 
   const isActive = useMemo(() => {
     if (!session?.state) return false;
-    return session.state === 'RUNNING' || session.state === 'WAITING_FOR_INPUT';
-  }, [session?.state]);
+    if (session.state === 'RUNNING' || session.state === 'WAITING_FOR_INPUT') return true;
+    // Workspace infrastructure (agentctl) is ready even though the agent CLI hasn't started
+    if (session.state === 'CREATED' && agentctlReady) return true;
+    return false;
+  }, [session?.state, agentctlReady]);
 
   const isFailed = useMemo(() => {
     return session?.state === 'FAILED';
diff --git a/apps/web/hooks/domains/workspace/use-repository-branches.ts b/apps/web/hooks/domains/workspace/use-repository-branches.ts
index 15276c9e31..ca8be01172 100644
--- a/apps/web/hooks/domains/workspace/use-repository-branches.ts
+++ b/apps/web/hooks/domains/workspace/use-repository-branches.ts
@@ -24,26 +24,22 @@ export function useRepositoryBranches(repositoryId: string | null, enabled = tru
   useEffect(() => {
     if (!enabled || !repositoryId) return;
     if (isLoaded || inFlightRef.current) return;
-    let cancelled = false;
     inFlightRef.current = true;
     setRepositoryBranchesLoading(repositoryId, true);
-    listRepositoryBranches(repositoryId, { cache: 'no-store' })
+    // Capture the repositoryId at effect start for the closure
+    const fetchRepoId = repositoryId;
+    listRepositoryBranches(fetchRepoId, { cache: 'no-store' })
       .then((response) => {
-        if (cancelled) return;
-        setRepositoryBranches(repositoryId, response.branches);
+        // Safe to always store: data is keyed by repositoryId in the store
+        setRepositoryBranches(fetchRepoId, response.branches);
       })
       .catch(() => {
-        if (cancelled) return;
-        setRepositoryBranches(repositoryId, []);
+        setRepositoryBranches(fetchRepoId, []);
       })
       .finally(() => {
         inFlightRef.current = false;
-        if (cancelled) return;
-        setRepositoryBranchesLoading(repositoryId, false);
+        setRepositoryBranchesLoading(fetchRepoId, false);
       });
-    return () => {
-      cancelled = true;
-    };
   }, [enabled, isLoaded, repositoryId, setRepositoryBranches, setRepositoryBranchesLoading]);
 
   return { branches, isLoading };
diff --git a/apps/web/lib/api/domains/kanban-api.ts b/apps/web/lib/api/domains/kanban-api.ts
index 54a00c533d..da3a080266 100644
--- a/apps/web/lib/api/domains/kanban-api.ts
+++ b/apps/web/lib/api/domains/kanban-api.ts
@@ -39,6 +39,7 @@ export async function createTask(
     }>;
     state?: Task['state'];
     start_agent?: boolean;
+    prepare_session?: boolean;
     agent_profile_id?: string;
     executor_id?: string;
     plan_mode?: boolean;
diff --git a/apps/web/lib/state/dockview-store.ts b/apps/web/lib/state/dockview-store.ts
index 20ead19e86..220be1c310 100644
--- a/apps/web/lib/state/dockview-store.ts
+++ b/apps/web/lib/state/dockview-store.ts
@@ -12,6 +12,21 @@ export type FileEditorState = {
     isBinary?: boolean;
 };
 
+/** Direction relative to a reference panel or group. */
+export type PanelDirection = 'left' | 'right' | 'above' | 'below';
+
+/** A deferred panel operation applied after the next layout build / restore. */
+export type DeferredPanelAction = {
+    id: string;
+    component: string;
+    title: string;
+    /** Where to place the panel. 'tab' adds as a tab in the reference group. */
+    placement: 'tab' | PanelDirection;
+    /** Panel ID or group alias to position relative to. Defaults to 'chat'. */
+    referencePanel?: string;
+    params?: Record<string, unknown>;
+};
+
 type DockviewStore = {
     api: DockviewApi | null;
     setApi: (api: DockviewApi | null) => void;
@@ -54,6 +69,10 @@ type DockviewStore = {
     isRestoringLayout: boolean;
     currentLayoutSessionId: string | null;
     switchSessionLayout: (oldSessionId: string | null, newSessionId: string) => void;
+
+    // Deferred panel actions — queued before navigation, applied after next layout build / restore
+    deferredPanelActions: DeferredPanelAction[];
+    queuePanelAction: (action: DeferredPanelAction) => void;
 };
 
 const SIDEBAR_GROUP = 'group-sidebar';
@@ -82,6 +101,32 @@ function focusOrAddPanel(api: DockviewApi, options: AddPanelOptions & { id: stri
     }
 }
 
+/**
+ * Drain the deferred panel action queue, applying each action to the dockview API.
+ * Call this after a layout build or restore so queued panels appear in the new layout.
+ */
+function applyDeferredPanelActions(api: DockviewApi, actions: DeferredPanelAction[]): void {
+    for (const action of actions) {
+        const ref = action.referencePanel ?? 'chat';
+        let position: AddPanelOptions['position'];
+        if (action.placement === 'tab') {
+            const groupId = api.getPanel(ref)?.group?.id;
+            if (groupId) {
+                position = { referenceGroup: groupId };
+            }
+        } else {
+            position = { referencePanel: ref, direction: action.placement };
+        }
+        focusOrAddPanel(api, {
+            id: action.id,
+            component: action.component,
+            title: action.title,
+            position,
+            ...(action.params ? { params: action.params } : {}),
+        });
+    }
+}
+
 /**
  * After fromJSON() restores a layout, apply fixups: re-lock sidebar,
  * fix old panel aliases, and return computed group IDs.
@@ -165,6 +210,11 @@ export const useDockviewStore = create<DockviewStore>((set, get) => ({
     isRestoringLayout: false,
     currentLayoutSessionId: null,
 
+    deferredPanelActions: [],
+    queuePanelAction: (action) => set((prev) => ({
+        deferredPanelActions: [...prev.deferredPanelActions, action],
+    })),
+
     switchSessionLayout: (oldSessionId, newSessionId) => {
         const { api, currentLayoutSessionId } = get();
         if (!api) return;
@@ -254,7 +304,7 @@ export const useDockviewStore = create<DockviewStore>((set, get) => ({
             id: 'terminal-default',
             component: 'terminal',
             title: 'Terminal',
-            params: { terminalId: 'default' },
+            params: { terminalId: 'shell-default' },
             position: { direction: 'below', referencePanel: 'changes' },
         });
 
@@ -268,6 +318,13 @@ export const useDockviewStore = create<DockviewStore>((set, get) => ({
             rightBottomGroupId: terminalPanel?.group?.id ?? RIGHT_BOTTOM_GROUP,
             sidebarGroupId: sidebarGroup.id,
         });
+
+        // Apply any queued panel actions (e.g., plan panel from plan mode task creation)
+        const pending = get().deferredPanelActions;
+        if (pending.length > 0) {
+            set({ deferredPanelActions: [] });
+            applyDeferredPanelActions(api, pending);
+        }
     },
 
     resetLayout: () => {
diff --git a/apps/web/lib/state/slices/workspace/types.ts b/apps/web/lib/state/slices/workspace/types.ts
index 10df9995fb..1b3da6826d 100644
--- a/apps/web/lib/state/slices/workspace/types.ts
+++ b/apps/web/lib/state/slices/workspace/types.ts
@@ -50,6 +50,7 @@ export type WorkspaceSliceActions = {
   setRepositoryScripts: (repositoryId: string, scripts: RepositoryScript[]) => void;
   setRepositoryScriptsLoading: (repositoryId: string, loading: boolean) => void;
   clearRepositoryScripts: (repositoryId: string) => void;
+  invalidateRepositories: (workspaceId: string) => void;
 };
 
 export type WorkspaceSlice = WorkspaceSliceState & WorkspaceSliceActions;
diff --git a/apps/web/lib/state/slices/workspace/workspace-slice.ts b/apps/web/lib/state/slices/workspace/workspace-slice.ts
index f0dd21382a..a616e371f6 100644
--- a/apps/web/lib/state/slices/workspace/workspace-slice.ts
+++ b/apps/web/lib/state/slices/workspace/workspace-slice.ts
@@ -66,4 +66,8 @@ export const createWorkspaceSlice: StateCreator<
       delete draft.repositoryScripts.loadingByRepositoryId[repositoryId];
       delete draft.repositoryScripts.loadedByRepositoryId[repositoryId];
     }),
+  invalidateRepositories: (workspaceId) =>
+    set((draft) => {
+      draft.repositories.loadedByWorkspaceId[workspaceId] = false;
+    }),
 });
diff --git a/apps/web/lib/state/store.ts b/apps/web/lib/state/store.ts
index 45c17d5835..ef2a4f3c3d 100644
--- a/apps/web/lib/state/store.ts
+++ b/apps/web/lib/state/store.ts
@@ -176,6 +176,7 @@ export type AppState = {
   setRepositoryScripts: (repositoryId: string, scripts: RepositoryScript[]) => void;
   setRepositoryScriptsLoading: (repositoryId: string, loading: boolean) => void;
   clearRepositoryScripts: (repositoryId: string) => void;
+  invalidateRepositories: (workspaceId: string) => void;
   setSettingsData: (next: Partial<SettingsDataState>) => void;
   setEditors: (editors: EditorsState['items']) => void;
   setEditorsLoading: (loading: boolean) => void;
diff --git a/apps/web/lib/ws/handlers/tasks.ts b/apps/web/lib/ws/handlers/tasks.ts
index 4787eeb487..8d7b367e71 100644
--- a/apps/web/lib/ws/handlers/tasks.ts
+++ b/apps/web/lib/ws/handlers/tasks.ts
@@ -7,7 +7,7 @@ type KanbanTask = KanbanState['tasks'][number];
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function buildTaskFromPayload(payload: any, existing?: KanbanTask): KanbanTask {
-  return {
+  const task = {
     id: payload.task_id,
     workflowStepId: payload.workflow_step_id,
     title: payload.title,
@@ -20,6 +20,7 @@ function buildTaskFromPayload(payload: any, existing?: KanbanTask): KanbanTask {
     reviewStatus: payload.review_status ?? existing?.reviewStatus,
     updatedAt: payload.updated_at ?? existing?.updatedAt,
   };
+  return task;
 }
 
 function upsertTask(tasks: KanbanTask[], nextTask: KanbanTask): KanbanTask[] {