It looks like you took some fancy items from agile development, put them to waterfall process and now you call it agile.
The product is developed for a customer who will re-sell it while
paying us royalty.
This is OK.
The team does not get to talk directly to the end user. Only to
the reseller.
This is OK. Product owner talk to reseller and collects requirements.
A product requirements document was created before starting
development.
This is not OK. I haven't seen the project where definite requirement set can be defined upfront. Change your product requirements document to product vision (short) with some initial set of requirements which are subject to change.
The requirements are rigid and do not change.
This is not OK and you will see in the future that it is also not true.
A delivery schedule was agreed on with milestones such as "alpha",
"beta" etc. and features/times attached to those milestones.
This is not OK. The real schedule will be visible from the team progress. You can make general milestones but assigning exact set of features which will be implemented in these milestones is not agile. This can change during development.
All developers on the Scrum team report to the product owner, a
software manager.
This is not OK. I would not say that developers report to product owner. Scrum process keeps visibility of the process but developers do not report anything except regular meetings. It is responsibility of product owner to be in contact with a team and as active participant see the progress himself.
Testers on the team report to a QA manager.
This is not OK. Testers should be part of development team because user story is not done until it is tested (there should be automated test to validate acceptance criteria). There can be separate QA but it is additional level of complex testing and it is usually done on customer side (but doesn't have to be) to validate that SW does what customer expects and the feedback is collected as new backlog items or bugs to existing completed backlog items.
Separating complete QA outside of development team leads to breaking the whole purpose of definition of done. Some QA must be part of the team and that part is not related to any QA manager - that part is doing commitment with development team.
The product owner has directed the team towards certain high risk
technical tasks. The output of those tasks is not usable by the end
user but rather some technology/code that will eventually be used in
the product.
This happens in every project but it should be part of some product backlog item targeting end user. It can be included directly in backlog item implemented in current iteration or it can be included as a spike (proof-of-concept) to clarify complexity of some backlog item which should be implemented in the future.
The product owner has created a backlog based on the requirements.
This is a must.
The product owner is unable to answer some questions regarding the
product. He refers to others or to the documented requirements.
This is not OK. It is job of the product owner to know answers. He has a responsibility and he must do decisions. If he doesn't know answer he must find it asap.
The team goes through the motions of Scrum. Daily Scrum, Sprint
Planning, Retrospective etc. There is a ScrumMaster.
This is OK but it doesn't mean that team is doing Scrum.
Every sprint the product owner and management decide what backlog
items the team works on.
This is definitely not OK. The product owner and management can make priorities but commitment (selection of most prioritized items) is teams responsibility.
There is a burndown chart. Scrum board with stories and tasks. The
estimates on those come from the team.
This is OK.
The team sits in an open floor "bull pen" shared with other teams,
all visible and audible. There is cross-team noise and there is foot
traffic around the team area.
It is Scrum master's responsibility to make end of this if team feels like it reduces their productivity.
The team may be required to attend various meetings not directly
related to the goals of the sprint.
It is OK, the time wasted on these meetings will result in smaller commitment (team will do less real work). It is up to Scrum master / management to reduce these meetings to increase team's velocity.
There are pressures to select certain technical solutions. Some
tools and processes are mandated.
This is partially OK. There can be non-functional requirements for tools and architecture and there can be defined processes but still final implementation is up to the team.
No, Agile does not call for the need of HLD (or SRS, business requirements) document or LLD (or technical specification) to be associated with User Stories. These documents would be highly encouraged for the Waterfall process however.
Simply because Agile does not call for this doesn't mean that it shouldn't exist though. They are not mutually exclusive. One can theoretically manage an Agile project and still demand HLD and LLD documents however the case should be made if these documents bring value to the stakeholders.
It is highly encouraged in Agile to only do tasks that bring value to the stakeholder and most would argue these documents do not do this. They may bring value to the architects or to the developer, but the users and other stakeholders likely do not care about such things unless they specifically require them as deliverables.
Best Answer
This seems to me to be the unspoken elephant in the room with Agile projects: how do you prevent them from evolving into chaos?
Let's look at the Agile Manifesto for a moment. Agile desires:
I've highlighted the last four. Why? Because they're the ones that will prevent the project from collapsing under its own weight.
Sustainable development means that you (hopefully) have someone that oversees the overall development process, someone who can steer the ship beyond growing the software a little bit at a time, someone who has an overarching vision of the entire project, someone with a keen knowledge of software architecture, system design, business logic principles and UI ergonomics. An architect, in other words.
The architect is the one that says "I know you asked for this, but if we build this other thing, we can avoid these other three features that are just confusing, and focus on the core requirement." He's the one that gives the team time to reduce technical debt. He's the one that brings an overarching structure and organization to the project. He's the one that calls meetings where the team gets together and asks "How can we do things better?"
And he's the one that maintains the master requirements document.
In the book Mastering the Requirements Process, the authors maintain that there are three kinds of customers, three kinds of software projects: Rabbits, Horses and Elephants. Rabbits are the small software projects that only need informal requirements; you work directly with the customer in small sprints, the scope of the project is reasonably constrained, and the software gets done within a relatively short time frame. Elephants are those mammoth projects that require a lot of up-front planning, a tremendous amount of documentation, and a long time horizon. They are arguably not agile, although you can break them up into smaller projects that can be built using agile.
It's the Horse projects that are somewhat confounding from an agile perspective. They can still be built iteratively, you can still use short sprints, but without some discipline in the requirements gathering and planning processes, they can easily run off the rails. These are the projects that can benefit from a disciplined requirements gathering process, and then careful adaptation and modification of those requirements as the project grows, while still maintaining an overarching vision for the entire project.
From a personal perspective, I work with a small team of about a dozen developers. At any given moment, we might be working on three software projects at the same time, ranging anywhere from a few thousand lines of code to over 100,000. Our customer thinks they are a rabbit, but they're really a horse. The customer is engaged, but not on a daily basis.
By far our weakest area is gathering specific, testable, measurable requirements and managing the customer's expectations relative to project scope. But we're working on that.