diff --git a/internal/documentation/scripts/generateCliDoc.js b/internal/documentation/scripts/generateCliDoc.js
index e833dff57b7..84b48f9384d 100644
--- a/internal/documentation/scripts/generateCliDoc.js
+++ b/internal/documentation/scripts/generateCliDoc.js
@@ -1,219 +1,37 @@
-import {execSync as exec} from "node:child_process";
 import {readFileSync, writeFileSync} from "node:fs";
 import {fileURLToPath} from "node:url";
 import Handlebars from "handlebars";
+import {buildCliModel} from "./lib/cliModel.js";
 
 const source = readFileSync(fileURLToPath(new URL("./resources/CLI.template.md", import.meta.url)), "utf8");
 const template = Handlebars.compile(source);
 
-
-let first = true;
-const obj = {
-	common: "",
-	usage: "",
-	desc: "",
-	positionals: [],
-	commands: [],
-	commonOptions: [],
-	addOptions: [],
-	examples: [],
-};
-
-function execute(command) {
-	parseOutput(exec(command).toString());
-}
-
-function parseOutput(stdout) {
-	const sections = stdout.split("\n\n");
-	if (first) {
-		for (const section of sections) {
-			if (section.includes("Usage:")) {
-				obj.common = section;
-			}
-			if (section.includes("Options:")) {
-				obj.commonOptions = section.split("\n");
-			}
-			if (section.includes("Examples:")) {
-				obj.examples = section.split("\n");
-			}
-			if (section.includes("Commands:")) {
-				obj.commands = section.split("\n");
-			}
-		}
-		first = false;
-	} else {
-		if (sections[0].includes("local")) {
-			obj.usage = sections[1];
-			obj.desc = sections[2];
-		} else {
-			obj.usage = sections[0];
-			obj.desc = sections[1];
-		}
-
-		obj.commands = [];
-		obj.examples = [];
-		obj.positionals = [];
-		obj.addOptions = [];
-		for (const section of sections) {
-			if (section.includes("Positionals:")) {
-				obj.positionals = section.split("\n");
-			}
-			if (section.includes("Options:")) {
-				obj.addOptions = section.split("\n").filter(function(el) {
-					const array = obj.commonOptions;
-					array.forEach(function(item, index, array) {
-						array[index] = item.replace(/\s+/g, "");
-					});
-					return !array.includes(el.replace(/\s+/g, ""));
-				});
-			}
-			if (section.includes("Examples:")) {
-				obj.examples = section.split("\n");
-			}
-			if (section.includes("Commands:")) {
-				obj.commands = section.split("\n");
-			}
-		}
-	}
+const model = await buildCliModel();
+
+let content = template({
+	// The template renders the usage inside backticks; strip the "Usage:" label
+	common: model.common.split("Usage:").join(""),
+	commonOptions: model.commonOptions,
+	commonExamples: model.commonExamples,
+	commands: model.commands,
+});
+
+content = content
+	.split("&lt;").join("<")
+	.split("&gt;").join(">")
+	// Escape <option> as it's considered HTML tag to prevent rendering issues
+	.replaceAll("<option>", "&lt;option&gt;")
+	// Wrap standalone URLs in backticks to prevent VitePress from treating them as live links
+	// Only target URLs that are not already in markdown link syntax [text](url)
+	.replace(/(?<!\()(https?:\/\/[^\s)]+)(?!\))/g, "`$1`");
+content = content.split("&#x3D;").join("=");
+content = content.split("&#x60;").join("`");
+
+const outputPath = fileURLToPath(new URL("../docs/pages/CLI.md", import.meta.url));
+try {
+	writeFileSync(outputPath, content);
+} catch (err) {
+	console.error(`Failed to generate docs/pages/CLI.md: ${err.message}.`);
+	throw err;
 }
-
-function generateDoc() {
-	execute("ui5 --help");
-
-	const optionObj = [];
-	obj.commonOptions.shift();
-	for (const all of obj.commonOptions) {
-		const temp = checkChars(all);
-		const {command, description, details} = splitString(temp);
-		optionObj.push({commonOption: command, commonOptionDescription: description, commonOptionDetails: details});
-	}
-
-	obj.examples.shift();
-	const examplesObj = [];
-	for (const all of obj.examples) {
-		const temp = checkChars(all);
-		if (temp == "") {
-			continue;
-		}
-		const {command, description} = splitString(temp);
-		examplesObj.push({commonExample: command, commonExampleDescription: description});
-	}
-
-	obj.commands.shift();
-	const commandsArray = [];
-	const commands = obj.commands;
-	for (const all of commands) {
-		const command = all.trim().split(" ").slice(0, 2).join(" ");
-		execute(command + " --help");
-
-		const commandsObj = [];
-		obj.commands.shift();
-		if (!(obj.commands.length <= 1)) {
-			for (const all of obj.commands) {
-				const temp = checkChars(all);
-				const {command, description} = splitString(temp);
-				commandsObj.push({childCommand: command, commandDescription: description});
-			}
-		}
-
-		const positionalObj = [];
-		obj.positionals.shift();
-
-		if (!(obj.positionals.length < 1)) {
-			let index = 0;
-			for (const all of obj.positionals) {
-				const temp = checkChars(all);
-				const {command, description, details} = splitString(temp);
-				if (!(/\S/.test(command))) {
-					positionalObj[index - 1].positionalDescription =
-						positionalObj[index - 1].positionalDescription.concat("<br>", description);
-					positionalObj[index - 1].positionalDetails =details;
-					continue;
-				}
-				positionalObj.push({
-					positional: command,
-					positionalDescription: description,
-					positionalDetails: details
-				});
-				index++;
-			}
-		}
-		const optionObj = [];
-		obj.addOptions.shift();
-		if (!(obj.addOptions.length <= 1)) {
-			for (const all of obj.addOptions) {
-				const temp = checkChars(all);
-				const {command, description, details} = splitString(temp);
-				optionObj.push({option: command, optionDescription: description, optionDetails: details});
-			}
-		}
-
-		const exampleObj = [];
-		obj.examples.shift();
-		if (!(obj.examples.length <= 1)) {
-			for (const all of obj.examples) {
-				const temp = checkChars(all);
-				if (temp == "") {
-					continue;
-				}
-				const {command, description} = splitString(temp);
-				exampleObj.push({example: command, exampleDescription: description});
-			}
-		}
-
-		const commandObj = {
-			command: command,
-			description: obj.desc,
-			usage: obj.usage,
-			childCommands: commandsObj,
-			positionals: positionalObj,
-			options: optionObj,
-			examples: exampleObj
-		};
-		commandsArray.push(commandObj);
-	}
-	let content = template({
-		common: obj.common.split("Usage:").join(""),
-		commonOptions: optionObj,
-		commonExamples: examplesObj,
-		commands: commandsArray
-	});
-
-	content = content
-		.split("&lt;").join("<")
-		.split("&gt;").join(">")
-		// Escape <option> as it's considered HTML tag to prevent rendering issues
-		.replaceAll("<option>", "&lt;option&gt;")
-		// Wrap standalone URLs in backticks to prevent VitePress from treating them as live links
-		// Only target URLs that are not already in markdown link syntax [text](url)
-		.replace(/(?<!\()(https?:\/\/[^\s)]+)(?!\))/g, "`$1`");
-	content = content.split("&#x3D;").join("=");
-	try {
-		writeFileSync("./docs/pages/CLI.md", content);
-	} catch (err) {
-		console.error(`Failed to generate docs/pages/CLI.md: ${err.message}.`);
-		throw err;
-	}
-	console.log("Generated internal/documentation/docs/pages/CLI.md");
-}
-
-function splitString(temp) {
-	let details;
-
-	const match = temp.split("  ").filter((s) => s).map((s) => s.trim());
-	if (match.length && match[match.length - 1].startsWith("[") && match[match.length - 1].endsWith("]")) {
-		details = match.pop();
-	}
-	const description = match.pop() || "";
-	const command = match.pop() || "";
-
-	return {command, description, details};
-}
-
-function checkChars(all) {
-	let clean = all.split("|").join("\\|");
-	clean = clean.replace(/"\D+[di]\d{6,}/i, "\"~");
-	return clean;
-}
-
-generateDoc();
+console.log("Generated internal/documentation/docs/pages/CLI.md");
diff --git a/internal/documentation/scripts/lib/cliModel.js b/internal/documentation/scripts/lib/cliModel.js
new file mode 100644
index 00000000000..e0548382227
--- /dev/null
+++ b/internal/documentation/scripts/lib/cliModel.js
@@ -0,0 +1,294 @@
+/**
+ * Builds a structured documentation model for the UI5 CLI by introspecting the
+ * real yargs command definitions in-process — no subprocess execution and no
+ * help-text parsing.
+ *
+ * The CLI's command/base modules operate on whatever yargs instance is passed
+ * to them and never import yargs themselves, so we can construct the instance
+ * exactly like `packages/cli/lib/cli/cli.js` does (minus update-notifier and
+ * the final parse()) and read its metadata. yargs is loaded from the CLI
+ * package to match the exact version the CLI ships with.
+ */
+
+import {createRequire} from "node:module";
+import {pathToFileURL} from "node:url";
+import {readdirSync} from "node:fs";
+import {
+	optionDetails,
+	positionalDetails,
+	switchColumn,
+	plainDescription,
+	tableCellDescription,
+} from "./formatDetails.js";
+
+const CLI_LIB_URL = new URL("../../../../packages/cli/lib/cli/", import.meta.url);
+
+/**
+ * Loads yargs (from the CLI package), the CLI's base configuration and all
+ * command modules.
+ *
+ * @returns {Promise<{yargs: Function, base: Function, commandModules: object[]}>} The CLI building blocks
+ */
+async function loadCli() {
+	const cliRequire = createRequire(new URL("cli.js", CLI_LIB_URL));
+	const {default: yargs} = await import(pathToFileURL(cliRequire.resolve("yargs")).href);
+	const {default: base} = await import(new URL("base.js", CLI_LIB_URL).href);
+
+	const commandsDir = new URL("commands/", CLI_LIB_URL);
+	const commandModules = [];
+	for (const name of readdirSync(commandsDir).filter((entry) => entry.endsWith(".js"))) {
+		const {default: command} = await import(new URL(name, commandsDir).href);
+		commandModules.push(command);
+	}
+	return {yargs, base, commandModules};
+}
+
+/**
+ * Creates a fresh yargs instance configured like the real CLI (parser config
+ * and script name), without any commands or global options.
+ *
+ * @param {Function} yargs The yargs factory
+ * @returns {object} A configured yargs instance
+ */
+function makeInstance(yargs) {
+	const cli = yargs([]);
+	cli.parserConfiguration({"parse-numbers": false});
+	cli.scriptName("ui5");
+	return cli;
+}
+
+/**
+ * Returns the command handlers registered on a yargs instance, keyed by command name.
+ *
+ * @param {object} instance A yargs instance
+ * @returns {object} Command handlers keyed by name
+ */
+function getCommandHandlers(instance) {
+	return instance.getInternalMethods().getCommandInstance().getCommandHandlers();
+}
+
+/**
+ * Returns the descriptions map (option/positional keys to descriptions) of a yargs instance.
+ *
+ * @param {object} instance A yargs instance
+ * @returns {object} Descriptions keyed by option/positional name
+ */
+function getDescriptions(instance) {
+	return instance.getInternalMethods().getUsageInstance().getDescriptions();
+}
+
+/**
+ * Builds a map from a command's original command string to its aliases, as
+ * registered on the given (parent) yargs instance. Aliases are stored on the
+ * usage instance rather than on the command handler.
+ *
+ * @param {object} instance A yargs instance the commands are registered on
+ * @returns {object} Map of original command string to alias-name array
+ */
+function getAliasMap(instance) {
+	const aliasMap = {};
+	for (const [cmd, , , aliases] of instance.getInternalMethods().getUsageInstance().getCommands()) {
+		aliasMap[cmd] = aliases || [];
+	}
+	return aliasMap;
+}
+
+/**
+ * Applies a command handler's builder to a fresh yargs instance and captures
+ * any examples the builder registers (yargs offers no example getter).
+ *
+ * @param {Function} yargs The yargs factory
+ * @param {object} handler A yargs command handler
+ * @returns {{child: object, examples: Array<[string, string]>}} The child instance and captured examples
+ */
+function applyBuilder(yargs, handler) {
+	const child = makeInstance(yargs);
+	const examples = [];
+	child.example = (cmd, description) => {
+		examples.push([cmd, description || ""]);
+		return child; // preserve chaining
+	};
+	if (typeof handler.builder === "function") {
+		handler.builder(child);
+	}
+	return {child, examples};
+}
+
+/**
+ * Maps a captured [command, description] example pair to a template example object.
+ *
+ * @param {[string, string]} example The example pair
+ * @param {string} commandField The template field name for the command
+ * @param {string} descriptionField The template field name for the description
+ * @returns {object} The template example object
+ */
+function toExample([cmd, description], commandField, descriptionField) {
+	return {
+		[commandField]: cmd.split("$0").join("ui5"),
+		[descriptionField]: plainDescription(description),
+	};
+}
+
+/**
+ * Extracts the command-specific (or, for the root, common) options of a yargs
+ * instance as template option objects. Alias entries are collapsed into their
+ * primary option. The built-in "help"/"version" options are only included for
+ * the common options.
+ *
+ * @param {object} instance A yargs instance
+ * @param {boolean} includeHelpVersion Whether to include the built-in help/version options
+ * @param {Set<string>} [positionalNames] Positional names to exclude (yargs registers them as options too)
+ * @returns {object[]} Template option objects ({option, optionDescription, optionDetails})
+ */
+function extractOptions(instance, includeHelpVersion, positionalNames = new Set()) {
+	const opts = instance.getOptions();
+	const descriptions = getDescriptions(instance);
+	const demandedOptions = instance.getDemandedOptions();
+
+	const aliasKeys = new Set();
+	for (const key of Object.keys(opts.alias || {})) {
+		for (const alias of opts.alias[key]) {
+			aliasKeys.add(alias);
+		}
+	}
+
+	const options = [];
+	for (const key of Object.keys(opts.key || {})) {
+		if (aliasKeys.has(key)) {
+			continue; // alias of another option, already covered
+		}
+		if (positionalNames.has(key)) {
+			continue; // registered via .positional(), documented in the Positionals table
+		}
+		if ((opts.hiddenOptions || []).includes(key)) {
+			continue; // hidden option (e.g. deprecated), not shown in help
+		}
+		if ((key === "help" || key === "version") && !includeHelpVersion) {
+			continue; // documented once as a common option
+		}
+		options.push({
+			option: switchColumn(key, opts),
+			optionDescription: tableCellDescription(descriptions[key]),
+			optionDetails: optionDetails(key, opts, demandedOptions),
+		});
+	}
+	return options;
+}
+
+/**
+ * Extracts the positional arguments of a command from its handler metadata
+ * (demanded/optional arrays parsed from the command string), enriched with the
+ * command instance's descriptions, choices and types.
+ *
+ * @param {object} handler The command handler
+ * @param {object} opts The command instance's yargs options object
+ * @param {object} descriptions The command instance's descriptions map
+ * @returns {object[]} Template positional objects
+ */
+function extractPositionals(handler, opts, descriptions) {
+	const entries = [
+		...(handler.demanded || []).map((entry) => ({...entry, required: true})),
+		...(handler.optional || []).map((entry) => ({...entry, required: false})),
+	];
+
+	const positionals = [];
+	for (const entry of entries) {
+		const name = entry.cmd[0];
+		if (name.startsWith("-")) {
+			continue; // usage-hint literal (e.g. "[--development]"), not a real positional
+		}
+		positionals.push({
+			positional: name,
+			positionalDescription: tableCellDescription(descriptions[name]),
+			positionalDetails: positionalDetails({
+				variadic: entry.variadic,
+				required: entry.required,
+				name,
+				opts,
+			}),
+		});
+	}
+	return positionals;
+}
+
+/**
+ * Recursively walks a command node, producing one section per command (and
+ * per subcommand) and appending it to the accumulator.
+ *
+ * @param {Function} yargs The yargs factory
+ * @param {string} name The command name (key in the parent's handler map)
+ * @param {object} handler The command handler
+ * @param {string[]} parentTokens The command path of the parent (e.g. ["cache"])
+ * @param {string[]} aliases The command's alias names (e.g. ["ls", "list"])
+ * @param {object[]} sections The accumulator for produced sections
+ */
+function walkCommand(yargs, name, handler, parentTokens, aliases, sections) {
+	const tokens = [...parentTokens, name];
+	const {child, examples} = applyBuilder(yargs, handler);
+	const opts = child.getOptions();
+	const descriptions = getDescriptions(child);
+	const subHandlers = getCommandHandlers(child);
+	const subAliasMap = getAliasMap(child);
+
+	const positionals = extractPositionals(handler, opts, descriptions);
+	const positionalNames = new Set(positionals.map((positional) => positional.positional));
+
+	sections.push({
+		command: `ui5 ${tokens.join(" ")}`,
+		description: plainDescription(handler.description),
+		aliases: aliases.map((alias) => `\`ui5 ${[...parentTokens, alias].join(" ")}\``).join(", "),
+		usage: `ui5 ${[...parentTokens, handler.original].join(" ")}`,
+		childCommands: Object.entries(subHandlers).map(([, subHandler]) => ({
+			childCommand: `ui5 ${[...tokens, subHandler.original].join(" ")}`,
+			commandDescription: tableCellDescription(subHandler.description),
+		})),
+		options: extractOptions(child, false, positionalNames),
+		positionals,
+		examples: examples.map((example) => toExample(example, "example", "exampleDescription")),
+	});
+
+	for (const [subName, subHandler] of Object.entries(subHandlers)) {
+		walkCommand(yargs, subName, subHandler, tokens, subAliasMap[subHandler.original] || [], sections);
+	}
+}
+
+/**
+ * Builds the full documentation model for the CLI template.
+ *
+ * @returns {Promise<object>} The model ({common, commonOptions, commonExamples, commands})
+ */
+export async function buildCliModel() {
+	const {yargs, base, commandModules} = await loadCli();
+
+	const root = makeInstance(yargs);
+	const commonExamples = [];
+	root.example = (cmd, description) => {
+		commonExamples.push([cmd, description || ""]);
+		return root;
+	};
+	base(root);
+	for (const command of commandModules) {
+		root.command(command);
+	}
+
+	const usages = root.getInternalMethods().getUsageInstance().getUsage();
+	const common = usages.length ? usages[0][0] : "";
+
+	const rootAliasMap = getAliasMap(root);
+	const sections = [];
+	for (const [name, handler] of Object.entries(getCommandHandlers(root))) {
+		walkCommand(yargs, name, handler, [], rootAliasMap[handler.original] || [], sections);
+	}
+
+	return {
+		common,
+		commonOptions: extractOptions(root, true).map((option) => ({
+			commonOption: option.option,
+			commonOptionDescription: option.optionDescription,
+			commonOptionDetails: option.optionDetails,
+		})),
+		commonExamples: commonExamples.map(
+			(example) => toExample(example, "commonExample", "commonExampleDescription")),
+		commands: sections,
+	};
+}
diff --git a/internal/documentation/scripts/lib/formatDetails.js b/internal/documentation/scripts/lib/formatDetails.js
new file mode 100644
index 00000000000..e201da4f78d
--- /dev/null
+++ b/internal/documentation/scripts/lib/formatDetails.js
@@ -0,0 +1,188 @@
+/**
+ * Pure formatting helpers that reproduce yargs' help-detail rendering
+ * (type/required/choices/default columns and the switch column) from
+ * command metadata, without invoking yargs' own renderer.
+ *
+ * The logic mirrors yargs 18.x `lib/usage.js` so the generated documentation
+ * matches what users see on the command line.
+ */
+
+const Y18N_PREFIX = "__yargsString__:";
+
+/**
+ * Reproduces yargs' `stringifiedValues`: JSON.stringify each choice, joined by ", ".
+ *
+ * @param {any[]} values The choices
+ * @returns {string} The stringified, comma-separated choices
+ */
+export function stringifiedValues(values) {
+	return [].concat(values).map((value) => JSON.stringify(value)).join(", ");
+}
+
+/**
+ * Reproduces yargs' `defaultString`: renders the "[default: X]" tag or null.
+ *
+ * @param {any} value The default value
+ * @param {string} [defaultDescription] An explicit default description
+ * @returns {string|null} The "[default: ...]" tag, or null when there is no default
+ */
+export function defaultString(value, defaultDescription) {
+	if (value === undefined && !defaultDescription) {
+		return null;
+	}
+	let inner;
+	if (defaultDescription) {
+		inner = defaultDescription;
+	} else if (typeof value === "string") {
+		inner = `"${value}"`;
+	} else if (typeof value === "object") {
+		inner = JSON.stringify(value);
+	} else {
+		inner = String(value);
+	}
+	return `[default: ${inner}]`;
+}
+
+/**
+ * Determines the "[type]" tag for an option key based on the yargs options object.
+ *
+ * @param {string} key The option key
+ * @param {object} opts The yargs options object (from getOptions())
+ * @returns {string|null} The type tag, or null
+ */
+function optionTypeTag(key, opts) {
+	let type = null;
+	if ((opts.boolean || []).includes(key)) {
+		type = "[boolean]";
+	}
+	if ((opts.count || []).includes(key)) {
+		type = "[count]";
+	}
+	if ((opts.string || []).includes(key)) {
+		type = "[string]";
+	}
+	if ((opts.normalize || []).includes(key)) {
+		type = "[string]";
+	}
+	if ((opts.array || []).includes(key)) {
+		type = "[array]";
+	}
+	if ((opts.number || []).includes(key)) {
+		type = "[number]";
+	}
+	return type;
+}
+
+/**
+ * Builds the "Details" column for an option, in yargs' order:
+ * [deprecated] [type] [required] [choices: ...] [default: ...]
+ *
+ * @param {string} key The option key
+ * @param {object} opts The yargs options object (from getOptions())
+ * @param {object} demandedOptions Map of demanded (required) option keys
+ * @returns {string} The joined details string (may be empty)
+ */
+export function optionDetails(key, opts, demandedOptions) {
+	const deprecated = opts.deprecatedOptions || {};
+	const parts = [
+		key in deprecated ?
+			(typeof deprecated[key] === "string" ? `[deprecated: ${deprecated[key]}]` : "[deprecated]") :
+			null,
+		optionTypeTag(key, opts),
+		key in demandedOptions ? "[required]" : null,
+		opts.choices && opts.choices[key] ? `[choices: ${stringifiedValues(opts.choices[key])}]` : null,
+		defaultString((opts.default || {})[key], (opts.defaultDescription || {})[key]),
+	];
+	return parts.filter(Boolean).join(" ");
+}
+
+/**
+ * Builds the "Details" column for a positional argument. Type and default are
+ * derived from the command-string metadata since yargs only populates these at
+ * parse time: variadic positionals ("name..") become arrays defaulting to [].
+ *
+ * @param {object} params The positional metadata
+ * @param {boolean} params.variadic Whether the positional is variadic ("..")
+ * @param {boolean} params.required Whether the positional is required ("<>")
+ * @param {string} params.name The positional name
+ * @param {object} params.opts The yargs options object of the command instance
+ * @returns {string} The joined details string (may be empty)
+ */
+export function positionalDetails({variadic, required, name, opts}) {
+	let type = null;
+	if (variadic) {
+		type = "[array]";
+	} else if ((opts.string || []).includes(name)) {
+		type = "[string]";
+	} else if ((opts.number || []).includes(name)) {
+		type = "[number]";
+	} else if ((opts.boolean || []).includes(name)) {
+		type = "[boolean]";
+	}
+
+	const explicitDefault = (opts.default || {})[name];
+	let def;
+	if (variadic && explicitDefault === undefined) {
+		def = "[default: []]";
+	} else {
+		def = defaultString(explicitDefault, (opts.defaultDescription || {})[name]);
+	}
+
+	const parts = [
+		type,
+		required ? "[required]" : null,
+		opts.choices && opts.choices[name] ? `[choices: ${stringifiedValues(opts.choices[name])}]` : null,
+		def,
+	];
+	return parts.filter(Boolean).join(" ");
+}
+
+/**
+ * Reproduces yargs' switch column for an option: prefixes each of the option's
+ * key and aliases ("-x" for single-char, "--xx" otherwise) and sorts short
+ * switches before long ones (stable), joined by ", ".
+ *
+ * @param {string} key The option key
+ * @param {object} opts The yargs options object (from getOptions())
+ * @returns {string} The switch column (e.g. "-D, --development, --dev")
+ */
+export function switchColumn(key, opts) {
+	const isBoolean = (opts.boolean || []).includes(key);
+	const switches = [key].concat((opts.alias || {})[key] || []).map((sw) => {
+		const prefix = /^[0-9]$/.test(sw) ?
+			(isBoolean ? "-" : "--") :
+			sw.length > 1 ? "--" : "-";
+		return prefix + sw;
+	});
+	// Array.prototype.sort is stable: keep declaration order within short/long groups
+	switches.sort((sw1, sw2) => {
+		const long1 = /^--/.test(sw1);
+		const long2 = /^--/.test(sw2);
+		return long1 === long2 ? 0 : long1 ? 1 : -1;
+	});
+	return switches.join(", ");
+}
+
+/**
+ * Strips the yargs i18n-deferral prefix from a description.
+ *
+ * @param {string} desc The raw description
+ * @returns {string} The description without the deferral prefix
+ */
+export function plainDescription(desc) {
+	if (!desc) {
+		return "";
+	}
+	return desc.startsWith(Y18N_PREFIX) ? desc.substring(Y18N_PREFIX.length) : desc;
+}
+
+/**
+ * Prepares a description for use inside a Markdown table cell: strips the
+ * deferral prefix and replaces newlines with "<br>" so table rows stay intact.
+ *
+ * @param {string} desc The raw description
+ * @returns {string} The table-cell-safe description
+ */
+export function tableCellDescription(desc) {
+	return plainDescription(desc).replace(/\r?\n/g, "<br>");
+}
diff --git a/internal/documentation/scripts/resources/CLI.template.md b/internal/documentation/scripts/resources/CLI.template.md
index 19a4f06ff9c..7b7f281c9c3 100644
--- a/internal/documentation/scripts/resources/CLI.template.md
+++ b/internal/documentation/scripts/resources/CLI.template.md
@@ -50,6 +50,10 @@ These options you can use with each command.
 
 {{description}}
 
+{{#if aliases}}
+**Aliases**: {{aliases}}
+
+{{/if}}
 **Usage**
 
 `