@@ -1961,6 +1961,10 @@ pub struct Parser<'t, 'a, 'v> {
     /// Once, per parse: a default subcommand that itself declares one would otherwise
     /// descend on every word until the tree ran out.
     default_taken: bool,
+    /// Whether this parse reads the words before a cursor. The word under the cursor is still
+    /// to be typed, so the line is not an empty invocation and `default_subcommand_on_empty`
+    /// must not route away from the root's own subcommands and flags.
+    completing: bool,
     /// First default-only flag, when lookahead found no explicit sibling.
     default_flag_at: Option<usize>,
     /// Cursor just after the implicit boundary bundle, whose shorts keep parent ownership.
@@ -1995,7 +1999,9 @@ impl<'t: 'v, 'a, 'v> Parser<'t, 'a, 'v> {
     /// Begin a non-executing parse for completion walking.
     #[cfg(feature = "complete")]
     pub(crate) fn for_completion(root: &'t Command<'t>, argv: &'a [&'v OsStr]) -> Self {
-        Self::with_action_errors(root, argv, false)
+        let mut parser = Self::with_action_errors(root, argv, false);
+        parser.completing = true;
+        parser
     }
 
     fn with_action_errors(
@@ -2034,6 +2040,7 @@ impl<'t: 'v, 'a, 'v> Parser<'t, 'a, 'v> {
             separator_seen: false,
             clause_separator_seen: false,
             default_taken: false,
+            completing: false,
             default_flag_at: None,
             default_bundle_end: 0,
             done: false,
@@ -2310,6 +2317,7 @@ impl<'t: 'v, 'a, 'v> Parser<'t, 'a, 'v> {
             && self.depth == 0
             && self.cmd.default_subcommand_on_empty
             && !self.default_taken
+            && !self.completing
             && !self.positional_arg_found
             && !self.separator_seen
             && !self.clause_separator_seen
 
@@ -153,7 +153,7 @@ impl CompleteWord {
             ctx.insert("PREV", &(cword - 1));
         }
 
-        let parsed = usage::parse::parse_partial(spec, &words)?;
+        let parsed = usage::parse::parse_partial_for_completion(spec, &words)?;
         debug!("parsed cmd: {}", parsed.cmd.full_cmd.join(" "));
 
         // Past an `external_subcommand` catch-all the cursor is inside another program's line.
 
@@ -0,0 +1,33 @@
+{
+  "section": "default-subcommand-on-empty",
+  "about": "An empty-invocation default does not hide the root's own candidates from completion: the word under the cursor is still to be typed.",
+  "vectors": [
+    {
+      "id": "empty-default-offers-all-root-subcommands",
+      "doc": "An empty word at the root still lists every subcommand.",
+      "spec": "name \"x\"\nbin \"x\"\nflag \"--rootf\"\ndefault_subcommand \"def\"\ndefault_subcommand_on_empty #true\ncmd \"def\" {\n flag \"--x <x>\"\n arg \"[a]\"\n}\ncmd \"other\"\n",
+      "line": "x ",
+      "expect": {
+        "candidates": ["def", "other"]
+      }
+    },
+    {
+      "id": "empty-default-offers-root-subcommands",
+      "doc": "At the root, completion offers the subcommands, not only the default command's arguments.",
+      "spec": "name \"x\"\nbin \"x\"\nflag \"--rootf\"\ndefault_subcommand \"def\"\ndefault_subcommand_on_empty #true\ncmd \"def\" {\n flag \"--x <x>\"\n arg \"[a]\"\n}\ncmd \"other\"\n",
+      "line": "x o",
+      "expect": {
+        "candidates": ["other"]
+      }
+    },
+    {
+      "id": "empty-default-offers-root-flags",
+      "doc": "At the root, completion offers the root's flags rather than the default command's.",
+      "spec": "name \"x\"\nbin \"x\"\nflag \"--rootf\"\ndefault_subcommand \"def\"\ndefault_subcommand_on_empty #true\ncmd \"def\" {\n flag \"--x <x>\"\n arg \"[a]\"\n}\ncmd \"other\"\n",
+      "line": "x --ro",
+      "expect": {
+        "candidates": ["--rootf"]
+      }
+    }
+  ]
+}
@@ -1253,6 +1253,25 @@ pub fn parse(spec: &Spec, input: &[String]) -> Result<ParseOutput, miette::Error
     Parser::new(spec).parse(input)
 }
 
+/// Parse the words before the cursor for completion.
+///
+/// Like [`parse_partial`], except that `default_subcommand_on_empty` is not applied. The word
+/// under the cursor is still to be typed, so the line is not an empty invocation: the root's
+/// subcommands and flags are all still valid next words, and routing into the default command
+/// would hide them.
+#[must_use = "parsing result should be used"]
+pub fn parse_partial_for_completion(
+    spec: &Spec,
+    input: &[String],
+) -> Result<ParseOutput, miette::Error> {
+    if spec.default_subcommand_on_empty {
+        let mut spec = spec.clone();
+        spec.default_subcommand_on_empty = false;
+        return parse_partial(&spec, input);
+    }
+    parse_partial(spec, input)
+}
+
 /// Parse command-line arguments without applying defaults.
 ///
 /// Use this for help text generation or when you need the raw parsed values.
 
@@ -429,7 +429,7 @@ fn complete_subtree(
     input: &[String],
     prefix: &str,
 ) -> Result<Completions<'static>, Error> {
-    let parsed = usage_parser::parse::parse_partial(spec, input)
+    let parsed = usage_parser::parse::parse_partial_for_completion(spec, input)
         .map_err(|error| Error::Parse(error.to_string()))?;
     // A plugin may itself forward to a program of its own. One level down, the same rule: these
     // words describe nothing this spec knows about.
@@ -457,7 +457,33 @@ fn complete_subtree(
             files = completion_files(spec, &parsed.cmd, arg);
         }
     } else if flag_like {
-        for (form, flag) in parsed.completion_flags() {
+        let mut flags = parsed.completion_flags();
+        // The completion parse no longer routes an empty root into the default command, so the
+        // flags `default_subcommand_flags` lends from it are added here, as `complete-word` does.
+        if spec.default_subcommand_flags
+            && parsed.cmds.len() == 1
+            && !root_took_positional(&parsed)
+            && let Some(default) = spec
+                .default_subcommand
+                .as_deref()
+                .and_then(|name| parsed.cmd.find_subcommand(name))
+        {
+            for flag in &default.flags {
+                let flag = std::sync::Arc::new(flag.clone());
+                for key in flag
+                    .long
+                    .iter()
+                    .map(|name| format!("--{name}"))
+                    .chain(flag.short.iter().map(|name| format!("-{name}")))
+                    .chain(flag.negate.iter().cloned())
+                {
+                    flags
+                        .entry(key)
+                        .or_insert_with(|| std::sync::Arc::clone(&flag));
+                }
+            }
+        }
+        for (form, flag) in flags {
             if flag.hide || !form.starts_with(prefix) || hidden_flag_form(&form, &flag) {
                 continue;
             }
@@ -492,6 +518,22 @@ fn complete_subtree(
                 }
             }
         }
+        // At the root with an empty-invocation default, the user may mean to elide the default
+        // command's name, so its first argument's choices are offered too. The choices stay
+        // out of `closed`: they belong to a different command and are only a guess.
+        if spec.default_subcommand_on_empty
+            && parsed.cmds.len() == 1
+            && !parsed.double_dash_seen
+            && !root_took_positional(&parsed)
+            && let Some(default) = spec
+                .default_subcommand
+                .as_deref()
+                .and_then(|name| parsed.cmd.find_subcommand(name))
+            && let Some(arg) = default.args.iter().find(|arg| arg.sigil.is_none())
+            && arg.double_dash != usage_parser::SpecDoubleDashChoices::Required
+        {
+            candidates.extend(choice_candidates(arg, prefix));
+        }
     }
     sort_and_dedup(&mut candidates);
 
@@ -510,6 +552,24 @@ fn complete_subtree(
     Ok(Completions { candidates, files })
 }
 
+/// Whether the root already took a positional, so the default command can no longer be
+/// selected by the next word. An unknown flag a positional absorbed counts: it filled one.
+fn root_took_positional(parsed: &usage_parser::parse::ParseOutput) -> bool {
+    use usage_parser::parse::TokenRole;
+    !parsed.args.is_empty()
+        || parsed.tokens.iter().any(|token| {
+            token.roles.iter().any(|role| {
+                matches!(
+                    role,
+                    TokenRole::Arg { .. }
+                        | TokenRole::Sigil { .. }
+                        | TokenRole::ClauseSeparator { .. }
+                        | TokenRole::UnknownFlag { bound_as: Some(_) }
+                )
+            })
+        })
+}
+
 /// Whether this position states what it accepts, so an unmatched prefix means "no matches".
 ///
 /// Choices are the obvious case. A declared `complete` block is one too — unless it says its
Original file line number	Diff line number	Diff line change
`@@ -153,7 +153,7 @@ impl CompleteWord {`
`153`	`153`	`ctx.insert("PREV", &(cword - 1));`
`154`	`154`	`}`
`155`	`155`
`156`		`- let parsed = usage::parse::parse_partial(spec, &words)?;`
	`156`	`+ let parsed = usage::parse::parse_partial_for_completion(spec, &words)?;`
`157`	`157`	`debug!("parsed cmd: {}", parsed.cmd.full_cmd.join(" "));`
`158`	`158`
`159`	`159`	// Past an `external_subcommand` catch-all the cursor is inside another program's line.