feat: integrate WebSocket for real-time progress in Conductor

- Add SetLiveClient() to Conductor for WebSocket reporting
- Add reportError() and reportComplete() helper methods
- Update reportProgress() to send via both HTTP and WebSocket
- Add NewAutonomousExecutorWithLive() for Live Dashboard integration
- Update autonomous executor to support Live client
- Update callers to use new function signature

Author: Test

cmd/gptcode/do.go

@@ -349,7 +349,7 @@ func runDoExecution(task string, verbose bool, supervised bool, setup *config.Se
 			language = "go" // default
 		}
 		// Use queryProvider for analyzer/classifier with selected backend
-		executor := modes.NewAutonomousExecutorWithBackend(queryProvider, cwd, queryModel, language, backendName)
+		executor := modes.NewAutonomousExecutorWithLive(queryProvider, cwd, queryModel, language, nil, nil, backendName)
 		return executor.Execute(context.Background(), task)
 	}
 

cmd/gptcode/issue.go

@@ -205,7 +205,7 @@ Examples:
 					language = "go"
 				}
 			}
-			exec := modes.NewAutonomousExecutorWithBackend(provider, workDir, queryModel, language, backendName)
+			exec := modes.NewAutonomousExecutorWithLive(provider, workDir, queryModel, language, nil, nil, backendName)
 			if err := exec.Execute(context.Background(), task); err != nil {
 				return fmt.Errorf("autonomous implementation failed: %w", err)
 			}
@@ -706,7 +706,7 @@ Comment: %s
 Please read the file, understand the context, and implement the requested change.`,
 				comment.Path, comment.Line, comment.Body)
 
-			exec := modes.NewAutonomousExecutorWithBackend(provider, workDir, queryModel, language, backendName)
+			exec := modes.NewAutonomousExecutorWithLive(provider, workDir, queryModel, language, nil, nil, backendName)
 			if err := exec.Execute(context.Background(), task); err != nil {
 				fmt.Printf("⚠️  Failed to address comment: %v\n", err)
 				continue

internal/maestro/conductor.go

@@ -31,6 +31,7 @@ type Conductor struct {
 	Observer         *observability.AgentObserver // For tracking and summary
 	loopDetector     *llm.LoopDetector            // Centralized Claude Code-style loop detection
 	liveReportConfig *live.ReportConfig           // For Live Dashboard HTTP reporting
+	liveClient       *live.Client                 // For Live Dashboard WebSocket reporting
 	progressCallback ProgressCallback             // For real-time progress updates
 }
 
@@ -66,21 +67,81 @@ func (c *Conductor) SetLiveReportConfig(reportConfig *live.ReportConfig) {
 	c.liveReportConfig = reportConfig
 }
 
+// SetLiveClient sets the Live Dashboard WebSocket client for real-time updates
+func (c *Conductor) SetLiveClient(client *live.Client) {
+	c.liveClient = client
+}
+
 // SetProgressCallback sets the callback for real-time progress updates
 func (c *Conductor) SetProgressCallback(callback ProgressCallback) {
 	c.progressCallback = callback
 }
 
-// reportProgress sends progress to Live Dashboard and calls progress callback
+// reportProgress sends progress to Live Dashboard via HTTP and WebSocket, and calls progress callback
 func (c *Conductor) reportProgress(phase string, details string) {
+	msg := phase + ": " + details
+
+	// Send via HTTP API (backup/reliability)
 	if c.liveReportConfig != nil {
-		c.liveReportConfig.Step(phase+": "+details, "step")
+		c.liveReportConfig.Step(msg, "step")
 	}
+
+	// Send via WebSocket (real-time)
+	if c.liveClient != nil {
+		c.liveClient.SendExecutionStep(phase, details, map[string]interface{}{
+			"phase":   phase,
+			"details": details,
+		})
+	}
+
+	// Call progress callback
 	if c.progressCallback != nil {
 		c.progressCallback(phase, details)
 	}
 }
 
+// reportError sends error to Live Dashboard
+func (c *Conductor) reportError(phase string, errMsg string) {
+	// Send via HTTP API
+	if c.liveReportConfig != nil {
+		c.liveReportConfig.Step(phase+": ERROR - "+errMsg, "error")
+	}
+
+	// Send via WebSocket
+	if c.liveClient != nil {
+		c.liveClient.SendExecutionStep("error", errMsg, map[string]interface{}{
+			"phase": phase,
+			"error": errMsg,
+		})
+	}
+}
+
+// reportComplete sends completion to Live Dashboard
+func (c *Conductor) reportComplete(success bool, summary string) {
+	stepType := "complete"
+	if !success {
+		stepType = "failed"
+	}
+
+	// Send via HTTP API
+	if c.liveReportConfig != nil {
+		if success {
+			c.liveReportConfig.Step("Completed: "+summary, "complete")
+		} else {
+			c.liveReportConfig.Step("Failed: "+summary, "error")
+		}
+		c.liveReportConfig.Disconnect()
+	}
+
+	// Send via WebSocket
+	if c.liveClient != nil {
+		c.liveClient.SendExecutionStep(stepType, summary, map[string]interface{}{
+			"success": success,
+			"summary": summary,
+		})
+	}
+}
+
 // ExecuteTask orchestrates the execution of a task
 func (c *Conductor) ExecuteTask(ctx context.Context, task string, complexity string) error {
 	if os.Getenv("GPTCODE_DEBUG") == "1" {

internal/modes/autonomous.go

@@ -8,31 +8,32 @@ import (
 	"gptcode/internal/autonomous"
 	"gptcode/internal/config"
 	"gptcode/internal/events"
+	"gptcode/internal/live"
 	"gptcode/internal/llm"
 	"gptcode/internal/maestro"
 )
 
 // AutonomousExecutor wraps autonomous execution for use across modes
 type AutonomousExecutor struct {
-	events   *events.Emitter
-	provider llm.Provider
-	cwd      string
-	model    string
-	executor *autonomous.Executor
+	events    *events.Emitter
+	provider  llm.Provider
+	cwd       string
+	model     string
+	executor  *autonomous.Executor
+	conductor *maestro.Conductor
 }
 
-// NewAutonomousExecutor creates a new autonomous executor
+// NewAutonomousExecutor creates a new autonomous executor (no Live integration)
 func NewAutonomousExecutor(provider llm.Provider, cwd string, model string, language string) *AutonomousExecutor {
-	return NewAutonomousExecutorWithBackend(provider, cwd, model, language, "")
+	return NewAutonomousExecutorWithLive(provider, cwd, model, language, nil, nil, "")
 }
 
-// NewAutonomousExecutorWithBackend creates executor with specific backend override
-func NewAutonomousExecutorWithBackend(provider llm.Provider, cwd string, model string, language string, backendName string) *AutonomousExecutor {
+// NewAutonomousExecutorWithLive creates executor with Live Dashboard integration
+func NewAutonomousExecutorWithLive(provider llm.Provider, cwd string, model string, language string, liveClient *live.Client, liveConfig *live.ReportConfig, backendName string) *AutonomousExecutor {
 	// Load setup
 	setup, err := config.LoadSetup()
 	if err != nil {
 		fmt.Printf("[WARN] Failed to load setup: %v, using defaults\n", err)
-		// Create minimal setup
 		setup = &config.Setup{
 			Backend: make(map[string]config.BackendConfig),
 		}
@@ -53,18 +54,27 @@ func NewAutonomousExecutorWithBackend(provider llm.Provider, cwd string, model s
 	// Create Maestro
 	conductor := maestro.NewConductor(selector, setup, cwd, language)
 
+	// Set up Live Dashboard integration
+	if liveClient != nil {
+		conductor.SetLiveClient(liveClient)
+	}
+	if liveConfig != nil {
+		conductor.SetLiveReportConfig(liveConfig)
+	}
+
 	// Create autonomous components
 	classifier := agents.NewClassifier(provider, model)
 	analyzer := autonomous.NewTaskAnalyzer(classifier, provider, cwd, model)
 
 	executor := autonomous.NewExecutor(analyzer, conductor, cwd)
 
 	return &AutonomousExecutor{
-		events:   events.NewEmitter(nil),
-		provider: provider,
-		cwd:      cwd,
-		model:    model,
-		executor: executor,
+		events:    events.NewEmitter(nil),
+		provider:  provider,
+		cwd:       cwd,
+		model:     model,
+		executor:  executor,
+		conductor: conductor,
 	}
 }