d1a05e5 fix(client): present Connecting instead of the picker while the initial navigation is pending · vev

M internal/app/broker_client_test.go +12 -5


@@ -737,11 +737,16 @@ func TestTerminalCompositionRefusedTargetOpensNothingAndKeepsThePicker(t *testin
737	737		t.Fatal("the refused target reported no failure")
738	738		}
739	739		require.Empty(t, run.service.openedRequests(), "a refused target never opens a stream")
	740	+	// The pending navigation presents Connecting, never the picker
	741	+	// first; the refusal then returns to the picker and never attaches.
	742	+	last := client.PresentConnecting
740	743		for {
741	744		select {
742	745		case state := <-run.states:
743		-	require.Equal(t, client.PresentPicker, state.Presentation, "a refusal keeps the picker presentation")
	746	+	require.NotEqual(t, client.PresentAttached, state.Presentation, "a refusal never attaches")
	747	+	last = state.Presentation
744	748		case <-time.After(100 * time.Millisecond):
	749	+	require.Equal(t, client.PresentPicker, last, "a refusal ends on the picker")
745	750		return
746	751		}
747	752		}

@@ -1009,11 +1014,13 @@ func TestTerminalCompositionExactAttachReportsMissingLocalInventory(t *testing.T
1009	1014		t.Fatal("the exact attach reported no failure")
1010	1015		}
1011	1016		// The refused navigation never writes a session frame and never attaches:
1012		-	// only the Picker presentation may be published, never a Connecting or
1013		-	// Attached session presentation.
1014		-	for _, status := range terminal.publishes() {
1015		-	require.Equal(t, ports.UIStatusPicker, status, "a refused navigation publishes only Picker")
	1017	+	// it presents Connecting while pending and ends on the picker.
	1018	+	publishes := terminal.publishes()
	1019	+	for _, status := range publishes {
	1020	+	require.NotEqual(t, ports.UIStatusAttached, status, "a refused navigation never attaches")
1016	1021		}
	1022	+	require.NotEmpty(t, publishes)
	1023	+	require.Equal(t, ports.UIStatusPicker, publishes[len(publishes)-1], "a refused navigation ends on the picker")
1017	1024		cancel()
1018	1025		require.NoError(t, ignoreContextCancellation(<-done))
1019	1026		}

 				t.Fatal("the refused target reported no failure")
 			}
 			require.Empty(t, run.service.openedRequests(), "a refused target never opens a stream")
+			// The pending navigation presents Connecting, never the picker
+			// first; the refusal then returns to the picker and never attaches.
+			last := client.PresentConnecting
 			for {
 				select {
 				case state := <-run.states:
-					require.Equal(t, client.PresentPicker, state.Presentation, "a refusal keeps the picker presentation")
+					require.NotEqual(t, client.PresentAttached, state.Presentation, "a refusal never attaches")
+					last = state.Presentation
 				case <-time.After(100 * time.Millisecond):
+					require.Equal(t, client.PresentPicker, last, "a refusal ends on the picker")
 					return
 				}
 			}
 		t.Fatal("the exact attach reported no failure")
 	}
 	// The refused navigation never writes a session frame and never attaches:
-	// only the Picker presentation may be published, never a Connecting or
+	// it presents Connecting while pending and ends on the picker.
-	// Attached session presentation.
+	publishes := terminal.publishes()
-	for _, status := range terminal.publishes() {
+	for _, status := range publishes {
-		require.Equal(t, ports.UIStatusPicker, status, "a refused navigation publishes only Picker")
+		require.NotEqual(t, ports.UIStatusAttached, status, "a refused navigation never attaches")
 	}
+	require.NotEmpty(t, publishes)
+	require.Equal(t, ports.UIStatusPicker, publishes[len(publishes)-1], "a refused navigation ends on the picker")
 	cancel()
 	require.NoError(t, ignoreContextCancellation(<-done))
 }

M internal/app/web_daemon_broker_test.go +11 -9


@@ -500,16 +500,17 @@ func TestWebGatewayTabsShareOneBrokerWithIndependentStreamsAndServices(t *testin
500	500		require.Equal(t, carriageAfterFirst, fixture.broker.physicalCount(),
501	501		"the second tab opened another daemonmux carriage instead of reusing the pooled one")
502	502
503		-	// The identical state machine: each browser run presents Picker, Connecting,
504		-	// and Attached exactly like every other frontend. Consult the durable
505		-	// observation barrier: the two Attached notifications above were consumed
506		-	// while synchronizing startup and must still count here.
	503	+	// The identical state machine: each browser run's initial creation presents
	504	+	// Connecting then Attached exactly like every other frontend, never a
	505	+	// picker flash first. Consult the durable observation barrier: the two
	506	+	// Attached notifications above were consumed while synchronizing startup
	507	+	// and must still count here.
507	508		require.Eventually(t, func() bool {
508	509		presentations := fixture.observedPresentations()
509		-	return presentations[client.PresentPicker] >= 2 &&
510		-	presentations[client.PresentConnecting] >= 2 &&
	510	+	return presentations[client.PresentConnecting] >= 2 &&
511	511		presentations[client.PresentAttached] >= 2
512		-	}, brokerTestWait, 5*time.Millisecond, "both browser runs must present picker, connecting, and attached; observed %v", fixture.observedPresentations())
	512	+	}, brokerTestWait, 5*time.Millisecond, "both browser runs must present connecting and attached; observed %v", fixture.observedPresentations())
	513	+	require.Zero(t, fixture.observedPresentations()[client.PresentPicker], "an initial creation never flashes the picker")
513	514
514	515		// Real content and real actions, and each tab renders only its own session.
515	516		first.submit(t, "PING-FIRST")

@@ -674,12 +675,13 @@ func TestWebGatewayTerminalIsNotDialedBeforeConnect(t *testing.T) {
674	675
675	676		fixture := startWebGatewayFixtureOver(t, offlineClientFixture{}, newProductionBrokerConnector)
676	677		tab := fixture.openTab(t)
677		-	fixture.awaitPresentation(t, client.PresentPicker)
	678	+	// The tab's initial creation is pending, so it presents Connecting.
	679	+	fixture.awaitPresentation(t, client.PresentConnecting)
678	680		// Construction performs no I/O: the gateway reaches the broker only through
679	681		// Connect, and an unreachable broker is an ordinary attempt failure.
680	682		require.Eventually(t, func() bool { return connects.Load() >= 1 }, brokerTestWait, 5*time.Millisecond,
681	683		"the gateway must reach the broker only through Connect")
682		-	// A broker that is never reachable keeps the tab usable in the picker.
	684	+	// A broker that is never reachable keeps the tab alive and repainting.
683	685		before := tab.frameCount()
684	686		tab.awaitMoreFrames(t, before+1)
685	687		select {

 	require.Equal(t, carriageAfterFirst, fixture.broker.physicalCount(),
 		"the second tab opened another daemonmux carriage instead of reusing the pooled one")
-	// The identical state machine: each browser run presents Picker, Connecting,
+	// The identical state machine: each browser run's initial creation presents
-	// and Attached exactly like every other frontend. Consult the durable
+	// Connecting then Attached exactly like every other frontend, never a
-	// observation barrier: the two Attached notifications above were consumed
+	// picker flash first. Consult the durable observation barrier: the two
-	// while synchronizing startup and must still count here.
+	// Attached notifications above were consumed while synchronizing startup
+	// and must still count here.
 	require.Eventually(t, func() bool {
 		presentations := fixture.observedPresentations()
-		return presentations[client.PresentPicker] >= 2 &&
+		return presentations[client.PresentConnecting] >= 2 &&
-			presentations[client.PresentConnecting] >= 2 &&
 			presentations[client.PresentAttached] >= 2
-	}, brokerTestWait, 5*time.Millisecond, "both browser runs must present picker, connecting, and attached; observed %v", fixture.observedPresentations())
+	}, brokerTestWait, 5*time.Millisecond, "both browser runs must present connecting and attached; observed %v", fixture.observedPresentations())
+	require.Zero(t, fixture.observedPresentations()[client.PresentPicker], "an initial creation never flashes the picker")
 	// Real content and real actions, and each tab renders only its own session.
 	first.submit(t, "PING-FIRST")
 	fixture := startWebGatewayFixtureOver(t, offlineClientFixture{}, newProductionBrokerConnector)
 	tab := fixture.openTab(t)
-	fixture.awaitPresentation(t, client.PresentPicker)
+	// The tab's initial creation is pending, so it presents Connecting.
+	fixture.awaitPresentation(t, client.PresentConnecting)
 	// Construction performs no I/O: the gateway reaches the broker only through
 	// Connect, and an unreachable broker is an ordinary attempt failure.
 	require.Eventually(t, func() bool { return connects.Load() >= 1 }, brokerTestWait, 5*time.Millisecond,
 		"the gateway must reach the broker only through Connect")
-	// A broker that is never reachable keeps the tab usable in the picker.
+	// A broker that is never reachable keeps the tab alive and repainting.
 	before := tab.frameCount()
 	tab.awaitMoreFrames(t, before+1)
 	select {

M internal/usecase/client/supervisor.go +34 -1


@@ -176,6 +176,9 @@ const (
176	176		supervisorAttachEnded
177	177		// supervisorNonRetryable is a failure that retrying can never fix.
178	178		supervisorNonRetryable
	179	+	// supervisorNavigationSettled ends a pending initial navigation's
	180	+	// Connecting presentation when no attachment took over the terminal.
	181	+	supervisorNavigationSettled
179	182		// supervisorTerminal ends the process: terminal EOF, process cancellation,
180	183		// or a terminal broker failure.
181	184		supervisorTerminal

@@ -189,6 +192,11 @@ const (
189	192		type supervisorEvent struct {
190	193		kind supervisorEventKind
191	194		err error
	195	+	// navigating marks a supervisorBeginAttempt made while an initial
	196	+	// navigation is still pending: the user asked for a session, not the
	197	+	// picker, so the attempt presents Connecting instead of flashing the
	198	+	// picker until the navigation settles.
	199	+	navigating bool
192	200		}
193	201
194	202		// reduceSupervisor is the pure connectivity/presentation reducer. It is

@@ -198,6 +206,9 @@ func reduceSupervisor(state State, event supervisorEvent) State {
198	206		switch event.kind {
199	207		case supervisorBeginAttempt:
200	208		state.Presentation = PresentPicker
	209	+	if event.navigating {
	210	+	state.Presentation = PresentConnecting
	211	+	}
201	212		state.Connectivity = ConnectivityConnectingBroker
202	213		state.Generation++
203	214		state.Err = nil

@@ -230,8 +241,17 @@ func reduceSupervisor(state State, event supervisorEvent) State {
230	241		state.Presentation = PresentPicker
231	242		state.Err = event.err
232	243		case supervisorNonRetryable:
	244	+	// The run stays on the picker with the visible error; a pending
	245	+	// initial navigation can no longer present Connecting.
	246	+	state.Presentation = PresentPicker
233	247		state.Connectivity = ConnectivityDisconnected
234	248		state.Err = event.err
	249	+	case supervisorNavigationSettled:
	250	+	// An initial navigation that ended without an attachment (a resolved
	251	+	// picker, or a loss before it could be taken) leaves Connecting.
	252	+	if state.Presentation == PresentConnecting {
	253	+	state.Presentation = PresentPicker
	254	+	}
235	255		case supervisorOverlayOpened:
236	256		// Only a committed attachment can host the overlay: a connecting
237	257		// foreground has not proven its first frame yet.

@@ -493,6 +513,18 @@ func NewSupervisor(cfg SupervisorConfig) (*Supervisor, error) {
493	513		return supervisor, nil
494	514		}
495	515
	516	+	// initialNavigationPending reports whether an initial navigation other than
	517	+	// the picker is still armed. A resolver may still resolve to the picker; the
	518	+	// navigation then settles back to it without an attachment.
	519	+	func (s *Supervisor) initialNavigationPending() bool {
	520	+	s.mu.Lock()
	521	+	defer s.mu.Unlock()
	522	+	if s.navigationConsumed {
	523	+	return false
	524	+	}
	525	+	return s.cfg.ResolveInitialNavigation != nil \|\| s.navigation.Kind != InitialNavigationPicker
	526	+	}
	527	+
496	528		// State returns the current immutable projection.
497	529		func (s *Supervisor) State() State {
498	530		s.mu.Lock()

@@ -551,7 +583,7 @@ func (s *Supervisor) Run(ctx context.Context) (retErr error) {
551	583		// The generation is claimed before the connector runs, so the attempt is
552	584		// always attributable to the state that started it and a completion can be
553	585		// matched against the generation that produced it.
554		-	s.transition(supervisorEvent{kind: supervisorBeginAttempt})
	586	+	s.transition(supervisorEvent{kind: supervisorBeginAttempt, navigating: s.initialNavigationPending()})
555	587		generation := s.State().Generation
556	588		attemptCtx, cancelAttempt := context.WithCancel(ctx)
557	589		outcome := make(chan supervisorAttempt, 1)

@@ -626,6 +658,7 @@ func (s *Supervisor) Run(ctx context.Context) (retErr error) {
626	658		s.transition(supervisorEvent{kind: supervisorTerminal, err: termErr})
627	659		return termErr
628	660		}
	661	+	s.transition(supervisorEvent{kind: supervisorNavigationSettled})
629	662
630	663		// Ready phase: fold publications, admit committed attachments one at a
631	664		// time, and return to the picker after each. A committed attachment

 	supervisorAttachEnded
 	// supervisorNonRetryable is a failure that retrying can never fix.
 	supervisorNonRetryable
+	// supervisorNavigationSettled ends a pending initial navigation's
+	// Connecting presentation when no attachment took over the terminal.
+	supervisorNavigationSettled
 	// supervisorTerminal ends the process: terminal EOF, process cancellation,
 	// or a terminal broker failure.
 	supervisorTerminal
 type supervisorEvent struct {
 	kind supervisorEventKind
 	err  error
+	// navigating marks a supervisorBeginAttempt made while an initial
+	// navigation is still pending: the user asked for a session, not the
+	// picker, so the attempt presents Connecting instead of flashing the
+	// picker until the navigation settles.
+	navigating bool
 }
 // reduceSupervisor is the pure connectivity/presentation reducer. It is
 	switch event.kind {
 	case supervisorBeginAttempt:
 		state.Presentation = PresentPicker
+		if event.navigating {
+			state.Presentation = PresentConnecting
+		}
 		state.Connectivity = ConnectivityConnectingBroker
 		state.Generation++
 		state.Err = nil
 		state.Presentation = PresentPicker
 		state.Err = event.err
 	case supervisorNonRetryable:
+		// The run stays on the picker with the visible error; a pending
+		// initial navigation can no longer present Connecting.
+		state.Presentation = PresentPicker
 		state.Connectivity = ConnectivityDisconnected
 		state.Err = event.err
+	case supervisorNavigationSettled:
+		// An initial navigation that ended without an attachment (a resolved
+		// picker, or a loss before it could be taken) leaves Connecting.
+		if state.Presentation == PresentConnecting {
+			state.Presentation = PresentPicker
+		}
 	case supervisorOverlayOpened:
 		// Only a committed attachment can host the overlay: a connecting
 		// foreground has not proven its first frame yet.
 	return supervisor, nil
 }
+// initialNavigationPending reports whether an initial navigation other than
+// the picker is still armed. A resolver may still resolve to the picker; the
+// navigation then settles back to it without an attachment.
+func (s *Supervisor) initialNavigationPending() bool {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if s.navigationConsumed {
+		return false
+	}
+	return s.cfg.ResolveInitialNavigation != nil || s.navigation.Kind != InitialNavigationPicker
+}
 // State returns the current immutable projection.
 func (s *Supervisor) State() State {
 	s.mu.Lock()
 		// The generation is claimed before the connector runs, so the attempt is
 		// always attributable to the state that started it and a completion can be
 		// matched against the generation that produced it.
-		s.transition(supervisorEvent{kind: supervisorBeginAttempt})
+		s.transition(supervisorEvent{kind: supervisorBeginAttempt, navigating: s.initialNavigationPending()})
 		generation := s.State().Generation
 		attemptCtx, cancelAttempt := context.WithCancel(ctx)
 		outcome := make(chan supervisorAttempt, 1)
 			s.transition(supervisorEvent{kind: supervisorTerminal, err: termErr})
 			return termErr
 		}
+		s.transition(supervisorEvent{kind: supervisorNavigationSettled})
 		// Ready phase: fold publications, admit committed attachments one at a
 		// time, and return to the picker after each. A committed attachment

M internal/usecase/client/supervisor_test.go +30 -0


@@ -568,6 +568,36 @@ func TestSupervisorReducerTransitions(t *testing.T) {
568	568		event: supervisorEvent{kind: supervisorNonRetryable, err: incompatible},
569	569		want: State{Presentation: PresentPicker, Connectivity: ConnectivityDisconnected, Attempt: 1, Generation: 3, Err: incompatible},
570	570		},
	571	+	{
	572	+	name: "begin attempt with a pending navigation presents connecting, not the picker",
	573	+	state: picker,
	574	+	event: supervisorEvent{kind: supervisorBeginAttempt, navigating: true},
	575	+	want: State{Presentation: PresentConnecting, Connectivity: ConnectivityConnectingBroker, Generation: 1},
	576	+	},
	577	+	{
	578	+	name: "retry wait keeps a pending navigation connecting",
	579	+	state: State{Presentation: PresentConnecting, Connectivity: ConnectivityConnectingBroker, Generation: 2},
	580	+	event: supervisorEvent{kind: supervisorTransientFailure, err: transient},
	581	+	want: State{Presentation: PresentConnecting, Connectivity: ConnectivityRetryWait, Attempt: 1, Generation: 2, Err: transient},
	582	+	},
	583	+	{
	584	+	name: "non-retryable failure during a pending navigation falls back to the picker",
	585	+	state: State{Presentation: PresentConnecting, Connectivity: ConnectivityConnectingBroker, Generation: 3},
	586	+	event: supervisorEvent{kind: supervisorNonRetryable, err: incompatible},
	587	+	want: State{Presentation: PresentPicker, Connectivity: ConnectivityDisconnected, Generation: 3, Err: incompatible},
	588	+	},
	589	+	{
	590	+	name: "a navigation that settles without attaching returns to the picker",
	591	+	state: State{Presentation: PresentConnecting, Connectivity: ConnectivityReady, Generation: 4},
	592	+	event: supervisorEvent{kind: supervisorNavigationSettled},
	593	+	want: State{Presentation: PresentPicker, Connectivity: ConnectivityReady, Generation: 4},
	594	+	},
	595	+	{
	596	+	name: "navigation settled leaves an unrelated presentation alone",
	597	+	state: State{Presentation: PresentAttached, Connectivity: ConnectivityReady, Generation: 4},
	598	+	event: supervisorEvent{kind: supervisorNavigationSettled},
	599	+	want: State{Presentation: PresentAttached, Connectivity: ConnectivityReady, Generation: 4},
	600	+	},
571	601		{
572	602		name: "terminal failure terminates",
573	603		state: State{Presentation: PresentPicker, Connectivity: ConnectivityReady, Generation: 7},


@@ -568,6 +568,36 @@ func TestSupervisorReducerTransitions(t *testing.T) {
568	event: supervisorEvent{kind: supervisorNonRetryable, err: incompatible},	568		event: supervisorEvent{kind: supervisorNonRetryable, err: incompatible},
569	want: State{Presentation: PresentPicker, Connectivity: ConnectivityDisconnected, Attempt: 1, Generation: 3, Err: incompatible},	569		want: State{Presentation: PresentPicker, Connectivity: ConnectivityDisconnected, Attempt: 1, Generation: 3, Err: incompatible},
570	},	570		},
		571	+	{
		572	+	name: "begin attempt with a pending navigation presents connecting, not the picker",
		573	+	state: picker,
		574	+	event: supervisorEvent{kind: supervisorBeginAttempt, navigating: true},
		575	+	want: State{Presentation: PresentConnecting, Connectivity: ConnectivityConnectingBroker, Generation: 1},
		576	+	},
		577	+	{
		578	+	name: "retry wait keeps a pending navigation connecting",
		579	+	state: State{Presentation: PresentConnecting, Connectivity: ConnectivityConnectingBroker, Generation: 2},
		580	+	event: supervisorEvent{kind: supervisorTransientFailure, err: transient},
		581	+	want: State{Presentation: PresentConnecting, Connectivity: ConnectivityRetryWait, Attempt: 1, Generation: 2, Err: transient},
		582	+	},
		583	+	{
		584	+	name: "non-retryable failure during a pending navigation falls back to the picker",
		585	+	state: State{Presentation: PresentConnecting, Connectivity: ConnectivityConnectingBroker, Generation: 3},
		586	+	event: supervisorEvent{kind: supervisorNonRetryable, err: incompatible},
		587	+	want: State{Presentation: PresentPicker, Connectivity: ConnectivityDisconnected, Generation: 3, Err: incompatible},
		588	+	},
		589	+	{
		590	+	name: "a navigation that settles without attaching returns to the picker",
		591	+	state: State{Presentation: PresentConnecting, Connectivity: ConnectivityReady, Generation: 4},
		592	+	event: supervisorEvent{kind: supervisorNavigationSettled},
		593	+	want: State{Presentation: PresentPicker, Connectivity: ConnectivityReady, Generation: 4},
		594	+	},
		595	+	{
		596	+	name: "navigation settled leaves an unrelated presentation alone",
		597	+	state: State{Presentation: PresentAttached, Connectivity: ConnectivityReady, Generation: 4},
		598	+	event: supervisorEvent{kind: supervisorNavigationSettled},
		599	+	want: State{Presentation: PresentAttached, Connectivity: ConnectivityReady, Generation: 4},
		600	+	},
571	{	601		{
572	name: "terminal failure terminates",	602		name: "terminal failure terminates",
573	state: State{Presentation: PresentPicker, Connectivity: ConnectivityReady, Generation: 7},	603		state: State{Presentation: PresentPicker, Connectivity: ConnectivityReady, Generation: 7},