fix: rebuild cobra command tree on each workflow re-execution

The workflowCmdAdapter previously cached a single rootCmd cobra command
tree as a singleton. When the ErrorMiddleware retry loop or gRPC
WorkflowService re-executed commands (e.g. after Copilot agent fixes a
provision failure), the stale tree with cancelled contexts caused
'context cancelled' exceptions.

Changed workflowCmdAdapter to use a command factory that calls
NewRootCmd() on each ExecuteContext() call, producing a fresh cobra
command tree with no stale state. This follows the same proven pattern
used in auto_install.go.

Fixes Azure#6530

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

Author: wbreza

cli/azd/cmd/container.go

@@ -891,13 +891,12 @@ func registerCommonDependencies(container *ioc.NestedContainer) {
 		container.MustRegisterNamedSingleton(platformName, constructor)
 	}
 
-	container.MustRegisterSingleton(func(s ioc.ServiceLocator) (workflow.AzdCommandRunner, error) {
-		var rootCmd *cobra.Command
-		if err := s.ResolveNamed("root-cmd", &rootCmd); err != nil {
-			return nil, err
+	container.MustRegisterSingleton(func() workflow.AzdCommandRunner {
+		return &workflowCmdAdapter{
+			newCommand: func() *cobra.Command {
+				return NewRootCmd(false, nil, container)
+			},
 		}
-		return &workflowCmdAdapter{cmd: rootCmd}, nil
-
 	})
 	container.MustRegisterSingleton(workflow.NewRunner)
 
@@ -948,19 +947,29 @@ func registerCommonDependencies(container *ioc.NestedContainer) {
 	registerAction[*configShowAction](container, "azd-config-show-action")
 }
 
-// workflowCmdAdapter adapts a cobra command to the workflow.AzdCommandRunner interface
+// workflowCmdAdapter adapts a cobra command to the workflow.AzdCommandRunner interface.
+// On each ExecuteContext call, a fresh cobra command tree is built via the newCommand factory
+// to avoid stale context or command state from previous executions.
+// See: https://github.com/Azure/azure-dev/issues/6530
 type workflowCmdAdapter struct {
-	cmd *cobra.Command
+	newCommand func() *cobra.Command
+	args       []string
 }
 
 func (w *workflowCmdAdapter) SetArgs(args []string) {
-	w.cmd.SetArgs(args)
+	w.args = args
 }
 
-// ExecuteContext implements workflow.AzdCommandRunner
+// ExecuteContext implements workflow.AzdCommandRunner.
+// It rebuilds the cobra command tree on each call to ensure a clean slate,
+// preventing "context cancelled" errors from stale command state during retries.
 func (w *workflowCmdAdapter) ExecuteContext(ctx context.Context) error {
 	childCtx := middleware.WithChildAction(ctx)
-	return w.cmd.ExecuteContext(childCtx)
+	rootCmd := w.newCommand()
+	if w.args != nil {
+		rootCmd.SetArgs(w.args)
+	}
+	return rootCmd.ExecuteContext(childCtx)
 }
 
 // ArmClientInitializer is a function definition for all Azure SDK ARM Client

cli/azd/cmd/container_test.go

@@ -170,24 +170,27 @@ func Test_WorkflowCmdAdapter_ContextPropagation(t *testing.T) {
 		// Track which contexts were seen by the subcommand
 		var receivedContexts []context.Context
 
-		// Create a root command with a subcommand
-		rootCmd := &cobra.Command{
-			Use: "root",
-		}
+		// Create a command factory that builds a fresh tree on each call
+		newCommand := func() *cobra.Command {
+			rootCmd := &cobra.Command{
+				Use: "root",
+			}
 
-		subCmd := &cobra.Command{
-			Use: "sub",
-			RunE: func(cmd *cobra.Command, args []string) error {
-				// Capture the context that the subcommand receives
-				receivedContexts = append(receivedContexts, cmd.Context())
-				return nil
-			},
-		}
+			subCmd := &cobra.Command{
+				Use: "sub",
+				RunE: func(cmd *cobra.Command, args []string) error {
+					// Capture the context that the subcommand receives
+					receivedContexts = append(receivedContexts, cmd.Context())
+					return nil
+				},
+			}
 
-		rootCmd.AddCommand(subCmd)
+			rootCmd.AddCommand(subCmd)
+			return rootCmd
+		}
 
-		// Create the adapter
-		adapter := &workflowCmdAdapter{cmd: rootCmd}
+		// Create the adapter with a factory
+		adapter := &workflowCmdAdapter{newCommand: newCommand}
 
 		// In production, main.go wraps with context.WithoutCancel.
 		// Simulate this by using a non-cancellable context.
@@ -209,7 +212,7 @@ func Test_WorkflowCmdAdapter_ContextPropagation(t *testing.T) {
 			// Expected: context is still valid
 		}
 
-		// Execute again - should still work
+		// Execute again - should still work (fresh command tree each time)
 		adapter.SetArgs([]string{"sub"})
 		err = adapter.ExecuteContext(ctx)
 		require.NoError(t, err)
@@ -224,27 +227,30 @@ func Test_WorkflowCmdAdapter_ContextPropagation(t *testing.T) {
 		// Track which contexts were seen
 		var receivedContexts []context.Context
 
-		// Create a root command with nested subcommands
-		rootCmd := &cobra.Command{
-			Use: "root",
-		}
+		// Create a command factory that builds a fresh tree on each call
+		newCommand := func() *cobra.Command {
+			rootCmd := &cobra.Command{
+				Use: "root",
+			}
 
-		parentCmd := &cobra.Command{
-			Use: "parent",
-		}
+			parentCmd := &cobra.Command{
+				Use: "parent",
+			}
 
-		childCmd := &cobra.Command{
-			Use: "child",
-			RunE: func(cmd *cobra.Command, args []string) error {
-				receivedContexts = append(receivedContexts, cmd.Context())
-				return nil
-			},
-		}
+			childCmd := &cobra.Command{
+				Use: "child",
+				RunE: func(cmd *cobra.Command, args []string) error {
+					receivedContexts = append(receivedContexts, cmd.Context())
+					return nil
+				},
+			}
 
-		parentCmd.AddCommand(childCmd)
-		rootCmd.AddCommand(parentCmd)
+			parentCmd.AddCommand(childCmd)
+			rootCmd.AddCommand(parentCmd)
+			return rootCmd
+		}
 
-		adapter := &workflowCmdAdapter{cmd: rootCmd}
+		adapter := &workflowCmdAdapter{newCommand: newCommand}
 
 		// In production, main.go wraps with context.WithoutCancel.
 		ctx := context.WithoutCancel(context.Background())
@@ -257,7 +263,7 @@ func Test_WorkflowCmdAdapter_ContextPropagation(t *testing.T) {
 		require.True(t, middleware.IsChildAction(receivedContexts[0]),
 			"Nested context should be marked as child action")
 
-		// Second execution should also work
+		// Second execution should also work (fresh command tree)
 		adapter.SetArgs([]string{"parent", "child"})
 		err = adapter.ExecuteContext(ctx)
 		require.NoError(t, err)
@@ -274,4 +280,40 @@ func Test_WorkflowCmdAdapter_ContextPropagation(t *testing.T) {
 		require.True(t, middleware.IsChildAction(receivedContexts[1]),
 			"Second nested context should also be marked as child action")
 	})
+
+	t.Run("FreshCommandTreeOnEachExecution", func(t *testing.T) {
+		// Verify that each ExecuteContext call creates a new command tree,
+		// ensuring no stale state from previous executions.
+		var commandTreeInstances []*cobra.Command
+
+		newCommand := func() *cobra.Command {
+			rootCmd := &cobra.Command{
+				Use: "root",
+			}
+			rootCmd.AddCommand(&cobra.Command{
+				Use: "test",
+				RunE: func(cmd *cobra.Command, args []string) error {
+					return nil
+				},
+			})
+			commandTreeInstances = append(commandTreeInstances, rootCmd)
+			return rootCmd
+		}
+
+		adapter := &workflowCmdAdapter{newCommand: newCommand}
+		ctx := context.WithoutCancel(context.Background())
+
+		adapter.SetArgs([]string{"test"})
+		err := adapter.ExecuteContext(ctx)
+		require.NoError(t, err)
+
+		adapter.SetArgs([]string{"test"})
+		err = adapter.ExecuteContext(ctx)
+		require.NoError(t, err)
+
+		// Each execution should have created a distinct command tree
+		require.Len(t, commandTreeInstances, 2, "Factory should have been called twice")
+		require.NotSame(t, commandTreeInstances[0], commandTreeInstances[1],
+			"Each execution should use a distinct command tree instance")
+	})
 }