fix: share teamwire event channel across concurrent triple-shots (#668)

When starting a second triple-shot, the old event channel was closed
and replaced. The old listener's TeamwireChannelClosedMsg then nil'd
out m.teamwireEventCh, causing subsequent re-subscriptions to block
forever on a nil channel read. This left the second group visible but
empty — its instances appeared as top-level items.

Fix: reuse the existing event channel (all messages already carry a
GroupID for demux), only start a new listener when there isn't one,
and keep listening after completion when other coordinators are active.

Also adds listenTeamwireCmd() nil-guard helper used by all teamwire
handlers, preventing the nil-channel block-forever issue defensively.

Author: Iron-Ham

CHANGELOG.md

@@ -19,6 +19,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- **Multiple Triple-Shot Event Channel** - Fixed second triple-shot instances appearing outside their group. The teamwire event channel was replaced (old closed, new created) on each new triple-shot, causing the old listener's `TeamwireChannelClosedMsg` to nil out the new channel. Subsequent events blocked forever on a nil channel read. Now all coordinators share a single event channel (demuxed by GroupID), and `handleTeamwireCompleted` re-subscribes when the channel is still active.
+
 - **TripleShot Implementer Auto-Collapse and Judge Nesting** - Fixed two TUI visual regressions introduced when Orchestration 2.0 became the default tripleshot execution path: (1) implementer instances were not auto-collapsed when the judge started because `ImplementersGroupID` was never set, and (2) the judge instance was not nested within the tripleshot group. Ported the legacy coordinator's group restructuring logic to `teamwire.TeamCoordinator.reorganizeGroupForJudge()` and added judge-to-group registration in the TUI handler.
 
 - **TripleShot Combine Evaluation Parse Failure** - `FlexibleStringSlice` now handles LLM judge output that writes an array of objects (e.g., `[{"description":"...","source":"attempt_1"}]`) where flat strings were expected; also improved the judge prompt to show a populated `suggested_changes` example and explicitly require plain strings

internal/tui/tripleshot.go

@@ -351,11 +351,17 @@ func (m Model) initiateTeamwireTripleShot(
 	// Persist tripleshot session for potential restore
 	m.session.TripleShots = append(m.session.TripleShots, coordinator.Session())
 
-	// Create buffered channel for callback → Bubble Tea bridge
-	eventCh := make(chan tea.Msg, 16)
+	// Reuse the existing event channel if one is already active.
+	// Multiple triple-shot coordinators share a single channel, with each
+	// message carrying a GroupID for demultiplexing.
+	eventCh := m.teamwireEventCh
+	needsNewListener := eventCh == nil
+	if eventCh == nil {
+		eventCh = make(chan tea.Msg, 16)
+	}
 	groupID := group.ID
 
-	// Register callbacks that write to the event channel
+	// Register callbacks that write to the shared event channel
 	coordinator.SetCallbacks(&tripleshot.CoordinatorCallbacks{
 		OnPhaseChange: func(phase tripleshot.Phase) {
 			eventCh <- tuimsg.TeamwirePhaseChangedMsg{GroupID: groupID, Phase: phase}
@@ -381,19 +387,6 @@ func (m Model) initiateTeamwireTripleShot(
 		},
 	})
 
-	// Stop existing runners before closing their event channel. Their
-	// callbacks hold a reference to the old channel and would panic with
-	// "send on closed channel" if they fire after close. Stop() cancels
-	// contexts and waits for goroutines, ensuring no more callback writes.
-	if m.tripleShot != nil {
-		for id, runner := range m.tripleShot.Runners {
-			if runner != nil {
-				runner.Stop()
-			}
-			delete(m.tripleShot.Runners, id)
-		}
-	}
-
 	// Store coordinator in runners map BEFORE starting so event handlers
 	// can find it when callbacks fire during Start().
 	if m.tripleShot == nil {
@@ -407,11 +400,6 @@ func (m Model) initiateTeamwireTripleShot(
 	m.tripleShot.Runners[groupID] = coordinator
 	m.tripleShot.UseTeamwire = true
 
-	// Close the previous event channel to unblock the old ListenTeamwireEvents
-	// reader. Safe because we stopped all old runners above (no more writes).
-	if ch := m.teamwireEventCh; ch != nil {
-		close(ch)
-	}
 	m.teamwireEventCh = eventCh
 
 	numActive := len(m.tripleShot.Runners)
@@ -435,8 +423,14 @@ func (m Model) initiateTeamwireTripleShot(
 		return tuimsg.TeamwireStartResultMsg{GroupID: groupID}
 	}
 
-	// Listen for callback events and start the coordinator concurrently.
-	return m, tea.Batch(startCmd, tuimsg.ListenTeamwireEvents(eventCh))
+	// Start the coordinator. Only start a new event listener if one isn't
+	// already running — existing listeners re-subscribe after each message
+	// and share the channel with all coordinators.
+	cmds := []tea.Cmd{startCmd}
+	if needsNewListener {
+		cmds = append(cmds, tuimsg.ListenTeamwireEvents(eventCh))
+	}
+	return m, tea.Batch(cmds...)
 }
 
 // handleTeamwirePhaseChanged handles a phase change from the teamwire coordinator.
@@ -464,7 +458,7 @@ func (m *Model) handleTeamwirePhaseChanged(msg tuimsg.TeamwirePhaseChangedMsg) (
 		// OnComplete callback handles this
 	}
 
-	return m, tuimsg.ListenTeamwireEvents(m.teamwireEventCh)
+	return m, m.listenTeamwireCmd()
 }
 
 // handleTeamwireAttemptStarted handles an attempt start from the teamwire coordinator.
@@ -486,7 +480,7 @@ func (m *Model) handleTeamwireAttemptStarted(msg tuimsg.TeamwireAttemptStartedMs
 	}
 
 	m.infoMessage = fmt.Sprintf("Attempt %d started", msg.AttemptIndex+1)
-	return m, tuimsg.ListenTeamwireEvents(m.teamwireEventCh)
+	return m, m.listenTeamwireCmd()
 }
 
 // handleTeamwireAttemptCompleted handles an attempt completion from the teamwire coordinator.
@@ -499,7 +493,7 @@ func (m *Model) handleTeamwireAttemptCompleted(msg tuimsg.TeamwireAttemptComplet
 	}
 
 	m.infoMessage = fmt.Sprintf("Attempt %d completed", msg.AttemptIndex+1)
-	return m, tuimsg.ListenTeamwireEvents(m.teamwireEventCh)
+	return m, m.listenTeamwireCmd()
 }
 
 // handleTeamwireAttemptFailed handles an attempt failure from the teamwire coordinator.
@@ -513,7 +507,7 @@ func (m *Model) handleTeamwireAttemptFailed(msg tuimsg.TeamwireAttemptFailedMsg)
 	}
 
 	m.errorMessage = fmt.Sprintf("Attempt %d failed: %s", msg.AttemptIndex+1, msg.Reason)
-	return m, tuimsg.ListenTeamwireEvents(m.teamwireEventCh)
+	return m, m.listenTeamwireCmd()
 }
 
 // handleTeamwireJudgeStarted handles judge start from the teamwire coordinator.
@@ -555,7 +549,7 @@ func (m *Model) handleTeamwireJudgeStarted(msg tuimsg.TeamwireJudgeStartedMsg) (
 		}
 	}
 
-	return m, tuimsg.ListenTeamwireEvents(m.teamwireEventCh)
+	return m, m.listenTeamwireCmd()
 }
 
 // handleTeamwireCompleted handles completion of the teamwire triple-shot.
@@ -582,10 +576,22 @@ func (m *Model) handleTeamwireCompleted(msg tuimsg.TeamwireCompletedMsg) (tea.Mo
 		m.tripleShot.NeedsNotification = true
 	}
 
-	// Don't re-subscribe — the session is done. The channel will be closed
-	// during cleanup. Returning nil avoids a goroutine leak from a reader
-	// permanently blocked on a channel that will never receive another message.
-	return m, nil
+	// Keep listening if the shared channel is still active — other
+	// triple-shot coordinators may still be running and sending events.
+	// When no runners remain, cleanup will close the channel and the
+	// listener will receive TeamwireChannelClosedMsg.
+	return m, m.listenTeamwireCmd()
+}
+
+// listenTeamwireCmd returns a tea.Cmd that re-subscribes to the shared
+// teamwire event channel. Returns nil if the channel has been closed
+// (set to nil by handleTeamwireChannelClosed or cleanupTripleShot),
+// preventing a goroutine from blocking forever on a nil channel read.
+func (m *Model) listenTeamwireCmd() tea.Cmd {
+	if m.teamwireEventCh == nil {
+		return nil
+	}
+	return tuimsg.ListenTeamwireEvents(m.teamwireEventCh)
 }
 
 // handleTeamwireChannelClosed handles the teamwire event channel being closed.