@@ -197,6 +197,7 @@ type cursorEvent struct {
 	Type      string          `json:"type"`    // system|user|assistant|thinking|tool_call|result
 	Subtype   string          `json:"subtype"` // init | delta | started | completed | success | ...
 	SessionID string          `json:"session_id"`
+	Model     string          `json:"model"`   // on system/init
 	Text      string          `json:"text"`    // on thinking/delta
 	Message   *cursorMessage  `json:"message"` // on assistant/user
 	ToolCall  *cursorToolCall `json:"tool_call"`
@@ -292,6 +293,11 @@ func (a *cursorAgent) parseStream(r io.Reader, onEvent func(StreamEvent)) Diagno
 			sessionID = e.SessionID
 		}
 		switch e.Type {
+		case "system":
+			// Cursor's init names the model but not its MCP servers or tools.
+			if e.Subtype == "init" {
+				onEvent(StreamEvent{Type: "phase", Phase: "ready", Model: e.Model})
+			}
 		case "thinking":
 			if e.Subtype == "delta" && e.Text != "" {
 				onEvent(StreamEvent{Type: "thinking", Token: e.Text})
 
@@ -96,10 +96,14 @@ func TestCursorParseStream_FormatPin(t *testing.T) {
 
 	var running, done bool
 	var doneIsError *bool
-	var thinking, doneResult, doneEvidenceRef, runningSummary string
+	var thinking, doneResult, doneEvidenceRef, runningSummary, readyModel string
 	agent := &cursorAgent{bin: "cursor-agent"}
 	diag := agent.parseStream(strings.NewReader(stream), func(ev StreamEvent) {
 		switch ev.Type {
+		case "phase":
+			if ev.Phase == "ready" {
+				readyModel = ev.Model
+			}
 		case "thinking":
 			thinking += ev.Token
 		case "step":
@@ -146,6 +150,9 @@ func TestCursorParseStream_FormatPin(t *testing.T) {
 	if diag.SessionID != "sess-abc" {
 		t.Errorf("session id (system/init) not captured: %q", diag.SessionID)
 	}
+	if readyModel != "GPT-5.5" {
+		t.Errorf("ready phase model (system/init) = %q, want GPT-5.5", readyModel)
+	}
 }
 
 func TestCursorParseStreamPreservesUncappedProducerResultForValidation(t *testing.T) {
 
@@ -249,8 +249,13 @@ type Diagnosis struct {
 // "turn" marks the start of a new turn (carries Question/Apply) so a connecting
 // or reconnecting client can reconstruct turn boundaries from the event log.
 type StreamEvent struct {
-	Type              string               `json:"type"` // "turn"|"phase"|"step"|"thinking"|"done"|"error"|"closed"
-	Phase             string               `json:"phase,omitempty"`
+	Type  string `json:"type"`            // "turn"|"phase"|"step"|"thinking"|"done"|"error"|"closed"
+	Phase string `json:"phase,omitempty"` // "investigating"|"connected"|"ready"
+	// Startup facts reported by the agent CLI on the "ready" phase: the model it
+	// resolved, how many Radar tools it registered, and each MCP server's status.
+	Model             string               `json:"model,omitempty"`
+	ToolCount         *int                 `json:"toolCount,omitempty"`
+	MCPServers        []MCPServerStatus    `json:"mcpServers,omitempty"`
 	Step              *StepInfo            `json:"step,omitempty"`
 	Token             string               `json:"token,omitempty"`
 	Diag              *Diagnosis           `json:"diagnosis,omitempty"`
@@ -277,6 +282,13 @@ const (
 	ApplyMutationUnknown   ApplyMutationOutcome = "unknown"
 )
 
+// MCPServerStatus is one MCP server's connection state as the agent CLI
+// reported it at startup. Only "connected" means the server's tools are usable.
+type MCPServerStatus struct {
+	Name   string `json:"name"`
+	Status string `json:"status"`
+}
+
 // StepInfo describes one tool invocation (running → done).
 type StepInfo struct {
 	ID      string `json:"id"`
@@ -609,19 +621,54 @@ func (d *Diagnoser) DiagnoseStream(ctx context.Context, req Request, onEvent fun
 		return Diagnosis{}, fmt.Errorf("ai: start %s: %w", agent.Name(), err)
 	}
 
-	onEvent(StreamEvent{Type: "phase", Phase: "investigating"})
+	// The handshake watcher and the stream parser both report to the caller;
+	// serialize them so callback consumers never see interleaved events.
+	var emitMu sync.Mutex
+	emit := func(event StreamEvent) {
+		emitMu.Lock()
+		defer emitMu.Unlock()
+		onEvent(event)
+	}
+	emit(StreamEvent{Type: "phase", Phase: "investigating"})
 	validator := investigationEvidenceValidator{
 		registry: d.evidenceRefs,
 		scope:    evidenceScope,
 		claimed:  make(map[string]struct{}),
 	}
 	streamEvent := func(event StreamEvent) {
-		onEvent(validator.validate(event))
+		emit(validator.validate(event))
+	}
+	streamDone := make(chan struct{})
+	var handshake sync.WaitGroup
+	if evidenceLease != nil {
+		// The private mount marks the scope connected on the agent's MCP
+		// handshake, which happens before its first message. Report it once.
+		handshake.Add(1)
+		go func() {
+			defer handshake.Done()
+			connected := evidenceLease.Connected()
+			select {
+			case <-connected:
+			case <-streamDone:
+				// Both may be ready when a short turn ends right after its
+				// handshake; select picks arbitrarily, so re-check before giving up.
+				select {
+				case <-connected:
+				default:
+					return
+				}
+			}
+			emit(StreamEvent{Type: "phase", Phase: "connected"})
+		}()
 	}
 	diag := agent.parseStream(stdout, streamEvent)
 	diag.evidenceScope = evidenceScope
 
 	waitErr := cmd.Wait()
+	// The watcher outlives stdout so a handshake that lands between EOF and
+	// process exit is still reported, and always before this method returns.
+	close(streamDone)
+	handshake.Wait()
 	if evidenceLease != nil {
 		// Closing before the diagnosis leaves this method prevents any late private
 		// MCP call from minting evidence for a completed turn. The deferred close
@@ -944,6 +991,26 @@ type cliEvent struct {
 	TotalCostUSD *float64 `json:"total_cost_usd"`
 	NumTurns     int      `json:"num_turns"`
 	SessionID    string   `json:"session_id"`
+	// system/init only.
+	Model      string            `json:"model"`
+	Tools      []string          `json:"tools"`
+	MCPServers []MCPServerStatus `json:"mcp_servers"`
+}
+
+// agentReadyEvent reports the CLI's init message as a startup phase. Radar
+// tools are counted by their MCP prefix so the count reflects what the model can
+// actually call, not what Radar offered.
+func agentReadyEvent(model string, tools []string, servers []MCPServerStatus) StreamEvent {
+	count := 0
+	for _, tool := range tools {
+		if strings.HasPrefix(tool, "mcp__radar__") {
+			count++
+		}
+	}
+	return StreamEvent{
+		Type: "phase", Phase: "ready",
+		Model: model, ToolCount: &count, MCPServers: servers,
+	}
 }
 
 func parseStream(r io.Reader, onEvent func(StreamEvent)) Diagnosis {
@@ -982,6 +1049,10 @@ func parseStream(r io.Reader, onEvent func(StreamEvent)) Diagnosis {
 			continue
 		}
 		switch ev.Type {
+		case "system":
+			if ev.Subtype == "init" {
+				onEvent(agentReadyEvent(ev.Model, ev.Tools, ev.MCPServers))
+			}
 		case "assistant":
 			if ev.Message == nil {
 				continue
 
@@ -9,8 +9,11 @@ import (
 	"net/url"
 	"os"
 	"os/exec"
+	"path/filepath"
 	"strings"
+	"sync"
 	"testing"
+	"time"
 
 	"github.com/skyhook-io/radar/internal/investigationrefs"
 )
@@ -922,3 +925,186 @@ func TestDiagnoseStream_ProcessAndStreamErrors(t *testing.T) {
 		t.Errorf("structured conclusion not preserved: %q", diag.RootCause)
 	}
 }
+
+// TestParseStream_InitReportsAgentReady pins the Claude Code system/init line:
+// the resolved model, the Radar tool count by MCP prefix, and every MCP
+// server's status, including a failed one the UI must surface as a warning.
+func TestParseStream_InitReportsAgentReady(t *testing.T) {
+	stream := strings.Join([]string{
+		`{"type":"system","subtype":"hook_started","hook_name":"SessionStart:startup","session_id":"s1"}`,
+		`{"type":"system","subtype":"init","session_id":"s1","tools":["Bash","mcp__radar__diagnose","mcp__radar__get_resource","mcp__other__ping"],"mcp_servers":[{"name":"radar","status":"connected"},{"name":"other","status":"failed"}],"model":"claude-opus-5[1m]"}`,
+		`{"type":"result","result":"done","num_turns":1}`,
+	}, "\n")
+	var ready []StreamEvent
+	parseStream(strings.NewReader(stream), func(ev StreamEvent) {
+		if ev.Type == "phase" {
+			ready = append(ready, ev)
+		}
+	})
+	if len(ready) != 1 || ready[0].Phase != "ready" {
+		t.Fatalf("phase events = %+v, want exactly one ready phase", ready)
+	}
+	got := ready[0]
+	if got.Model != "claude-opus-5[1m]" {
+		t.Errorf("model = %q", got.Model)
+	}
+	if got.ToolCount == nil || *got.ToolCount != 2 {
+		t.Errorf("radar tool count = %v, want 2", got.ToolCount)
+	}
+	want := []MCPServerStatus{{Name: "radar", Status: "connected"}, {Name: "other", Status: "failed"}}
+	if len(got.MCPServers) != len(want) {
+		t.Fatalf("mcp servers = %+v, want %+v", got.MCPServers, want)
+	}
+	for i := range want {
+		if got.MCPServers[i] != want[i] {
+			t.Errorf("mcp server %d = %+v, want %+v", i, got.MCPServers[i], want[i])
+		}
+	}
+	raw, err := json.Marshal(got)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, field := range []string{`"toolCount":2`, `"mcpServers":[`, `"model":"claude-opus-5[1m]"`} {
+		if !strings.Contains(string(raw), field) {
+			t.Errorf("serialized ready phase %s lacks %s", raw, field)
+		}
+	}
+	zero := agentReadyEvent("m", nil, nil)
+	if raw, _ := json.Marshal(zero); !strings.Contains(string(raw), `"toolCount":0`) {
+		t.Errorf("a zero Radar tool count must serialize, got %s", raw)
+	}
+}
+
+// TestDiagnoseStreamReportsHandshakeOnce pins the agent-agnostic "connected"
+// phase: the private mount's handshake produces exactly one event per turn, no
+// matter how many times the scope is marked, and it lands before the stream ends.
+func TestDiagnoseStreamReportsHandshakeOnce(t *testing.T) {
+	dir := t.TempDir()
+	flag := filepath.Join(dir, "handshake-observed")
+	bin := filepath.Join(dir, "claude")
+	resultLine := `{"type":"result","result":"` + "```json\\n{\\\"healthy\\\":true}\\n```" + `","num_turns":1}`
+	script := "#!/bin/sh\nwhile [ ! -f '" + flag + "' ]; do sleep 0.02; done\n" +
+		"printf '%s\\n' '" + resultLine + "'\n"
+	if err := os.WriteFile(bin, []byte(script), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	refs := investigationrefs.NewRegistry()
+	d, err := New(bin, refs)
+	if err != nil {
+		t.Fatal(err)
+	}
+	scope := strings.Repeat("d", 26)
+	started := make(chan struct{})
+	var mu sync.Mutex
+	var phases []string
+	type outcome struct {
+		diag Diagnosis
+		err  error
+	}
+	finished := make(chan outcome, 1)
+	go func() {
+		diag, err := d.DiagnoseStream(context.Background(), Request{
+			Kind: "Pod", Namespace: "ns", Name: "p", MCPPort: 1, EvidenceScope: scope,
+		}, func(ev StreamEvent) {
+			if ev.Type != "phase" {
+				return
+			}
+			mu.Lock()
+			phases = append(phases, ev.Phase)
+			mu.Unlock()
+			if ev.Phase == "investigating" {
+				close(started)
+			}
+		})
+		finished <- outcome{diag, err}
+	}()
+	select {
+	case <-started:
+	case <-time.After(10 * time.Second):
+		t.Fatal("agent never started")
+	}
+	if !refs.MarkConnected(scope) || !refs.MarkConnected(scope) {
+		t.Fatal("live turn scope rejected its handshake")
+	}
+	deadline := time.Now().Add(5 * time.Second)
+	for {
+		mu.Lock()
+		seen := len(phases) >= 2
+		mu.Unlock()
+		if seen || time.Now().After(deadline) {
+			break
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+	if err := os.WriteFile(flag, nil, 0o644); err != nil {
+		t.Fatal(err)
+	}
+	var result outcome
+	select {
+	case result = <-finished:
+	case <-time.After(10 * time.Second):
+		t.Fatal("DiagnoseStream did not finish")
+	}
+	if result.err != nil || !result.diag.Healthy {
+		t.Fatalf("diagnosis = %+v, err = %v", result.diag, result.err)
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	if strings.Join(phases, ",") != "investigating,connected" {
+		t.Fatalf("phases = %v, want investigating then exactly one connected", phases)
+	}
+}
+
+// handshakeAgent completes the private-mount handshake from inside command()
+// and exits at once, so the stream can end in the same instant the scope is
+// marked connected.
+type handshakeAgent struct {
+	refs *investigationrefs.Registry
+}
+
+func (*handshakeAgent) Name() string      { return "claude" }
+func (*handshakeAgent) Path() string      { return "printf" }
+func (*handshakeAgent) SigninCmd() string { return "claude auth login" }
+func (a *handshakeAgent) parseStream(r io.Reader, onEvent func(StreamEvent)) Diagnosis {
+	return parseStream(r, onEvent)
+}
+func (a *handshakeAgent) command(ctx context.Context, spec turnSpec) (*exec.Cmd, func(), error) {
+	u, err := url.Parse(spec.mcpURL)
+	if err != nil {
+		return nil, func() {}, err
+	}
+	if !a.refs.MarkConnected(u.Query().Get("scope")) {
+		return nil, func() {}, fmt.Errorf("test agent could not mark the scope connected")
+	}
+	stream := `{"type":"result","result":"` + "```json\\n{\\\"healthy\\\":true}\\n```" + `","num_turns":1}`
+	return exec.CommandContext(ctx, "printf", "%s\n", stream), func() {}, nil
+}
+
+// TestDiagnoseStreamReportsHandshakeOnShortTurn pins that a handshake which
+// lands as the stream ends is still reported exactly once, before the turn
+// returns, rather than lost to a select that happens to observe the end first.
+func TestDiagnoseStreamReportsHandshakeOnShortTurn(t *testing.T) {
+	refs := investigationrefs.NewRegistry()
+	diagnoser := &Diagnoser{
+		agents:       map[string]Agent{"claude": &handshakeAgent{refs: refs}},
+		defName:      "claude",
+		evidenceRefs: refs,
+	}
+	for i := 0; i < 20; i++ {
+		var phases []string
+		diag, err := diagnoser.DiagnoseStream(context.Background(), Request{
+			Kind: "Pod", Namespace: "ns", Name: "p", MCPPort: 1,
+			EvidenceScope: strings.Repeat("e", 26),
+		}, func(ev StreamEvent) {
+			if ev.Type == "phase" {
+				phases = append(phases, ev.Phase)
+			}
+		})
+		if err != nil || !diag.Healthy {
+			t.Fatalf("diagnosis = %+v, err = %v", diag, err)
+		}
+		if strings.Join(phases, ",") != "investigating,connected" {
+			t.Fatalf("run %d phases = %v, want investigating then exactly one connected", i, phases)
+		}
+	}
+}