@jiayunxie/aerial 0.2.5 → 0.2.7

package/README.md

@@ -53,6 +53,8 @@ During setup, Aerial reads your Copilot model list, shows the models that work f
 aerial service install
 ```
 
+On Windows, run this command from an Administrator PowerShell or Command Prompt. Aerial registers its background service with Task Scheduler, and Windows requires elevation for that registration step.
+
 4. Check everything from one place:
 
 ```bash
@@ -91,10 +93,12 @@ aerial setup claude
 To skip the prompts:
 
 ```bash
-aerial setup codex --model <responses-model-id> --effort <low|medium|high|xhigh|max>
+aerial setup codex --model <responses-model-id> --effort <minimal|low|medium|high|xhigh|max|ultra>
 aerial setup claude --model <messages-model-id> --effort <low|medium|high|xhigh|max>
 ```
 
+Codex effort is model-aware. Aerial preserves an effort when the selected Copilot model advertises it and otherwise selects the nearest usable effort, preferring the highest level below the request. Codex `minimal` maps to Copilot `none`; `none` is also accepted as an input alias. Claude Code keeps its own effort semantics, where `max` is an alias for `xhigh`.
+
 To inspect the full model matrix:
 
 ```bash
@@ -120,9 +124,9 @@ Advanced override: `AERIAL_UPSTREAM_PROXY` can be set to a bare `http://`, `http
 ```bash
 aerial status           # setup, login, service, and health summary
 aerial proxy status     # upstream proxy mode, egress, and route visibility
-aerial service install  # install and start the background service
+aerial service install  # install and start the background service (Windows: Administrator terminal required)
 aerial doctor           # local diagnostics
-aerial disable          # restore client configs and uninstall the service
+aerial teardown          # restore client configs and uninstall the service
 ```
 
 `aerial start` is for foreground debugging in the current terminal. Most users should use `aerial service install`.
@@ -136,12 +140,12 @@ Advanced service lifecycle commands are documented in `docs/usage.md`.
 - No models listed during setup: run `aerial login` first, then retry setup.
 - Claude models or the `messages` route are missing: run `aerial proxy enable`, then `aerial probe`.
 - Port conflict on `18181`: run `aerial status` to see whether another process is using the port.
-- Need to undo setup: run `aerial disable`, or restore one client with `aerial setup restore <codex|claude> --latest`.
+- Need to undo setup: run `aerial teardown`, or restore one client with `aerial setup restore <codex|claude> --latest`.
 
 ## Notes
 
 - macOS background service support uses a user LaunchAgent.
-- Windows background service support uses a user Task Scheduler task.
+- Windows background service support uses a user Task Scheduler task. Run `aerial service install` from an Administrator terminal to register it.
 - Linux service management is not built in yet; run `aerial start` or use your own init system.
 - Copilot inference routes are an observed compatibility target and may change upstream.
 

package/docs/usage.md

@@ -67,6 +67,8 @@ aerial service install
 
 Default URL: `http://127.0.0.1:18181`. `aerial service install` is the daily-use path on macOS and Windows because it installs and starts the local background service. Use `aerial start` only when you want a foreground debug process in the current terminal.
 
+On Windows, run `aerial service install` from an Administrator PowerShell or Command Prompt. Aerial registers the background service with Task Scheduler, and Windows requires elevation for that registration step.
+
 ## 5. Configure Codex CLI
 
 ```bash
@@ -91,7 +93,7 @@ The local key is generated and stored by Aerial automatically. Users do not need
 
 For a dry inspection without touching your real config, set `HOME`/`USERPROFILE` to a temporary directory before running this command.
 
-To skip the prompts, pass `--model <responses-model-id>` and/or `--effort <low|medium|high|xhigh|max>` (`max` is an alias for `xhigh`). The chosen effort is written into the `[profiles.aerial]` block as `model_reasoning_effort = "<effort>"` and is also persisted as Aerial-wide `defaultEffort` in `~/.aerial/config.json`. Under non-TTY (CI/pipes) the wizard does not prompt and falls back to the default effort `medium`.
+To skip the prompts, pass `--model <responses-model-id>` and/or `--effort <minimal|low|medium|high|xhigh|max|ultra>`. `none` is accepted as an alias for Codex `minimal`. Aerial resolves the request against the selected model's live Copilot capabilities: supported values are preserved, while unsupported values fall back to the nearest usable level (`ultra` currently becomes `max` on GPT-5.6 models, and `minimal` is sent as Copilot `none`). The resolved Codex value is written as root-level `model_reasoning_effort = "<effort>"`. Codex setup does not change Aerial `defaultEffort`, which remains the Claude proxy fallback. Under non-TTY (CI/pipes) the wizard does not prompt and falls back to `medium` when the selected model supports it.
 
 ## 6. Configure Claude Code
 
@@ -171,7 +173,7 @@ Use `responses` models for Codex, `messages` models for Claude Code, and `chat`
 ```bash
 aerial setup status [--json]
 aerial setup restore <codex|claude|all> --latest
-aerial disable
+aerial teardown
 ```
 
 `aerial setup status` reports whether each supported client is currently configured to route through Aerial, plus the local API key and GitHub token files. The state for each client is one of:
@@ -221,7 +223,7 @@ Stability rules for `aerial.setup-status.v1`: new fields may be added at any lev
 
 `aerial setup restore <codex|claude|all> --latest` restores the most recent `*.aerial-backup-<ISO>` snapshot for the named client. Before overwriting, it takes a `*.aerial-pre-restore-<ISO>` snapshot of the current file so the restore itself is reversible. With `all`, both clients are restored best-effort and the command exits non-zero if any individual restore failed. If there is no backup to restore, the command prints a note and exits 0.
 
-`aerial disable` first runs `setup restore all --latest` and then, only if every client restore succeeded, uninstalls the local Aerial service via `aerial service uninstall`. If any client restore reports a failure, the service is left running and `aerial disable` exits non-zero; resolve the restore errors, then rerun `aerial disable` (or call `aerial service uninstall` directly once the client config is in the state you want).
+`aerial teardown` first runs `setup restore all --latest` and then, only if every client restore succeeded, uninstalls the local Aerial service via `aerial service uninstall`. If any client restore reports a failure, the service is left running and `aerial teardown` exits non-zero; resolve the restore errors, then rerun `aerial teardown` (or call `aerial service uninstall` directly once the client config is in the state you want).
 
 ## 7.6 Run Aerial As A Local Service
 
@@ -237,7 +239,7 @@ aerial service uninstall
 Aerial ships a thin platform wrapper around the user-mode service primitives provided by the host OS — there is no Aerial-specific daemon. Two platforms are supported:
 
 - macOS: a user-level launchd `LaunchAgent` at `~/Library/LaunchAgents/com.jiayunxie.aerial.plist` invokes a generated POSIX shell wrapper at `<config-dir>/bin/aerial-service.sh`. The plist is regenerated on every `aerial service install` with a `<!-- Generated by aerial; do not edit -->` header, `KeepAlive = { SuccessfulExit = false; Crashed = true }` so the agent only restarts on crash (not on a clean exit), `ThrottleInterval = 10` to cap restart cadence, and no `StandardOutPath`/`StandardErrorPath` keys (the wrapper owns stdio redirection so launchd does not hold a write fd that would race with rotation). The launchctl command path is `gui/<uid>` (per-user agent, no privilege escalation). Start/stop go through `launchctl bootstrap` and `launchctl bootout` against that domain — never `launchctl kill`.
-- Windows: a Task Scheduler task named `AerialLocalProxy`, `/SC ONLOGON /RL LIMITED`, executes a PowerShell wrapper at `<config-dir>\bin\aerial-service.ps1` (default `%APPDATA%\aerial\bin\aerial-service.ps1`). The wrapper is regenerated on every `aerial service install`. The `/TR` argument quotes the wrapper path with normal double quotes so paths that contain spaces or non-ASCII characters work without manual quoting.
+- Windows: a Task Scheduler task named `AerialLocalProxy`, `/SC ONLOGON /RL LIMITED`, executes a PowerShell wrapper at `<config-dir>\bin\aerial-service.ps1` (default `%APPDATA%\aerial\bin\aerial-service.ps1`). The wrapper is regenerated on every `aerial service install`. Run `aerial service install` from an Administrator PowerShell or Command Prompt so Windows allows Aerial to register or refresh the scheduled task. The task itself still runs at user logon with `/RL LIMITED`. The `/TR` argument quotes the wrapper path with normal double quotes so paths that contain spaces or non-ASCII characters work without manual quoting.
 - Linux: not implemented in this release. `aerial service install|start|stop|restart|uninstall` throws an unsupported-platform error and exits 1; `aerial service status --json` still emits a schema-valid document with `"supported": false` and exits 1. Run `aerial start` directly or wrap it in your own init system.
 
 Both wrappers do the same three things before exec-ing the proxy: (1) startup-rotate the captured stdio log (`aerial-stdio.log` → `.1` → `.2` → `.3`) if it has grown beyond the configured cap; (2) export `AERIAL_LOG_FILE=<config-dir>/logs/aerial.log`, plus `AERIAL_LOG_MAX_BYTES` and `AERIAL_LOG_BACKUPS` (default `5242880` / `3`, or whatever value was present in the installer's environment — see below), and — when `AERIAL_CONFIG_DIR` was set at install time — re-export `AERIAL_CONFIG_DIR` so the service sees the same config root as the installer; (3) `exec` `node src/cli/index.js start --host <host> --port <port>` with stdout and stderr appended to `aerial-stdio.log`. By default, the service wrapper uses the same Node.js binary that ran `aerial service install`. Set `AERIAL_SERVICE_NODE` before `aerial service install` to override this explicitly, for example when installing from one Node binary but running the service with another. The structured event log is opt-in via `AERIAL_LOG_FILE`: when this env var is set (always set by the wrapper, never by foreground `aerial start`), structured events go to that file only; when unset, they go to stderr only. There is no double-write.
@@ -252,7 +254,7 @@ Wrapper env values are baked in at install time. If you set `AERIAL_LOG_MAX_BYTE
 4. If the port answers as Aerial AND the local service manager does NOT report the unit/task loaded → the definition is regenerated, but the service is NOT started. Exit 1 with `reason=foreground_running`, `definitionUpdated=true`, and an actionable next step: stop the foreground process, then run `aerial service start`. This guarantees `install` never causes two Aerial instances to fight for the port.
 5. Otherwise (port absent) → write the definition, then start the service (`launchctl bootstrap` on macOS, `schtasks /Run` on Windows). Exit 0.
 
-`aerial service start` enforces a similar shape: it refuses with `reason=not_installed` and exit 1 if the unit/task does not exist; it refuses with `reason=port_conflict` and exit 1 if a non-Aerial process owns the port; it refuses with `reason=foreground_running` and exit 1 if Aerial is already running in the foreground (not via the service manager); it returns idempotent success with `note=already running (service-managed)` if the service is already up; otherwise it starts the service. `aerial service stop` is idempotent (exit 0 + `note` when nothing is installed or nothing is running). `aerial service uninstall` is idempotent on the "no service installed" branch, but does NOT swallow real teardown failures: on macOS, if the service is loaded and `launchctl bootout` returns non-zero, the plist and wrapper are preserved and the command exits 1 with `reason=bootout_failed`; on Windows, if `schtasks /Delete` returns non-zero, the wrapper is preserved and the command exits 1 with `reason=delete_failed`. In both cases the message includes a retry pointer. `aerial service restart` blocks the start step when the stop step fails: if `stop` returns `ok=false`, the response includes `reason=stop_failed` and `start` is not attempted. `aerial disable` follows the same contract: it restores client configs first, then calls `serviceUninstall`. Only an `unsupported platform` exception is treated as a silent skip (Linux); any supported-platform uninstall failure (`ok=false` or non-`unsupported-platform` throw) propagates as exit 1 with a retry pointer at `aerial service uninstall`.
+`aerial service start` enforces a similar shape: it refuses with `reason=not_installed` and exit 1 if the unit/task does not exist; it refuses with `reason=port_conflict` and exit 1 if a non-Aerial process owns the port; it refuses with `reason=foreground_running` and exit 1 if Aerial is already running in the foreground (not via the service manager); it returns idempotent success with `note=already running (service-managed)` if the service is already up; otherwise it starts the service. `aerial service stop` is idempotent (exit 0 + `note` when nothing is installed or nothing is running). `aerial service uninstall` is idempotent on the "no service installed" branch, but does NOT swallow real teardown failures: on macOS, if the service is loaded and `launchctl bootout` returns non-zero, the plist and wrapper are preserved and the command exits 1 with `reason=bootout_failed`; on Windows, if `schtasks /Delete` returns non-zero, the wrapper is preserved and the command exits 1 with `reason=delete_failed`. In both cases the message includes a retry pointer. `aerial service restart` blocks the start step when the stop step fails: if `stop` returns `ok=false`, the response includes `reason=stop_failed` and `start` is not attempted. `aerial teardown` follows the same contract: it restores client configs first, then calls `serviceUninstall`. Only an `unsupported platform` exception is treated as a silent skip (Linux); any supported-platform uninstall failure (`ok=false` or non-`unsupported-platform` throw) propagates as exit 1 with a retry pointer at `aerial service uninstall`.
 
 If GitHub login is not yet configured, install and start still succeed (when reachable) and emit a structured warning pointing at `aerial login`; inference proxy requests return 503 until you log in, while `GET /v1/models` returns 401 with `error.aerial.status = "login_required"`. After rotating the local API key or moving the config directory, restart the service with `aerial service restart` so the new credentials are picked up.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jiayunxie/aerial",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "Local GitHub Copilot proxy for Codex CLI and Claude Code with smart HTTP(S)/SOCKS5 upstream proxy support.",
   "type": "module",
   "private": false,
@@ -47,6 +47,6 @@
   "dependencies": {
     "smol-toml": "^1.6.1",
     "socks": "^2.8.9",
-    "undici": "^7.25.0"
+    "undici": "^7.28.0"
   }
 }

package/src/cli/commands/config.js

@@ -1,7 +1,7 @@
 import { defaultConfig, loadConfig, saveConfig } from "../../shared/config.js";
 import { configPath } from "../../shared/paths.js";
 import { assertValidEffort } from "../../shared/effort.js";
-import { parseConfigHost, parseConfigPort } from "../args.js";
+import { parseConfigHost, parseConfigPort } from "../helpers.js";
 
 export function runConfigCli(subcommand, rest) {
   if (subcommand === "reset") {

package/src/cli/commands/setup.js

@@ -1,15 +1,24 @@
 import { loadConfig } from "../../shared/config.js";
 import { configPath } from "../../shared/paths.js";
 import { restoreAllClients, restoreClient, setupClaude, setupCodex, setupStatus } from "../../setup/index.js";
-import { chooseSetupModel, formatModelChoices } from "../model-selection.js";
-import { assertValidEffort, chooseSetupEffort, formatEffortSelection } from "../setup-selection.js";
-import { requiredArgValue } from "../args.js";
-import { claudeApiKeyHelper, codexAuthCommand } from "../runtime-auth.js";
+import {
+  assertValidCodexEffort,
+  assertValidEffort,
+  chooseSetupEffort,
+  chooseSetupModel,
+  discoverModelsForRoute,
+  formatEffortSelection,
+  formatModelChoices
+} from "../select.js";
+import { requiredArgValue, claudeApiKeyHelper, codexAuthCommand } from "../helpers.js";
 import { printRestoreResults, printSetupCompletionSummary } from "../output.js";
 
 async function selectSetupOptions(target, route, args) {
   const explicitEffort = requiredArgValue(args, "--effort");
-  if (explicitEffort !== undefined) assertValidEffort(explicitEffort);
+  if (explicitEffort !== undefined) {
+    if (target === "Codex") assertValidCodexEffort(explicitEffort);
+    else assertValidEffort(explicitEffort);
+  }
   const selected = await chooseSetupModel({ target, route, explicitModel: requiredArgValue(args, "--model") });
   if (!selected.displayed) {
     for (const line of formatModelChoices({ target, route, choices: selected.choices, selectedModel: selected.model, source: selected.source, recommended: selected.recommended })) {
@@ -18,8 +27,26 @@ async function selectSetupOptions(target, route, args) {
   } else {
     console.log(`Selected ${target} model: ${selected.model}`);
   }
-  const effortChoice = await chooseSetupEffort({ target, explicitEffort });
-  console.log(formatEffortSelection({ target, effort: effortChoice.effort, source: effortChoice.source }));
+  let selectedModel = selected.choices.find((choice) => choice.id === selected.model);
+  if (!selectedModel && selected.source === "explicit") {
+    try {
+      selectedModel = (await discoverModelsForRoute(route)).find((choice) => choice.id === selected.model);
+    } catch {
+      selectedModel = undefined;
+    }
+  }
+  const effortChoice = await chooseSetupEffort({
+    target,
+    explicitEffort,
+    model: selected.model,
+    supportedEfforts: selectedModel?.supportedEfforts
+  });
+  console.log(formatEffortSelection({
+    target,
+    effort: effortChoice.effort,
+    source: effortChoice.source,
+    supportedEfforts: effortChoice.supportedEfforts
+  }));
   return {
     model: selected.model,
     effort: effortChoice.effort,
@@ -45,6 +72,7 @@ function printSetupStatus(status) {
     console.log(`${head}${effortText}  file=${cs.file}`);
     if (cs.backups.length) console.log(`         backups=${cs.backups.length}`);
     if (cs.error) console.log(`         error=${cs.error}`);
+    if (cs.migration) console.log(`         migration=${cs.migration}`);
   }
 }
 
@@ -64,7 +92,10 @@ export async function runSetupCli(subcommand, rest) {
       aerialDefaultEffort: config.defaultEffort || "missing",
       backup: result.backup,
       auth: "command-backed local Aerial key",
-      notes: ["restart Codex if it was already running so it reloads the profile."]
+      notes: [
+        "Aerial defaultEffort is the Claude proxy fallback and was left unchanged.",
+        "restart Codex if it was already running so it reloads the profile."
+      ]
     });
     return;
   }

package/src/cli/commands/start.js

@@ -1,6 +1,6 @@
 import { ensureApiKey, loadConfig } from "../../shared/config.js";
 import { startServer } from "../../proxy/server.js";
-import { argValue } from "../args.js";
+import { argValue } from "../helpers.js";
 
 export function runStartCli(args) {
   const config = loadConfig();

package/src/cli/commands/status.js

@@ -1,6 +1,6 @@
 import { setupStatus } from "../../setup/index.js";
 import { serviceStatus } from "../../service/index.js";
-import { computeAppStatus } from "../app-status.js";
+import { computeAppStatus } from "../helpers.js";
 import { printServiceSummary, printSetupSummary } from "../output.js";
 
 export async function appStatus({ json = false } = {}) {

package/src/cli/commands/{disable.js → teardown.js}

@@ -3,11 +3,11 @@ import { serviceUninstall } from "../../service/index.js";
 import { printRestoreResults } from "../output.js";
 import { printServiceUninstallResult } from "./service.js";
 
-export function runDisableCli() {
+export function runTeardownCli() {
   const { ok: restoreOk, results } = restoreAllClients();
   printRestoreResults(results);
   if (!restoreOk) {
-    console.log("service uninstall: skipped because client restore reported failures; resolve restore errors then rerun `aerial disable` or `aerial service uninstall`.");
+    console.log("service uninstall: skipped because client restore reported failures; resolve restore errors then rerun `aerial teardown` or `aerial service uninstall`.");
     process.exitCode = 1;
     return;
   }

package/src/cli/doctor.js

@@ -1,6 +1,6 @@
 import { setupStatus } from "../setup/index.js";
 import { serviceStatus } from "../service/index.js";
-import { computeAppStatus } from "./app-status.js";
+import { computeAppStatus } from "./helpers.js";
 import { readConfigFileStatus } from "../shared/config.js";
 
 const REPAIRS = Object.freeze({

package/src/cli/helpers.js

@@ -0,0 +1,92 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PACKAGE_JSON_URL = new URL("../../package.json", import.meta.url);
+const CLI_ENTRY = path.join(path.dirname(fileURLToPath(import.meta.url)), "index.js");
+
+export function readPackageVersion(packageJsonUrl = PACKAGE_JSON_URL) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(packageJsonUrl, "utf8"));
+    if (typeof pkg.version === "string" && pkg.version.length > 0) return pkg.version;
+    throw new Error("missing version field");
+  } catch (error) {
+    const reason = error?.message || String(error);
+    console.warn(`aerial: cannot read package version (${reason}); reporting "unknown"`);
+    return "unknown";
+  }
+}
+
+export function printVersion(packageJsonUrl = PACKAGE_JSON_URL) {
+  console.log(readPackageVersion(packageJsonUrl));
+}
+
+export function argValue(args, name) {
+  const index = args.indexOf(name);
+  return index >= 0 ? args[index + 1] : undefined;
+}
+
+export function requiredArgValue(args, name) {
+  const index = args.indexOf(name);
+  if (index < 0) return undefined;
+  const value = args[index + 1];
+  if (value === undefined || value.startsWith("--")) {
+    throw new Error(`${name} requires a value.`);
+  }
+  return value;
+}
+
+export function parseConfigPort(value) {
+  const text = String(value).trim();
+  if (!/^\d+$/.test(text)) throw new Error("port must be an integer between 1 and 65535");
+  const port = Number(text);
+  if (port < 1 || port > 65535) throw new Error("port must be an integer between 1 and 65535");
+  return port;
+}
+
+export function parseConfigHost(value) {
+  const host = String(value).trim().toLowerCase();
+  if (host === "127.0.0.1" || host === "localhost" || host === "::1") return host;
+  throw new Error("host must be a loopback address: 127.0.0.1, localhost, or ::1");
+}
+
+export function codexAuthCommand() {
+  return {
+    command: process.execPath,
+    args: [CLI_ENTRY, "key", "print"],
+    timeout_ms: 5000,
+    refresh_interval_ms: 0
+  };
+}
+
+function quoteCommandPart(value) {
+  return `"${String(value).replace(/"/g, '\\"')}"`;
+}
+
+export function claudeApiKeyHelper() {
+  return [process.execPath, CLI_ENTRY, "key", "print"].map(quoteCommandPart).join(" ");
+}
+
+export function computeAppStatus(setup, service) {
+  const githubTokenPresent = setup.auth.github_token.source !== "missing";
+  const apiKeyPresent = setup.auth.api_key.exists;
+  const hasAerialClient = setup.clients.codex.state === "aerial" || setup.clients.claude.state === "aerial";
+  const serviceHealthy = service.supported !== false && service.health?.aerial === true;
+  const ok = apiKeyPresent && githubTokenPresent && hasAerialClient && serviceHealthy;
+  const nextSteps = [];
+  const hints = [];
+  if (!githubTokenPresent) nextSteps.push("run: aerial login");
+  if (!hasAerialClient) nextSteps.push("run: aerial setup codex or aerial setup claude");
+  if (hasAerialClient && !apiKeyPresent) nextSteps.push("run: aerial setup codex or aerial setup claude to recreate the local Aerial key");
+  if (service.supported !== false && !service.service?.loaded) {
+    if (serviceHealthy) {
+      hints.push("Aerial is running in the foreground but no background service is installed; run `aerial service install` so it starts on reboot.");
+    } else {
+      nextSteps.push("run: aerial service install");
+    }
+  }
+  if (setup.auth.github_token.source === "env") {
+    hints.push("AERIAL_GITHUB_TOKEN is set for this process only; run aerial login without that env var to persist a service-readable login.");
+  }
+  return { schema: "aerial.status.v1", ok, setup, service, nextSteps, hints };
+}

package/src/cli/index.js

@@ -1,9 +1,8 @@
 #!/usr/bin/env node
-import { printVersion } from "./version.js";
-import { printHelp } from "./help.js";
+import { printVersion } from "./helpers.js";
 import { appStatus } from "./commands/status.js";
 import { runConfigCli } from "./commands/config.js";
-import { runDisableCli } from "./commands/disable.js";
+import { runTeardownCli } from "./commands/teardown.js";
 import { runKeyCli } from "./commands/key.js";
 import { runLoginCli } from "./commands/login.js";
 import { runProxyCli } from "./commands/proxy.js";
@@ -13,6 +12,30 @@ import { runStartCli } from "./commands/start.js";
 import { doctor, renderDoctorText } from "./doctor.js";
 import { formatProbeReport, runProbe } from "./probe.js";
 
+function printHelp() {
+  console.log(`Aerial local Copilot proxy
+
+Usage:
+  aerial --version
+  aerial login
+  aerial setup codex [--model <id>] [--effort <minimal|low|medium|high|xhigh|max|ultra>]
+  aerial setup claude [--model <id>] [--effort <low|medium|high|xhigh|max>]
+  aerial service install
+  aerial status [--json]
+  aerial proxy status|enable|disable [--json]
+
+Diagnostics and rollback:
+  aerial setup status [--json]
+  aerial setup restore <codex|claude|all> --latest
+  aerial service status [--json]
+  aerial teardown
+  aerial doctor
+  aerial probe [--live] [--json]
+
+Debug:
+  aerial start [--host 127.0.0.1] [--port 18181]`);
+}
+
 async function main() {
   const args = process.argv.slice(2);
   const [command, subcommand, ...rest] = args;
@@ -51,8 +74,8 @@ async function main() {
     }
   }
 
-  if (command === "disable") {
-    runDisableCli();
+  if (command === "teardown") {
+    runTeardownCli();
     return;
   }
 
@@ -86,7 +109,16 @@ async function main() {
   process.exitCode = 1;
 }
 
-main().catch((error) => {
-  console.error(error.message);
-  process.exitCode = 1;
-});
+main()
+  .then(() => {
+    // One-shot commands may leave keep-alive sockets (undici pools), a SOCKS5
+    // bridge, or stdin open, which keeps the event loop alive and hangs the CLI
+    // after the work is done. `start` is the only long-running command, so for
+    // everything else exit explicitly once main() resolves.
+    const command = process.argv[2];
+    if (command !== "start") process.exit(process.exitCode ?? 0);
+  })
+  .catch((error) => {
+    console.error(error.message);
+    process.exit(1);
+  });

package/src/cli/output.js

@@ -18,6 +18,7 @@ export function printSetupSummary(status) {
     const model = client.model ? ` model=${client.model}` : "";
     const effort = ` effort=${client.effort || "missing"}`;
     console.log(`  ${client.target}: ${client.state}${model}${effort}`);
+    if (client.migration) console.log(`    migration: ${client.migration}`);
   }
   console.log(`api key: ${status.auth.api_key.exists ? "present" : "missing"}`);
   const ghSource = status.auth.github_token.source;

package/src/cli/probe.js

@@ -1,6 +1,7 @@
 import { proxyChatCompletions, proxyMessages, proxyModels, proxyResponses } from "../proxy/index.js";
-import { readJsonSafely } from "../shared/http-utils.js";
-import { aerialRoutes, usageSummary } from "../proxy/model-utils.js";
+import { readJsonSafely } from "../shared/utils.js";
+import { aerialRoutes, usageSummary } from "../proxy/models.js";
+import { supportedReasoningEfforts } from "../proxy/model-catalog.js";
 
 function modelRoutes(model) {
   return aerialRoutes(model);
@@ -59,6 +60,7 @@ export async function runProbe({ live = false } = {}) {
     models: models.map((model) => ({
       id: model.id,
       routes: modelRoutes(model),
+      efforts: supportedReasoningEfforts(model),
       notes: model.aerial?.notes || [],
       supported: Boolean(model.aerial?.supported)
     }))
@@ -117,8 +119,9 @@ export function formatProbeReport(report) {
   lines.push("", "Model matrix:");
   for (const model of report.models) {
     const routes = model.routes.length ? model.routes.join(",") : "-";
+    const efforts = model.efforts.length ? ` efforts=${model.efforts.join(",")}` : "";
     const notes = model.notes.length ? ` notes=${model.notes.join(",")}` : "";
-    lines.push(`- ${model.id}: routes=${routes}${notes}`);
+    lines.push(`- ${model.id}: routes=${routes}${efforts}${notes}`);
   }
   return lines.join("\n");
 }