Designed the @with_annotated feature as stabilized in the CHANGELOG and docs

Also:
- Prepare for 4.3.0 release

Author: tleonhardt

CHANGELOG.md

@@ -1,5 +1,11 @@
-## 4.3.0 (TBD)
-
+## 4.3.0 (October 13, 2026)
+
+- Stabilized features
+    - `@with_annotated` is no longer experimental. It was introduced as an experimental feature in
+      4.0.0 and is now a fully supported way to define a command's arguments, alongside
+      `@with_argparser`. This covers the decorator and its supporting API in `cmd2.annotated`,
+      including `Argument`, `Option`, `Group`, and `ArgumentBlock`.
+      [Annotated Argument Processing](https://cmd2.readthedocs.io/en/latest/features/annotated/).
 - Bug Fixes
     - On POSIX, piping a command's output to an interactive program such as `less`
       (`help -v | less`) now runs that program as the terminal's foreground job, as a shell pipeline

CLAUDE.md

@@ -71,8 +71,9 @@ Three layers, all producing a `Cmd2ArgumentParser`:
   range `nargs` tuples, per-argument completion metadata, and subcommand records.
 - `cmd2/decorators.py` — `@with_argparser`, `@with_argument_list`, `@with_category`,
   `@as_subcommand_to` attach parsers/metadata to `do_*` methods.
-- `cmd2/annotated.py` — the newer, still-experimental Typer-style path: `@with_annotated` builds a
-  parser from a function's type hints, with `Argument`/`Option` metadata via `typing.Annotated`.
+- `cmd2/annotated.py` — the newer Typer-style path (experimental in 4.0.0, stable as of 4.3.0):
+  `@with_annotated` builds a parser from a function's type hints, with `Argument`/`Option` metadata
+  via `typing.Annotated`.
 
 Parsers are built lazily and cached by the `CommandParsers` class in `cmd2.py` (`_build_parser`), so
 that `CommandSet`-supplied subcommands can be attached and detached at runtime.

README.md

@@ -89,7 +89,9 @@ to build a more complete application.
 
 - Define commands as Python methods and use familiar
   [`argparse`](https://cmd2.readthedocs.io/en/latest/features/argument_processing/) parsers for
-  arguments and subcommands. A single parser definition drives validation, help, and completion.
+  arguments and subcommands, or plain type hints via
+  [`@with_annotated`](https://cmd2.readthedocs.io/en/latest/features/annotated/). A single parser
+  definition drives validation, help, and completion.
 - Render Rich tables and other styled objects, with consistent helpers for
   [normal output, errors, warnings, and paging](https://cmd2.readthedocs.io/en/latest/features/generating_output/).
 - Organize large applications into independently testable and dynamically loadable

cmd2/annotated.py

@@ -1,9 +1,5 @@
 """Build argparse parsers from type-annotated function signatures.
 
-!!! warning "Experimental"
-
-    This module is experimental and its behavior may change in future releases.
-
 The [`with_annotated`][cmd2.annotated.with_annotated] decorator inspects a command function's type hints and
 default values to build a ``Cmd2ArgumentParser``.  [`Argument`][cmd2.annotated.Argument] and
 [`Option`][cmd2.annotated.Option] metadata classes give finer per-parameter control via

docs/features/annotated.md

@@ -1,16 +1,5 @@
 # Annotated Argument Processing
 
-!!! warning "Experimental"
-
-    The `@with_annotated` decorator and its supporting `Argument` / `Option` metadata classes are
-    **experimental**. The public API, the surface of accepted type annotations, and the generated
-    argparse behavior may all change in future releases without a deprecation cycle. Pin a specific
-    `cmd2` version if you depend on the exact current semantics, and expect to revisit your usage on
-    upgrades.
-
-    For production code that needs stable behavior, use
-    [@with_argparser](argument_processing.md#with_argparser-decorator) instead.
-
 The [@with_annotated][cmd2.with_annotated] decorator builds an argparse parser automatically from
 the decorated function's type annotations. No manual `add_argument()` calls are required, and the
 command body receives typed keyword arguments directly instead of an `argparse.Namespace`.
@@ -45,9 +34,8 @@ The two decorators are interchangeable -- here is the same command written both
 
 The annotated version is more concise, gives you typed parameters, and supports several advanced
 cmd2 features directly, including `ns_provider`, `with_unknown_args`, and typed subcommands. Pick
-`@with_argparser` when you need a stable, well-established API or fine-grained control over the
-parser; pick `@with_annotated` when you want type-hint-driven ergonomics and can accept the
-experimental status.
+`@with_argparser` when you want direct control over the parser or already have one; pick
+`@with_annotated` when you want type-hint-driven ergonomics.
 
 ## Basic usage
 
@@ -815,16 +803,3 @@ Specifically:
 
 With `@with_argparser`, provide `choices`, `choices_provider`, or `completer` explicitly when you
 want completion behavior.
-
-## Stability and feedback
-
-Because this feature is experimental:
-
-- Behavior of edge cases (mixed-type tuples, deeply-nested `Annotated`, conflicting metadata) may
-  change.
-- Diagnostic error messages may be reworded.
-- The set of supported type annotations may be expanded or trimmed.
-
-If you depend on `@with_annotated`, please share feedback and edge cases via the
-[issue tracker](https://github.com/python-cmd2/cmd2/issues) so behavior can be locked in before the
-feature graduates out of experimental.

docs/features/argument_processing.md

@@ -57,14 +57,10 @@ stores internally. A consequence is that parsers don't need to be unique across
 
 ## with_annotated decorator
 
-!!! warning "Experimental"
-
-    The `@with_annotated` decorator is **experimental** and its API may change in future releases.
-
 The [@with_annotated][cmd2.with_annotated] decorator builds an argparse parser automatically from
 the decorated function's type annotations -- no manual `add_argument()` calls required. See
 [Annotated Argument Processing](annotated.md) for the full reference, including type mapping,
-metadata classes, subcommands, and stability caveats.
+metadata classes, and subcommands.
 
 ## Argument Parsing