@@ -20,6 +20,7 @@ import { setupProxySupport } from './utils/network'
 import { withLocalBinPath } from './utils/path-env'
 import { resolveProjectDir } from './utils/paths'
 import { templateNames } from './utils/templates/names'
+import { findUnknownFlags, suggestFlags } from './utils/unknown-args'
 import { scheduleUpdateNudge } from './utils/update-lazy'
 
 // Node.js only reads `NODE_USE_ENV_PROXY` during bootstrap, so this cannot make
@@ -68,6 +69,10 @@ const _main = defineCommand({
       process.exit(0)
     }
 
+    if (command && Object.hasOwn(commands, command)) {
+      await warnUnknownFlags(command, ctx.rawArgs)
+    }
+
     // allow running arbitrary commands if there's a locally registered binary with `nuxt-` prefix
     if (ctx.args.command && !Object.hasOwn(commands, ctx.args.command)) {
       const cwd = resolve(ctx.args.cwd)
@@ -93,4 +98,39 @@ const _main = defineCommand({
   },
 })
 
+/**
+ * Report long flags the resolved command does not declare. Unknown flags are
+ * otherwise parsed and silently ignored, so a misspelling looks like the flag
+ * simply had no effect.
+ */
+async function warnUnknownFlags(command: string, rawArgs: string[]): Promise<void> {
+  let def: CommandDef<any>
+  try {
+    def = await commands[command as keyof typeof commands]() as CommandDef<any>
+    const subCommands = await resolveLazy(def.subCommands)
+    const subCommand = rawArgs.slice(1).find(arg => !arg.startsWith('-'))
+    if (subCommands && subCommand && Object.hasOwn(subCommands, subCommand)) {
+      def = await resolveLazy(subCommands[subCommand]) as CommandDef<any>
+    }
+  }
+  catch (err) {
+    debug('Could not check arguments:', err)
+    return
+  }
+
+  const argsDef = { ...cwdArgs, ...await resolveLazy(def.args) }
+  const unknown = findUnknownFlags(argsDef, rawArgs.slice(1))
+  if (unknown.flags.length === 0) {
+    return
+  }
+
+  for (const { flag, suggestion } of await suggestFlags(unknown)) {
+    logger.warn(`Unknown option ${styleText('cyan', flag)}.${suggestion ? ` Did you mean ${styleText('cyan', suggestion)}?` : ''}`)
+  }
+}
+
+function resolveLazy<T>(value: T | (() => T | Promise<T>) | undefined): Promise<T | undefined> {
+  return Promise.resolve(typeof value === 'function' ? (value as () => T | Promise<T>)() : value)
+}
+
 export const main = _main as CommandDef<any>
@@ -0,0 +1,79 @@
+import type { ArgsDef } from 'citty'
+
+/** Always accepted by citty, so never reported as unknown. */
+const BUILTIN_FLAGS = ['help', 'version']
+
+/** Low enough to catch a wrong case (`--loglevel`) or a dropped letter, high enough not to invent a match. */
+const SUGGESTION_THRESHOLD = 0.3
+
+const LEADING_DASHES_RE = /^--/
+const NEGATION_RE = /^no-/
+
+export interface UnknownFlags {
+  flags: string[]
+  known: string[]
+}
+
+/**
+ * Long flags in `rawArgs` that `argsDef` does not declare.
+ *
+ * Only `--long` forms are considered. A bundle of short flags (`-abc`) cannot be
+ * told apart from a single misspelled one, and guessing wrong is worse than
+ * staying quiet.
+ */
+export function findUnknownFlags(argsDef: ArgsDef, rawArgs: string[]): UnknownFlags {
+  const known = new Set<string>(BUILTIN_FLAGS)
+  for (const [name, def] of Object.entries(argsDef)) {
+    known.add(name)
+    const alias = (def as { alias?: string | string[] }).alias
+    for (const entry of Array.isArray(alias) ? alias : alias ? [alias] : []) {
+      known.add(entry)
+    }
+  }
+
+  const separator = rawArgs.indexOf('--')
+  const argv = separator === -1 ? rawArgs : rawArgs.slice(0, separator)
+
+  const flags: string[] = []
+  for (const arg of argv) {
+    if (!arg.startsWith('--') || arg === '--') {
+      continue
+    }
+    const equals = arg.indexOf('=')
+    const name = (equals === -1 ? arg : arg.slice(0, equals)).replace(LEADING_DASHES_RE, '')
+    if (name && !isKnown(known, name) && !flags.includes(name)) {
+      flags.push(name)
+    }
+  }
+  return { flags, known: [...known] }
+}
+
+/**
+ * The declared flag each unknown flag was most likely meant to be. Resolved
+ * separately so the fuzzy matcher is only loaded once something is wrong.
+ */
+export async function suggestFlags({ flags, known }: UnknownFlags): Promise<Array<{ flag: string, suggestion?: string }>> {
+  const { default: fuzzysort } = await import('fuzzysort')
+  return flags.map((flag) => {
+    const [match] = fuzzysort.go(flag.replace(NEGATION_RE, ''), known, { limit: 1, threshold: SUGGESTION_THRESHOLD })
+    return { flag: `--${flag}`, suggestion: match && `--${match.target}` }
+  })
+}
+
+/**
+ * Dotted flags are declared either whole (`https.cert`) or as the object that
+ * holds them (`https`), and a boolean may be negated with a `no-` prefix.
+ */
+function isKnown(known: Set<string>, name: string): boolean {
+  for (const candidate of new Set([name, name.replace(NEGATION_RE, '')])) {
+    if (known.has(candidate)) {
+      return true
+    }
+    for (let dot = candidate.lastIndexOf('.'); dot !== -1; dot = candidate.lastIndexOf('.', dot - 1)) {
+      if (known.has(candidate.slice(0, dot))) {
+        return true
+      }
+    }
+  }
+  return false
+}
@@ -0,0 +1,95 @@
+import type { ArgsDef, CommandDef } from 'citty'
+
+import { describe, expect, it } from 'vitest'
+
+import { commands } from '../../src/commands'
+import { cwdArgs } from '../../src/commands/_shared'
+import { findUnknownFlags, suggestFlags } from '../../src/utils/unknown-args'
+
+const argsDef = {
+  'cwd': { type: 'string' },
+  'json': { type: 'boolean' },
+  'logLevel': { type: 'string' },
+  'fork': { type: 'boolean' },
+  'https': { type: 'boolean' },
+  'open.url': { type: 'string' },
+  'port': { type: 'string', alias: ['p'] },
+} satisfies ArgsDef
+
+describe('findUnknownFlags', () => {
+  it('should accept declared flags, aliases and negations', () => {
+    const { flags } = findUnknownFlags(argsDef, ['--cwd=.', '--json', '--no-fork', '--port', '3000', '--help', '--version'])
+    expect(flags).toEqual([])
+  })
+
+  it('should accept a dotted flag declared whole or by its parent', () => {
+    expect(findUnknownFlags(argsDef, ['--open.url=/admin', '--https.cert=x', '--https.key', 'y']).flags).toEqual([])
+  })
+
+  it('should report a flag that is not declared', () => {
+    expect(findUnknownFlags(argsDef, ['--strictport']).flags).toEqual(['strictport'])
+  })
+
+  it('should report each unknown flag once', () => {
+    expect(findUnknownFlags(argsDef, ['--nope', '--nope=1']).flags).toEqual(['nope'])
+  })
+
+  it('should ignore short flags and everything after a separator', () => {
+    expect(findUnknownFlags(argsDef, ['-abc', '-x', '--', '--nope']).flags).toEqual([])
+  })
+
+  it('should ignore positionals and a bare separator', () => {
+    expect(findUnknownFlags(argsDef, ['build', './app', '--']).flags).toEqual([])
+  })
+})
+
+describe('suggestFlags', () => {
+  it('should suggest the declared flag a misspelling is closest to', async () => {
+    await expect(suggestFlags(findUnknownFlags(argsDef, ['--loglevel', '--jsn']))).resolves.toEqual([
+      { flag: '--loglevel', suggestion: '--logLevel' },
+      { flag: '--jsn', suggestion: '--json' },
+    ])
+  })
+
+  it('should not invent a suggestion for an unrelated flag', async () => {
+    await expect(suggestFlags(findUnknownFlags(argsDef, ['--xyzzy']))).resolves.toEqual([{ flag: '--xyzzy', suggestion: undefined }])
+  })
+})
+
+describe('declared command arguments', () => {
+  it('should never be reported as unknown', async () => {
+    const reported: Record<string, string[]> = {}
+
+    for (const name of Object.keys(commands)) {
+      for (const [commandName, def] of await resolveCommands(name)) {
+        const args = await resolveLazy((def as CommandDef<any>).args) ?? {}
+        const argv: string[] = []
+        for (const [flag, definition] of Object.entries(args as ArgsDef)) {
+          if ((definition as { type?: string }).type === 'positional') {
+            continue
+          }
+          argv.push(`--${flag}`)
+        }
+        const { flags } = findUnknownFlags({ ...cwdArgs, ...args }, argv)
+        if (flags.length > 0) {
+          reported[commandName] = flags
+        }
+      }
+    }
+
+    expect(reported).toEqual({})
+  })
+})
+
+async function resolveCommands(name: string): Promise<Array<[string, unknown]>> {
+  const def = await commands[name as keyof typeof commands]() as CommandDef<any>
+  const subCommands = await resolveLazy(def.subCommands)
+  if (!subCommands) {
+    return [[name, def]]
+  }
+  return Promise.all(Object.entries(subCommands).map(async ([subName, subDef]) => [`${name} ${subName}`, await resolveLazy(subDef)] as [string, unknown]))
+}
+
+function resolveLazy<T>(value: T | (() => T | Promise<T>) | undefined): Promise<T | undefined> {
+  return Promise.resolve(typeof value === 'function' ? (value as () => T | Promise<T>)() : value)
+}