revert: drop cross-surface rotate compatibility, keep the lean rename

The rotate->orientation change is a bug fix (name collision with the
`gesture rotate` two-finger gesture), not a compatibility feature. The
cross-surface command-data compatibility added disproportionate weight
(~480 B, dominated by the alias module inlined into the batch bundle) for a
command that was only canonical for two minor versions, so shipped batch/
replay/MCP data carrying `rotate` is a rare, documentable break.

Removed:
- daemon request-boundary command normalization (`request-router.ts`)
- batch step alias resolution (`batch-policy.ts`, `cli/batch-steps.ts`)
- MCP tool-runner alias/legacy-result handling (`mcp/command-tools.ts`)
- the `command-aliases.ts` module rename and cross-surface machinery
  (reverted to `cli-command-aliases.ts`)
- the cross-surface tests

Kept (cheap, high value — prevents build breaks for typed consumers):
- CLI `rotate` alias (one line, same mechanism as `tap`/`launch`)
- deprecated `RotateCommand*` / `SystemRotate*` type aliases and the
  `client.command.rotate` / `device.system.rotate` wrappers that delegate to
  `orientation` and restore the legacy response contract

Net bundle vs main is now +473 B (was +952 B), almost all the kept SDK
wrappers plus the unavoidable longer command name.

Author: thymikee

src/__tests__/batch-command-alias.test.ts

@@ -1,6 +1,5 @@
 import { deriveStructuredBatchCommandNames } from './core/command-descriptor/derive.ts';
 import { commandDescriptors } from './core/command-descriptor/registry.ts';
-import { normalizeCrossSurfaceCommandAlias } from './command-aliases.ts';
 import { AppError } from './kernel/errors.ts';
 
 /**
@@ -58,11 +57,7 @@ function isStructuredBatchCommandName(command: string): command is StructuredBat
 }
 
 export function normalizeBatchCommandName(command: unknown): string {
-  // Resolve command-name aliases (e.g. `rotate` -> `orientation`) from the shared
-  // map so structured batch data carrying a renamed command validates and runs
-  // against the canonical descriptor instead of failing as unavailable.
-  const raw = typeof command === 'string' ? command.trim().toLowerCase() : '';
-  return raw ? normalizeCrossSurfaceCommandAlias(raw) : '';
+  return typeof command === 'string' ? command.trim().toLowerCase() : '';
 }
 
 export function readStructuredBatchCommandName(

src/batch-policy.ts

@@ -0,0 +1,38 @@
+import type { CliFlags } from './commands/cli-grammar/flag-types.ts';
+
+type BooleanCliFlagKey = {
+  [Key in keyof CliFlags]-?: Exclude<CliFlags[Key], undefined> extends boolean ? Key : never;
+}[keyof CliFlags];
+
+export type CliCommandAlias = {
+  alias: string;
+  command: string;
+  impliedFlags?: readonly BooleanCliFlagKey[];
+};
+
+const CLI_COMMAND_ALIASES: readonly CliCommandAlias[] = [
+  { alias: 'long-press', command: 'longpress' },
+  { alias: 'metrics', command: 'perf' },
+  { alias: 'tap', command: 'press' },
+  { alias: 'launch', command: 'open' },
+  { alias: 'relaunch', command: 'open', impliedFlags: ['relaunch'] },
+  // Deprecated: `rotate` was renamed to `orientation` (it collided with the
+  // `gesture rotate` two-finger gesture). Kept working at the CLI for a few versions.
+  { alias: 'rotate', command: 'orientation' },
+];
+
+const aliasByToken: ReadonlyMap<string, CliCommandAlias> = new Map(
+  CLI_COMMAND_ALIASES.map((entry) => [entry.alias, entry]),
+);
+
+export function normalizeCliCommandAlias(command: string): string {
+  return aliasByToken.get(command.toLowerCase())?.command ?? command;
+}
+
+export function cliCommandAlias(rawCommand: string): CliCommandAlias | undefined {
+  return aliasByToken.get(rawCommand.toLowerCase());
+}
+
+export function cliAliasesForCommand(command: string): CliCommandAlias[] {
+  return CLI_COMMAND_ALIASES.filter((entry) => entry.command === command);
+}

src/cli-command-aliases.ts

@@ -3,7 +3,6 @@ import { type SessionRuntimeHints } from '../kernel/contracts.ts';
 import { parseBatchStepRuntime } from '../batch-contract.ts';
 import { readInputFromCli } from '../commands/cli-grammar.ts';
 import { isCommandName, type CommandName } from '../commands/command-metadata.ts';
-import { normalizeCrossSurfaceCommandAlias } from '../command-aliases.ts';
 import type { CliFlags } from '../commands/cli-grammar/flag-types.ts';
 import { AppError } from '../kernel/errors.ts';
 import { isRecord } from '../utils/parsing.ts';
@@ -69,8 +68,6 @@ function readStructuredBatchStep(
   const { runtime: _runtime, ...rest } = step;
   return {
     ...rest,
-    // Resolve command-name aliases (e.g. `rotate` -> `orientation`) from the shared map.
-    command: normalizeCrossSurfaceCommandAlias(rest.command),
     ...(runtime === undefined ? {} : { runtime }),
   };
 }
@@ -93,10 +90,8 @@ function readLegacyCliBatchStep(step: unknown, stepNumber: number): LegacyCliBat
 }
 
 function readLegacyCommand(value: unknown, stepNumber: number): CommandName {
-  const raw = typeof value === 'string' ? value.trim().toLowerCase() : '';
-  if (!raw) throw new AppError('INVALID_ARGS', `Batch step ${stepNumber} requires command.`);
-  // Resolve command-name aliases (e.g. `rotate` -> `orientation`) from the shared map.
-  const command = normalizeCrossSurfaceCommandAlias(raw);
+  const command = typeof value === 'string' ? value.trim().toLowerCase() : '';
+  if (!command) throw new AppError('INVALID_ARGS', `Batch step ${stepNumber} requires command.`);
   if (isCommandName(command)) return command;
   throw new AppError(
     'INVALID_ARGS',

src/cli/batch-steps.ts

@@ -11,7 +11,7 @@ import {
 } from '../../cli-schema/command-schema.ts';
 import { isFlagSupportedForCommand } from '../../cli-schema/option-schema.ts';
 import { isKnownCliCommandName } from '../../command-catalog.ts';
-import { commandAlias, normalizeCommandAlias } from '../../command-aliases.ts';
+import { cliCommandAlias, normalizeCliCommandAlias } from '../../cli-command-aliases.ts';
 import { formatUnknownFlagMessage, suggestCommandFor } from './command-suggestions.ts';
 
 type ParsedArgs = {
@@ -118,7 +118,7 @@ export function parseRawArgs(argv: string[]): RawParsedArgs {
 
 function applyAliasImpliedFlags(rawCommand: string | null, flags: CliFlags): void {
   if (!rawCommand) return;
-  for (const key of commandAlias(rawCommand)?.impliedFlags ?? []) {
+  for (const key of cliCommandAlias(rawCommand)?.impliedFlags ?? []) {
     flags[key] = true;
   }
 }
@@ -382,3 +382,7 @@ export async function usageForCommand(command: string): Promise<string | null> {
   const { buildCommandUsageText } = await import('./cli-help.ts');
   return buildCommandUsageText(normalizeCommandAlias(command));
 }
+
+function normalizeCommandAlias(command: string): string {
+  return normalizeCliCommandAlias(command);
+}

src/cli/parser/args.ts

@@ -1,5 +1,5 @@
 import { listCliCommandNames } from '../command-catalog.ts';
-import { aliasesForCommand, normalizeCommandAlias } from '../command-aliases.ts';
+import { cliAliasesForCommand, normalizeCliCommandAlias } from '../cli-command-aliases.ts';
 import { buildCommandUsage } from '../cli-schema/usage.ts';
 import type { DaemonCommandRoute } from '../daemon/daemon-command-registry.ts';
 import { commandDescriptors, type Command } from '../core/command-descriptor/registry.ts';
@@ -165,13 +165,13 @@ export function formatCommandExplanation(
 }
 
 function resolveDescriptor(query: string): CommandDescriptor | undefined {
-  const direct = descriptorByName.get(normalizeCommandAlias(query));
+  const direct = descriptorByName.get(normalizeCliCommandAlias(query));
   if (direct) return direct;
   return commandDescriptors.find((descriptor) => readCatalogKey(descriptor) === query);
 }
 
 function describeCliAliases(command: string): CommandAliasExplanation[] {
-  return aliasesForCommand(command).map((entry) => ({
+  return cliAliasesForCommand(command).map((entry) => ({
     alias: entry.alias,
     ...(entry.impliedFlags && entry.impliedFlags.length > 0
       ? { impliedFlags: [...entry.impliedFlags] }
@@ -240,7 +240,7 @@ function suggestCommands(query: string): string[] {
   const candidates = commandDescriptors.flatMap((descriptor) => [
     descriptor.name,
     readCatalogKey(descriptor),
-    ...aliasesForCommand(descriptor.name).map((alias) => alias.alias),
+    ...cliAliasesForCommand(descriptor.name).map((alias) => alias.alias),
   ]);
   return [...new Set(candidates)]
     .map((candidate) => ({ candidate, distance: levenshtein(query, candidate) }))