feat(azure.ai.agents): add monitor --follow secondary after invoke --local success (P5.1 C4)

Fixes B7: `azd ai agent invoke --local` success previously emitted
only a single `azd deploy` suggestion. Per issue Azure#7975 lines 168-181,
the natural follow-up loop is "ship to Azure, then watch the live
logs" — surface both commands in one block:

  Next: azd deploy                       -- deploy the agent to Azure
        azd ai agent monitor --follow    -- view logs after deploying

Rationale: by the time `invoke --local` returns success, the user
has already provisioned (dependencies exist) and the agent itself
works. The next loop is the deploy + verify dance, so the live-log
feed is the right secondary.

Also updates the deploy command's description from the conversational
"the local invoke worked — ship it to Azure" to the spec-aligned
"deploy the agent to Azure" so the description column stays
functional rather than narrative.

Renderer fit: PrintNext (used by invoke.go) caps at 2 lines, which
exactly accommodates the new shape; no callsite change needed. The
existing remote-success path already returned 2 suggestions
(`show <agent>` + `monitor`), so this brings the local- and
remote-success paths into structural parity.

Scope: ~40 LoC + doc/test updates. Independent of C1-C3.

Out of scope (issue Azure#7975 lines 183-191 multi-agent variant):
The multi-agent local-invoke output uses an "After deploying:"
prose subsection with per-agent invoke commands. That requires
threading state into ResolveAfterInvoke (today's call site passes
state=nil — see invoke.go:222 doc) and either a new Suggestion
sub-type for the indented subsection or a layout change to
PrintNext. Deferred to a follow-up commit. The single-agent
project case — by far the common one — is fully covered by this
change.

Tests:
- `TestResolveAfterInvoke_Success` / "local success → deploy +
  monitor" updated to assert the 2-Suggestion shape, both command
  strings, both descriptions, and that neither is Trailing.

Source of truth: issue Azure#7975 lines 168-181, P5.1 commit plan C4.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Antriksh Jain

cli/azd/extensions/azure.ai.agents/internal/cmd/nextstep/resolver.go

@@ -220,7 +220,9 @@ type InvokeFailure struct {
 // ResolveAfterInvoke produces the Next: block for a completed invoke.
 //
 // Success paths:
-//   - InvokeLocal  → `azd deploy` (the natural next step is to ship)
+//   - InvokeLocal  → `azd deploy` + `azd ai agent monitor --follow`
+//     (the local invoke worked, so the next loop is "ship to Azure
+//     then watch the live logs". Spec: issue #7975 lines 168-181.)
 //   - InvokeRemote → `azd ai agent show <agent>` + monitor secondary
 //
 // Failure paths:
@@ -237,11 +239,24 @@ func ResolveAfterInvoke(state *State, mode InvokeMode, agentName string, failure
 
 func resolveInvokeSuccess(mode InvokeMode, agentName string) []Suggestion {
 	if mode == InvokeLocal {
-		return []Suggestion{{
-			Command:     "azd deploy",
-			Description: "the local invoke worked — ship it to Azure",
-			Priority:    10,
-		}}
+		// Issue #7975 lines 168-181: local-invoke success has run to
+		// completion against a local `azd ai agent run` process, so
+		// the user has already provisioned (dependencies exist) and
+		// the agent code itself works. The natural next step is to
+		// ship to Azure with `azd deploy`, and once it's running
+		// there, `monitor --follow` is the live-log feed.
+		return []Suggestion{
+			{
+				Command:     "azd deploy",
+				Description: "deploy the agent to Azure",
+				Priority:    10,
+			},
+			{
+				Command:     "azd ai agent monitor --follow",
+				Description: "view logs after deploying",
+				Priority:    20,
+			},
+		}
 	}
 
 	primary := "azd ai agent show"

cli/azd/extensions/azure.ai.agents/internal/cmd/nextstep/resolver_test.go

@@ -463,11 +463,32 @@ func TestResolveAfterRun_NilState(t *testing.T) {
 func TestResolveAfterInvoke_Success(t *testing.T) {
 	t.Parallel()
 
-	t.Run("local success → ship it", func(t *testing.T) {
+	t.Run("local success → deploy + monitor", func(t *testing.T) {
 		t.Parallel()
 		out := ResolveAfterInvoke(&State{}, InvokeLocal, "", nil)
-		require.Len(t, out, 1)
+		// Issue #7975 lines 168-181: local-invoke success surfaces
+		// both `azd deploy` (ship to Azure) and the live-log monitor
+		// follow-up (verify the deployed copy is healthy).
+		require.Len(t, out, 2)
+
 		assert.Equal(t, "azd deploy", out[0].Command)
+		assert.Equal(t, "deploy the agent to Azure", out[0].Description)
+		assert.False(t, out[0].Trailing,
+			"primary suggestion must not be Trailing")
+
+		assert.Equal(t, "azd ai agent monitor --follow", out[1].Command)
+		assert.Equal(t, "view logs after deploying", out[1].Description)
+		assert.False(t, out[1].Trailing,
+			"secondary suggestion must not be Trailing")
+
+		// Priority ordering matters: PrintNext / PrintAllNext stable-sort
+		// by Priority ascending, so the slice position alone does NOT
+		// guarantee the rendered order. Locking priorities here prevents
+		// a future edit from accidentally inverting the values and
+		// making `monitor --follow` render before `azd deploy`. Mirrors
+		// the failure-path pattern on the remote-failure test below.
+		assert.Less(t, out[0].Priority, out[1].Priority,
+			"deploy must sort before monitor --follow")
 	})
 
 	t.Run("remote success with agent name → show <agent> + monitor", func(t *testing.T) {