fix copilot reviews and other fixes

Author: paulbalandan

system/CLI/AbstractCommand.php

@@ -358,7 +358,7 @@ public function hasNegation(string $name): bool
      *   2. Otherwise, the command is interactive when STDIN is a TTY.
      *
      * Non-CLI contexts (e.g., a controller invoking `command()`) don't expose
-     * `STDIN` at all — those always resolve as non-interactive.
+     * `STDIN` at all; those always resolve as non-interactive.
      *
      * Note: the `--no-interaction` / `-N` flag is folded into the explicit state
      * by `run()` before interactive hooks fire, so callers do not need to
@@ -417,12 +417,12 @@ public function setInteractive(bool $interactive): static
      */
     final public function run(array $arguments, array $options): int
     {
-        $this->initialize($arguments, $options);
-
         if ($this->interactive === null && $this->hasUnboundOption('no-interaction', $options)) {
             $this->interactive = false;
         }
 
+        $this->initialize($arguments, $options);
+
         if ($this->isInteractive()) {
             $this->interact($arguments, $options);
         }
@@ -498,9 +498,9 @@ abstract protected function execute(array $arguments, array $options): int;
      * @param array<string, list<string>|string|null> $options               Parsed options from command line.
      * @param bool|null                               $noInteractionOverride `null` (default) propagates the parent's non-interactive state;
      *                                                                       `true` forces the sub-command non-interactive by injecting
-     *                                                                       `--no-interaction`; `false` strips any inherited
-     *                                                                       `--no-interaction` so the sub-command resolves its own state
-     *                                                                       (TTY detection may still downgrade it).
+     *                                                                       `--no-interaction`; `false` removes any forwarded
+     *                                                                       `--no-interaction` from `$options` so the sub-command
+     *                                                                       resolves its own state (TTY detection may still downgrade it).
      */
     protected function call(string $command, array $arguments = [], array $options = [], ?bool $noInteractionOverride = null): int
     {
@@ -693,9 +693,10 @@ protected function provideDefaultOptions(): void
      *    aliases, their value is preserved.
      *  - `true` forces the sub-command non-interactive regardless of the
      *    parent, again deferring to a caller-supplied value if present.
-     *  - `false` strips any inherited or propagated `--no-interaction` so the
-     *    sub-command resolves its own state. TTY detection can still force
-     *    non-interactive if STDIN is not a TTY.
+     *  - `false` removes any `--no-interaction` from `$options` (whether
+     *    caller-supplied or inherited) so the sub-command resolves its own
+     *    state. TTY detection can still force non-interactive if STDIN is
+     *    not a TTY.
      *
      * @param array<string, list<string|null>|string|null> $options
      *

tests/_support/Commands/Modern/InteractiveStateProbeCommand.php

@@ -20,7 +20,7 @@
 final class InteractiveStateProbeCommand extends AbstractCommand
 {
     /**
-     * Records whether `interact()` fired during the last run — a side-channel
+     * Records whether `interact()` fired during the last run. This is a side-channel
      * for asserting on a child fixture created anonymously by `Commands::runCommand()`.
      */
     public static bool $interactCalled = false;

tests/system/CLI/AbstractCommandTest.php

@@ -803,8 +803,8 @@ public function testCallStripsInheritedNoInteractionWhenCallerAllowsInteraction(
     public function testCallPreservesCallerFlagWhenForcingNonInteractive(): void
     {
         // When $noInteractionOverride is true and the caller already supplied the flag,
-        // the resolver must not touch the caller's entry — proved by the child
-        // still seeing a non-interactive state.
+        // the resolver must not touch the caller's entry. The child still sees a
+        // non-interactive state.
 
         $command = new ParentCallsInteractFixtureCommand(new Commands());
 

user_guide_src/source/cli/cli_modern_commands.rst

@@ -75,7 +75,7 @@ this order:
 3. ``interact(array &$arguments, array &$options): void`` also receives the
    raw arguments and options by reference. This is where you prompt the user
    for missing input, set values conditionally, or abort early. This hook is
-   skipped when the command is non-interactive — see :ref:`non-interactive-mode`.
+   skipped when the command is non-interactive (see :ref:`non-interactive-mode`).
 4. **Bind & validate.** The framework maps the raw input to the definitions
    you declared in ``configure()``, applies defaults, and rejects input that
    violates the definitions (missing required argument, unknown option, array
@@ -189,20 +189,20 @@ Non-Interactive Mode
 ====================
 
 Every modern command accepts ``--no-interaction`` / ``-N`` out of the box.
-When the flag is present — or when the command is otherwise non-interactive —
+When the flag is present, or when the command is otherwise non-interactive,
 the ``interact()`` hook is skipped entirely and the command proceeds straight
 to bind, validate, and ``execute()``.
 
 Programmatically, the state is exposed through two public methods on
 ``AbstractCommand``:
 
-- ``isInteractive(): bool`` — reports the current state.
-- ``setInteractive(bool $interactive): static`` — pins the state, overriding
+- ``isInteractive(): bool``: reports the current state.
+- ``setInteractive(bool $interactive): static``: pins the state, overriding
   both the CLI flag and TTY detection. Returns ``$this`` for chaining.
 
 The resolved state follows this precedence:
 
-1. An explicit ``setInteractive(bool)`` call wins — useful when a command
+1. An explicit ``setInteractive(bool)`` call wins. Useful when a command
    must force a specific mode for safety.
 2. Otherwise, the CLI flag ``--no-interaction`` / ``-N`` forces non-interactive state.
 3. Otherwise, **STDIN** is probed: if it is not a TTY (piped input, cron,
@@ -217,11 +217,11 @@ sub-command's ``$options`` wins over that propagation.
 The propagation can be overridden with the ``$noInteractionOverride``
 parameter of ``call()``:
 
-- ``null`` (default) — propagate the parent's state.
-- ``true`` — force the sub-command non-interactive regardless of the parent.
-- ``false`` — strip any inherited ``--no-interaction`` so the sub-command
-  resolves its own state. Note: TTY detection can still downgrade the
-  sub-command if STDIN is not a TTY.
+- ``null`` (default): propagate the parent's state.
+- ``true``: force the sub-command non-interactive regardless of the parent.
+- ``false``: remove any forwarded ``--no-interaction`` / ``-N`` from the
+  child ``$options`` so the sub-command resolves its own state. Note: TTY
+  detection can still downgrade the sub-command if STDIN is not a TTY.
 
 ******************
 Inside execute()
@@ -539,8 +539,8 @@ covered in the sections above and are not listed here.
         :param array     $options:                Options to forward, keyed by long name, shortcut, or negation.
         :param bool|null $noInteractionOverride:  Override the sub-command's interactive state.
                                                   ``null`` propagates the parent's state (default);
-                                                  ``true`` forces non-interactive; ``false`` strips
-                                                  any inherited ``--no-interaction`` flag.
+                                                  ``true`` forces non-interactive; ``false`` removes
+                                                  any forwarded ``--no-interaction`` from ``$options``.
         :returns:                                 The exit code returned by the called command.
 
         Invokes another modern command. The arguments and options go through