feat: make orchestration 2.0 the default execution path

Make Orch 2.0 the default for both UltraPlan and TripleShot sessions:

- UltraPlan: flip UsePipeline default to true, routing execution through
  the pipeline backend instead of legacy ExecutionOrchestrator
- TripleShot: wire teamwire.TeamCoordinator as default, replacing file
  polling with callback-driven execution via buffered channel bridge
- Adversarial mode and session restoration stay on legacy path

Add tripleshot.Runner interface for dual-coordinator coexistence,
NewTripleShotAdapters() factory to break import cycles, and
pipeline_wire.go wiring files for lazy PipelineRunner creation.

Fix channel safety issues: nil-guard close to prevent double-close
panic, stop re-subscribing after completion to prevent goroutine leak,
close old channel on overwrite. Log SaveSession() errors instead of
discarding. Improve pipeline factory error messages for users.

Author: Iron-Ham

CHANGELOG.md

@@ -9,12 +9,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- **Orchestration 2.0 Default Execution** - Made Orch 2.0 the default for both UltraPlan and TripleShot. UltraPlan flips `UsePipeline` default to `true`. TripleShot uses `teamwire.TeamCoordinator` with callback-driven execution (replacing file polling), falling back to legacy for adversarial mode or `tripleshot.use_legacy` config. Added `tripleshot.Runner` interface for dual-coordinator coexistence, channel bridge for teamwire callbacks into Bubble Tea, and `NewTripleShotAdapters()` factory to avoid import cycles.
+
+- **Pipeline Execution Path** - Wired the Orchestration 2.0 pipeline stack into `Coordinator.StartExecution()`. Added `ExecutionRunner` interface in `orchestrator` (implemented by `bridgewire.PipelineRunner`) with factory-based injection to avoid import cycles. When `UsePipeline` config is enabled, the Coordinator delegates execution to the pipeline backend instead of the legacy `ExecutionOrchestrator`. Subscribes to `pipeline.completed` events for synthesis/failure handling. Guards legacy-only methods (`RetryFailedTasks`, `RetriggerGroup`, `ResumeWithPartialWork`) when pipeline is active.
+
 - **Dynamic Team Sizing** - Connected the scaling feedback loop so bridges adjust concurrency based on workload and budget. Added `dynamicSemaphore` to the bridge for context-aware, resizable concurrency limiting. Added `SetMaxConcurrency`/`MaxConcurrency`/`ActiveInstances` to Bridge. Added `TeamScaledEvent` for TUI observability. Added `MinInstances`/`MaxInstances` to team Spec and `WithMinInstances`/`WithMaxInstances` coordination options. Decompose now populates scaling bounds from `DecomposeConfig`. `PipelineExecutor.wireScalingFeedback` connects scaling monitor decisions to bridge concurrency with budget-aware veto. (#646)
 
 - **Remaining E2E Test Scenarios** - Added 5 new E2E integration tests for the pipeline executor: dependency ordering (linear chain), dependency failure cascade, partial failure (mixed success/failure), budget exhaustion event, and context cancellation. Added `selectiveFactory` mock for per-task failure control and `waitForTeamPhase` helper. (#649)
 
 ### Fixed
 
+- **Teamwire Channel Safety** - Fixed potential panic from closing `teamwireEventCh` while callbacks may still write to it (nil-guard before close), goroutine leak from re-subscribing after triple-shot completion, and channel overwrite leak when starting multiple sessions. Surfaced session error details in `PhaseFailed` handler instead of generic "Triple-shot failed" message.
+
+- **Pipeline SaveSession Error Logging** - Replaced silent `_ = SaveSession()` calls in `onPipelineCompleted` and `Cancel()` with logged errors, preventing session state loss from going undetected. Improved pipeline factory error message for user-facing context.
+
 - **Failed-Dependency Cascade** - Teams blocked on a failed dependency now transition to `PhaseFailed` instead of staying blocked forever. The `Manager.onTeamCompleted` handler detects permanently blocked teams and cascades failure through multi-hop dependency chains (A fails → B fails → C fails). Uses a two-phase approach (collect state under lock, publish events outside) to avoid re-entrancy deadlock with the synchronous event bus. (#649)
 
 ### Changed

internal/cmd/session/pipeline_wire.go

@@ -0,0 +1,27 @@
+package session
+
+import (
+	"github.com/Iron-Ham/claudio/internal/logging"
+	"github.com/Iron-Ham/claudio/internal/orchestrator"
+	"github.com/Iron-Ham/claudio/internal/orchestrator/bridgewire"
+)
+
+// registerPipelineFactory registers a PipelineRunnerFactory on the given
+// Coordinator so that the Pipeline-based execution backend can be created
+// lazily when UsePipeline is enabled. See tui/pipeline_wire.go for the
+// equivalent TUI-side registration.
+func registerPipelineFactory(coordinator *orchestrator.Coordinator, orch *orchestrator.Orchestrator, logger *logging.Logger) {
+	coordinator.SetPipelineFactory(func(deps orchestrator.PipelineRunnerDeps) (orchestrator.ExecutionRunner, error) {
+		recorder := bridgewire.NewSessionRecorder(bridgewire.SessionRecorderDeps{})
+		return bridgewire.NewPipelineRunner(bridgewire.PipelineRunnerConfig{
+			Orch:        deps.Orch,
+			Session:     deps.Session,
+			Verifier:    deps.Verifier,
+			Plan:        deps.Plan,
+			Bus:         orch.EventBus(),
+			Logger:      logger,
+			Recorder:    recorder,
+			MaxParallel: deps.MaxParallel,
+		})
+	})
+}

internal/cmd/session/start.go

@@ -511,6 +511,9 @@ func resumeUltraplanSession(orch *orchestrator.Orchestrator, sess *orchestrator.
 	// Create coordinator from the loaded session state
 	coordinator := orchestrator.NewCoordinator(orch, sess, ultraSession, logger)
 
+	// Register pipeline factory for lazy PipelineRunner creation
+	registerPipelineFactory(coordinator, orch, logger)
+
 	// Resume based on current phase
 	switch ultraSession.Phase {
 	case orchestrator.PhasePlanning:

internal/config/config.go

@@ -226,6 +226,8 @@ type TripleshotConfig struct {
 	AutoApprove bool `mapstructure:"auto_approve"`
 	// Adversarial enables adversarial review mode where each implementer must pass review before completion (default: false)
 	Adversarial bool `mapstructure:"adversarial"`
+	// UseLegacy forces the legacy polling-based coordinator instead of team-based Orch 2.0 (default: false)
+	UseLegacy bool `mapstructure:"use_legacy"`
 }
 
 // AdversarialConfig controls adversarial review mode behavior.
@@ -471,6 +473,7 @@ func Default() *Config {
 		Tripleshot: TripleshotConfig{
 			AutoApprove: false,
 			Adversarial: false,
+			UseLegacy:   false,
 		},
 		Adversarial: AdversarialConfig{
 			MaxIterations:   10, // Reasonable default to prevent infinite loops
@@ -598,6 +601,7 @@ func SetDefaults() {
 	// Tripleshot defaults
 	viper.SetDefault("tripleshot.auto_approve", defaults.Tripleshot.AutoApprove)
 	viper.SetDefault("tripleshot.adversarial", defaults.Tripleshot.Adversarial)
+	viper.SetDefault("tripleshot.use_legacy", defaults.Tripleshot.UseLegacy)
 
 	// Adversarial defaults
 	viper.SetDefault("adversarial.max_iterations", defaults.Adversarial.MaxIterations)

internal/orchestrator/bridgewire/runner.go

@@ -0,0 +1,193 @@
+package bridgewire
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/Iron-Ham/claudio/internal/bridge"
+	"github.com/Iron-Ham/claudio/internal/event"
+	"github.com/Iron-Ham/claudio/internal/logging"
+	"github.com/Iron-Ham/claudio/internal/orchestrator"
+	"github.com/Iron-Ham/claudio/internal/pipeline"
+	"github.com/Iron-Ham/claudio/internal/ultraplan"
+)
+
+// PipelineRunnerConfig holds the dependencies for constructing a PipelineRunner.
+type PipelineRunnerConfig struct {
+	Orch     *orchestrator.Orchestrator
+	Session  *orchestrator.Session
+	Verifier orchestrator.Verifier
+	Plan     *orchestrator.PlanSpec // orchestrator's PlanSpec (converted internally)
+	Bus      *event.Bus
+	Logger   *logging.Logger
+	Recorder bridge.SessionRecorder
+	BaseDir  string // Base directory for pipeline state files (defaults to Session.BaseRepo)
+
+	MaxParallel int // from UltraPlanConfig.MaxParallel
+}
+
+// PipelineRunner implements orchestrator.ExecutionRunner using the
+// Pipeline-based execution backend (Orchestration 2.0).
+//
+// It encapsulates the full lifecycle: plan conversion, pipeline creation,
+// decomposition, and PipelineExecutor wiring.
+type PipelineRunner struct {
+	pipe *pipeline.Pipeline
+	exec *PipelineExecutor
+}
+
+// NewPipelineRunner creates a PipelineRunner from the given config.
+// It converts the orchestrator PlanSpec to ultraplan.PlanSpec, creates the
+// Pipeline, decomposes the plan into teams, and wires a PipelineExecutor.
+func NewPipelineRunner(cfg PipelineRunnerConfig) (*PipelineRunner, error) {
+	if cfg.Plan == nil {
+		return nil, fmt.Errorf("bridgewire: PipelineRunner requires a non-nil Plan")
+	}
+	if cfg.Bus == nil {
+		return nil, fmt.Errorf("bridgewire: PipelineRunner requires a non-nil Bus")
+	}
+	if cfg.Orch == nil {
+		return nil, fmt.Errorf("bridgewire: PipelineRunner requires a non-nil Orch")
+	}
+	if cfg.Session == nil {
+		return nil, fmt.Errorf("bridgewire: PipelineRunner requires a non-nil Session")
+	}
+
+	// Convert orchestrator.PlanSpec → ultraplan.PlanSpec
+	uplan := convertPlan(cfg.Plan)
+
+	// Use explicit BaseDir if provided, otherwise fall back to Session.BaseRepo
+	baseDir := cfg.BaseDir
+	if baseDir == "" {
+		baseDir = cfg.Session.BaseRepo
+	}
+
+	// Create the pipeline
+	pipe, err := pipeline.NewPipeline(pipeline.PipelineConfig{
+		Bus:     cfg.Bus,
+		BaseDir: baseDir,
+		Plan:    uplan,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("bridgewire: create pipeline: %w", err)
+	}
+
+	// Decompose the plan into execution teams only (no planning/review/consolidation
+	// phases — those are handled by the Coordinator's existing methods).
+	maxPar := cfg.MaxParallel
+	if maxPar < 1 {
+		maxPar = 3
+	}
+
+	_, err = pipe.Decompose(pipeline.DecomposeConfig{
+		DefaultTeamSize:  maxPar,
+		MinTeamInstances: 1,
+		MaxTeamInstances: maxPar,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("bridgewire: decompose plan: %w", err)
+	}
+
+	// Create the PipelineExecutor
+	logger := cfg.Logger
+	if logger == nil {
+		logger = logging.NopLogger()
+	}
+
+	exec, err := NewPipelineExecutorFromOrch(
+		cfg.Orch, cfg.Session, cfg.Verifier,
+		cfg.Bus, pipe, cfg.Recorder, logger,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("bridgewire: create executor: %w", err)
+	}
+
+	return &PipelineRunner{
+		pipe: pipe,
+		exec: exec,
+	}, nil
+}
+
+// Start begins execution: starts the executor (which subscribes to pipeline
+// phase events and creates bridges) then starts the pipeline itself.
+func (r *PipelineRunner) Start(ctx context.Context) error {
+	if err := r.exec.Start(ctx); err != nil {
+		return fmt.Errorf("bridgewire: start executor: %w", err)
+	}
+	if err := r.pipe.Start(ctx); err != nil {
+		r.exec.Stop()
+		return fmt.Errorf("bridgewire: start pipeline: %w", err)
+	}
+	return nil
+}
+
+// Stop tears down both the executor and pipeline.
+func (r *PipelineRunner) Stop() {
+	r.exec.Stop()
+	_ = r.pipe.Stop()
+}
+
+// convertPlan converts an orchestrator.PlanSpec to an ultraplan.PlanSpec.
+// The two types have identical shapes (by design) so this is a field-by-field copy.
+func convertPlan(src *orchestrator.PlanSpec) *ultraplan.PlanSpec {
+	tasks := make([]ultraplan.PlannedTask, len(src.Tasks))
+	for i, t := range src.Tasks {
+		var files []string
+		if len(t.Files) > 0 {
+			files = make([]string, len(t.Files))
+			copy(files, t.Files)
+		}
+		var deps []string
+		if len(t.DependsOn) > 0 {
+			deps = make([]string, len(t.DependsOn))
+			copy(deps, t.DependsOn)
+		}
+		tasks[i] = ultraplan.PlannedTask{
+			ID:            t.ID,
+			Title:         t.Title,
+			Description:   t.Description,
+			Files:         files,
+			DependsOn:     deps,
+			Priority:      t.Priority,
+			EstComplexity: ultraplan.TaskComplexity(t.EstComplexity),
+			IssueURL:      t.IssueURL,
+			NoCode:        t.NoCode,
+		}
+	}
+
+	depGraph := make(map[string][]string, len(src.DependencyGraph))
+	for k, v := range src.DependencyGraph {
+		cp := make([]string, len(v))
+		copy(cp, v)
+		depGraph[k] = cp
+	}
+
+	execOrder := make([][]string, len(src.ExecutionOrder))
+	for i, group := range src.ExecutionOrder {
+		execOrder[i] = make([]string, len(group))
+		copy(execOrder[i], group)
+	}
+
+	var insights []string
+	if len(src.Insights) > 0 {
+		insights = make([]string, len(src.Insights))
+		copy(insights, src.Insights)
+	}
+	var constraints []string
+	if len(src.Constraints) > 0 {
+		constraints = make([]string, len(src.Constraints))
+		copy(constraints, src.Constraints)
+	}
+
+	return &ultraplan.PlanSpec{
+		ID:              src.ID,
+		Objective:       src.Objective,
+		Summary:         src.Summary,
+		Tasks:           tasks,
+		DependencyGraph: depGraph,
+		ExecutionOrder:  execOrder,
+		Insights:        insights,
+		Constraints:     constraints,
+		CreatedAt:       src.CreatedAt,
+	}
+}