@workweave/router 0.2.10 → 0.2.12

package/install.sh

@@ -37,6 +37,8 @@
 #   npx @workweave/router --codex                          # skip the picker, target Codex
 #   npx @workweave/router --opencode                       # skip the picker, target opencode
 #   npx @workweave/router --pi                              # skip the picker, target pi
+#   npx @workweave/router --pi --lsp go,typescript          # also install language servers for pi's lsp tool
+#                                                             (go/typescript/python/rust; needs that language's toolchain)
 #   npx @workweave/router --scope project                  # commit-with-team install
 #   npx @workweave/router --dir /tmp/my-sandbox            # isolated throwaway install
 #   npx @workweave/router --local                          # local router on localhost:8080
@@ -47,10 +49,11 @@
 #   npx @workweave/router --uninstall                      # remove a previous install (delegates to uninstall.sh)
 #
 # Re-running the installer reuses the key already on disk, so you only paste it
-# once. `update` is the scriptable form of that: it never prompts, refreshes the
-# managed config + assets in place, and errors (rather than asking) when no key
-# can be found:
+# once — for every client, not just Claude Code. `update` is the scriptable form
+# of that: it never prompts, refreshes the managed config + assets in place, and
+# errors (rather than asking) when no key can be found:
 #   npx @workweave/router update --claude                  # refresh the Claude Code install in place
+#   npx @workweave/router update --codex                   # same for Codex / opencode / pi
 #
 # Toggle an existing install on/off without losing the router config (so
 # switching back is instant). These never prompt for a key and require an
@@ -64,6 +67,28 @@
 # `claude` start; Codex and opencode re-read config every invocation.
 # Cursor's base URL lives in its own settings UI (no file we own), so there's
 # nothing to toggle here — flip "Override OpenAI Base URL" in Cursor settings.
+#
+# Which router directives each client gets is declared once in
+# install/directives.tsv and installed from there: Claude Code and opencode get
+# Markdown slash commands, Codex gets native `$name` skills (it reserves `/…`
+# for built-ins), pi registers /fm and /ufm in its extension, and Cursor is
+# manual. See install/README.md for the full matrix.
+#
+# Inspect and edit which models this installation lets the router pick from —
+# the same lists the router dashboard's settings page renders. The endpoint and
+# router key both come from the install already on disk, so nothing is prompted
+# and no key is ever passed on the command line:
+#   npx @workweave/router models --claude                            # every model, with its on/off state
+#   npx @workweave/router models disable gpt-5.6 --claude            # take a model out of rotation
+#   npx @workweave/router models enable gpt-5.6 --claude             # put it back
+#   npx @workweave/router models providers --claude                  # same, one row per provider
+#   npx @workweave/router models providers disable openai --claude   # drop a whole provider
+#   npx @workweave/router models prefer claude-opus-5 --claude       # set the preferred-model ranking
+#   npx @workweave/router models list --json --claude                # machine-readable, for scripts
+# Editing needs a router that mounts the model-selection API (self-hosted and
+# local routers do). The Weave-hosted router keeps model selection with the
+# organization, in the Weave dashboard — there `models` lists and points you at
+# it rather than editing.
 
 set -euo pipefail
 
@@ -98,9 +123,22 @@ target_explicit="false"
 # never-prompting install that reuses the key already on disk. "off"/"on"/
 # "status" toggle or report an existing install without touching the router
 # key/identity — see the toggle_* helpers and the dispatch block below.
+# "models" reads and edits the installation's model selection over the router's
+# admin API; it touches no local config at all.
 mode="install"
 disable_routing_alias="false"
 
+# `models` sub-verb plus its operands (model / provider ids), newline-delimited
+# in argument order. Catalog ids and provider names never contain whitespace,
+# so a newline-delimited string stays readable where a bash 3.2 array under
+# `set -u` would not. --json switches the output to the raw API payload.
+models_args=""
+models_json="false"
+
+# --lsp <langs>: comma-separated languages whose language servers to install
+# for the pi extension's `lsp` tool (pi target only). Empty = don't install any.
+lsp_langs=""
+
 # --rotate-key forces the interactive key prompt even when a usable key is
 # already installed, so a rotated key can replace it.
 rotate_key="false"
@@ -316,7 +354,6 @@ refuse_if_symlink() {
 # --codex) can find and replace the block instead of duplicating it.
 WEAVE_CODEX_BEGIN_MARKER="# >>> weave-router managed (do not edit between markers) >>>"
 WEAVE_CODEX_END_MARKER="# <<< weave-router managed <<<"
-WEAVE_CODEX_SKILL_MARKER="<!-- weave-router managed disable-routing skill -->"
 
 # ---------- identity helpers ----------
 #
@@ -465,11 +502,12 @@ write_codex_config() {
     printf '%s' "${s//\"/\\\"}"
   }
 
-  local esc_key esc_email esc_name esc_url
+  local esc_key esc_email esc_name esc_url esc_status
   esc_key="$(toml_escape "$block_key")"
   esc_email="$(toml_escape "$block_email")"
   esc_name="$(toml_escape "$block_name")"
   esc_url="$(toml_escape "$block_url")"
+  esc_status="$(toml_escape "$codex_status_file")"
 
   # Plant whichever identity values we have alongside the router key so the
   # router can attribute Codex traffic to a person on shared keys. Build the
@@ -486,22 +524,50 @@ write_codex_config() {
   # that share the same router key. The router otherwise has to guess from
   # User-Agent.
   headers_parts="${headers_parts}, \"X-App\" = \"codex\""
-  # Match the public hosted Claude Code installation: Codex needs this
-  # explicit policy selection because that endpoint otherwise uses its
-  # cluster default. Self-hosted endpoints may not run the optional HMM
-  # sidecar, so every custom URL deliberately keeps the router's own default.
-  # Keep this inside the managed block so a re-install can change it safely.
-  if [ "$block_url" = "$HOSTED_BASE_URL" ]; then
-    headers_parts="${headers_parts}, \"X-Weave-Router-Strategy\" = \"hmm\""
-  fi
+  # No strategy header: pinning one here freezes installed clients on whatever
+  # policy was current at install time, so a deployment-default change never
+  # reaches them. Every endpoint, hosted or self-hosted, uses its own default.
   local headers_line="http_headers = { ${headers_parts} }"
 
+  local hook_feature_line="features.hooks = true"
+  local hook_block=""
+  local codex_hooks_enabled="true"
+  if [ -f "$config_file" ]; then
+    if awk '
+      !in_section && /^[[:space:]]*hooks[[:space:]]*=/ { conflict=1 }
+      $0 == "[hooks]" { conflict=1 }
+      /^[[:space:]]*\[/ { in_section=1 }
+      END { exit(conflict ? 0 : 1) }
+    ' "$config_file"; then
+      codex_hooks_enabled="false"
+      hook_feature_line=""
+    fi
+  fi
+  if [ -f "$config_file" ] && grep -q '^\[features\]$' "$config_file"; then
+    hook_feature_line=""
+  fi
+  if [ "$codex_hooks_enabled" = "true" ]; then
+    hook_block="$(cat <<TOML
+
+[[hooks.SessionStart]]
+[[hooks.SessionStart.hooks]]
+type = "command"
+command = "${esc_status}"
+
+[[hooks.Stop]]
+[[hooks.Stop.hooks]]
+type = "command"
+command = "${esc_status}"
+TOML
+)"
+  fi
   local block
   block="$(cat <<TOML
 ${WEAVE_CODEX_BEGIN_MARKER}
 # Managed by the Weave Router installer. Re-running the installer rewrites
 # this block; \`./uninstall.sh --codex\` removes it. To opt out without
 # uninstalling, change the model_provider value below.
+${hook_feature_line}
 model_provider = "weave"
 
 [model_providers.weave]
@@ -510,6 +576,7 @@ base_url = "${esc_url}/v1"
 wire_api = "responses"
 requires_openai_auth = true
 ${headers_line}
+${hook_block}
 ${WEAVE_CODEX_END_MARKER}
 TOML
 )"
@@ -564,6 +631,25 @@ TOML
   else
     printf "%s\n" "$block" >"$config_file"
   fi
+
+  # If the user already has a [features] table, place our managed hook
+  # setting in that table instead of using a duplicate dotted key. Preserve an
+  # explicit user setting and mark only the line this installer owns.
+  if grep -q '^\[features\]$' "$config_file"; then
+    if ! awk '
+      /^\[features\]$/ { in_features=1; next }
+      /^\[/ { in_features=0 }
+      in_features && /^[[:space:]]*hooks[[:space:]]*=/ { found=1 }
+      END { exit(found ? 0 : 1) }
+    ' "$config_file"; then
+      tmp="$(mktemp -t weave-codex-features.XXXXXX)"
+      awk '/^\[features\]$/ && !inserted { print; print "hooks = true # weave-router managed codex hooks"; inserted=1; next } { print }' "$config_file" >"$tmp"
+      mv "$tmp" "$config_file"
+    fi
+  fi
+  if [ "$codex_hooks_enabled" != "true" ]; then
+    warn "Existing Codex hooks configuration is not an inline array; preserving it and skipping the Weave status hooks. Routing is still enabled."
+  fi
   # 0600: the file holds a router key. Even at user scope, mode 644 would
   # leak the key to any local user on a shared box.
   chmod 600 "$config_file"
@@ -803,8 +889,8 @@ write_pi_models_config() {
       models: [
         { id: "claude-fable-5",    name: "Claude Fable 5 (via Weave Router)",    reasoning: true, input: ["text","image"], contextWindow: 1000000, maxTokens: 128000 },
         { id: "claude-opus-5",     name: "Claude Opus 5 (via Weave Router)",     reasoning: true, input: ["text","image"], contextWindow: 1000000, maxTokens: 128000 },
-        { id: "claude-opus-4-7",   name: "Claude Opus 4.7 (via Weave Router)",   reasoning: true, input: ["text","image"], contextWindow: 200000, maxTokens: 64000 },
-        { id: "claude-sonnet-4-6", name: "Claude Sonnet 4.6 (via Weave Router)", reasoning: true, input: ["text","image"], contextWindow: 200000, maxTokens: 64000 },
+        { id: "claude-opus-4-7",   name: "Claude Opus 4.7 (via Weave Router)",   reasoning: true, input: ["text","image"], contextWindow: 1000000, maxTokens: 64000 },
+        { id: "claude-sonnet-4-6", name: "Claude Sonnet 4.6 (via Weave Router)", reasoning: true, input: ["text","image"], contextWindow: 1000000, maxTokens: 64000 },
         { id: "claude-haiku-4-5",  name: "Claude Haiku 4.5 (via Weave Router)",  reasoning: true, input: ["text","image"], contextWindow: 200000, maxTokens: 32000 },
         { id: "gpt-5.6-sol",       name: "GPT-5.6 Sol (via Weave Router)",       reasoning: true, input: ["text","image"], contextWindow: 1050000, maxTokens: 128000 },
         { id: "grok-4.5",          name: "Grok 4.5 (via Weave Router)",          reasoning: true, input: ["text","image"], contextWindow: 500000, maxTokens: 131072 },
@@ -859,6 +945,69 @@ write_pi_settings_config() {
   printf '%s\n' "$merged" >"$settings_file"
 }
 
+# Language-server installs for the pi extension's `lsp` tool (--lsp go,ts,...).
+# The alias -> server -> toolchain matrix mirrors LSP_SERVERS in
+# install/pi-router/src/lsp-servers.ts — keep the two in lockstep. Every
+# failure is a warn-and-continue: a missing toolchain must not fail the router
+# install, and the extension re-offers conversationally at session start.
+install_lsp_servers() {
+  local langs="$1" lang
+  local seen=" "
+  for lang in $(printf '%s' "$langs" | tr ',' ' '); do
+    local id="" bin="" alt_bin="" toolchain="" fallback_dir="" gopath=""
+    local cmd=""
+    case "$(printf '%s' "$lang" | tr '[:upper:]' '[:lower:]')" in
+      go|golang)
+        id="go"; bin="gopls"; toolchain="go"
+        # go install honors $GOBIN, else <first GOPATH element>/bin (default ~/go/bin).
+        gopath="${GOPATH:-$HOME/go}"
+        fallback_dir="${GOBIN:-${gopath%%:*}/bin}"
+        cmd="go install golang.org/x/tools/gopls@latest"
+        ;;
+      ts|typescript|js|javascript)
+        id="typescript"; bin="typescript-language-server"; toolchain="npm"
+        cmd="npm i -g typescript-language-server typescript"
+        ;;
+      py|python)
+        id="python"; bin="pyright-langserver"; alt_bin="basedpyright-langserver"; toolchain="npm"
+        cmd="npm i -g pyright"
+        ;;
+      rs|rust)
+        id="rust"; bin="rust-analyzer"; toolchain="rustup"
+        # rustup honors $CARGO_HOME (default ~/.cargo).
+        fallback_dir="${CARGO_HOME:-$HOME/.cargo}/bin"
+        cmd="rustup component add rust-analyzer"
+        ;;
+      *)
+        warn "--lsp: unknown language '$lang' (valid: go, typescript, python, rust). Skipping."
+        continue
+        ;;
+    esac
+    case "$seen" in *" $id "*) continue ;; esac
+    seen="$seen$id "
+
+    if command -v "$bin" >/dev/null 2>&1 \
+      || { [ -n "$alt_bin" ] && command -v "$alt_bin" >/dev/null 2>&1; } \
+      || { [ -n "$fallback_dir" ] && [ -x "$fallback_dir/$bin" ]; }; then
+      ok "$id language server already installed ($bin)"
+      continue
+    fi
+    if ! command -v "$toolchain" >/dev/null 2>&1; then
+      warn "--lsp $id: needs '$toolchain' on PATH (install command: $cmd). Skipping — re-run after installing the $toolchain toolchain."
+      continue
+    fi
+    # shellcheck disable=SC2086 — $cmd is a fixed argv from the case above, never user input.
+    if spin "Installing $id language server" $cmd; then
+      ok "$id language server installed ($cmd)"
+      if [ -n "$fallback_dir" ] && ! command -v "$bin" >/dev/null 2>&1; then
+        info "$bin landed in $fallback_dir (not on PATH). The pi lsp tool finds it there; other tools may need a PATH entry."
+      fi
+    else
+      warn "--lsp $id: '$cmd' failed. Run it manually, or ask pi to enable $id LSP support later."
+    fi
+  done
+}
+
 # resolve_user_name mirrors resolve_user_email but for display name. Priority:
 # WEAVE_USER_NAME env override → git config user.name → empty. We don't
 # prompt for name independently: if email prompting yielded nothing, name
@@ -972,6 +1121,10 @@ while [ $# -gt 0 ]; do
     --pi)
       target="pi"; target_explicit="true"; shift
       ;;
+    --lsp)
+      lsp_langs="${2:-}"; shift 2
+      [ -n "$lsp_langs" ] || { err "--lsp requires a comma-separated language list (go,typescript,python,rust)."; exit 2; }
+      ;;
     --claude)
       # No-op selector for symmetry with --codex / --opencode. Useful in
       # pipelines that want to skip the interactive picker without depending
@@ -994,15 +1147,44 @@ while [ $# -gt 0 ]; do
       # so `disable-routing --claude` cannot silently change Claude settings.
       mode="off"; disable_routing_alias="true"; shift
       ;;
+    models|--models)
+      # Model selection. Sub-verb and operand collection happens in the
+      # catch-all arm below (guarded on mode="models"), not here — that lets
+      # `--claude`/`--json`/etc. appear before, after, or between operands
+      # instead of only after every operand has been consumed.
+      mode="models"; shift
+      ;;
+    --json)
+      models_json="true"; shift
+      ;;
     -h|--help)
       usage 0
       ;;
     *)
-      err "Unknown flag: $1."; usage 2
+      # In `models` mode, a bare (non-dashed) word is a sub-verb or operand —
+      # collect it and keep parsing, so a flag can appear before, after, or
+      # between them (`models --claude enable x` and `models enable x --claude`
+      # both work). A dashed token nothing above matched is still an error,
+      # models mode or not.
+      if [ "$mode" = "models" ] && [ "${1#-}" = "$1" ]; then
+        models_args="${models_args}${models_args:+$'\n'}$1"; shift
+      else
+        err "Unknown flag: $1."; usage 2
+      fi
       ;;
   esac
 done
 
+# --lsp is a pi-extension feature, so it implies the pi target; combining it
+# with another explicit target is a contradiction, not a preference.
+if [ -n "$lsp_langs" ]; then
+  if [ "$target_explicit" = "true" ] && [ "$target" != "pi" ]; then
+    err "--lsp only applies to the pi target (the lsp tool ships in the pi extension). Drop --lsp or use --pi."
+    exit 2
+  fi
+  target="pi"; target_explicit="true"
+fi
+
 if [ "$disable_routing_alias" = "true" ]; then
   if [ "$target_explicit" = "true" ] && [ "$target" != "codex" ]; then
     err "disable-routing only applies to Codex; omit the client flag or use --codex."
@@ -1014,13 +1196,38 @@ fi
 
 # Toggle verbs only flip config install.sh already wrote: no key, no identity,
 # no prompts. Require an explicit client so we never guess which config to
-# touch, and suppress every interactive prompt downstream.
+# touch, and suppress every interactive prompt downstream. `models` edits no
+# local config, but it still reads the endpoint and key out of one install, so
+# it needs the same explicit choice.
 if [ "$mode" != "install" ] && [ "$mode" != "update" ]; then
   non_interactive="true"
   if [ "$target_explicit" != "true" ]; then
-    err "'$mode' requires an explicit client: --claude, --codex, or --opencode."
+    if [ "$mode" = "models" ]; then
+      err "'models' requires an explicit client: --claude or --codex."
+    else
+      err "'$mode' requires an explicit client: --claude, --codex, or --opencode."
+    fi
+    exit 2
+  fi
+fi
+
+# `models` needs to resolve one install's endpoint + key. Claude Code and Codex
+# both expose readers for that (resolve_installed_endpoint / read_installed_key);
+# opencode and pi do not have the endpoint-trust story worked out yet, so they
+# still fail fast here rather than falling through to the toggle dispatch, which
+# would flip config nobody asked to change.
+if [ "$mode" = "models" ] && [ "$target" != "claude" ] && [ "$target" != "codex" ]; then
+  err "'models' supports --claude and --codex only (it resolves the router endpoint from that client's config)."
+  exit 2
+fi
+
+# --json prints the API payload verbatim, so nothing else may reach stdout.
+if [ "$models_json" = "true" ]; then
+  if [ "$mode" != "models" ]; then
+    err "--json only applies to 'models'."
     exit 2
   fi
+  quiet="true"
 fi
 
 # `update` is an install that never prompts: it refreshes the managed config
@@ -1033,16 +1240,14 @@ if [ "$mode" = "update" ]; then
     err "--rotate-key needs a prompt, which 'update' never issues. Re-run the installer without 'update'."
     exit 2
   fi
-  if [ "$target" != "claude" ]; then
-    err "'update' currently supports --claude only. Re-run the installer for $target (it reuses your installed key)."
-    exit 2
-  fi
 fi
 
 # Toggle verbs (off/on/status) aren't implemented for pi — its config is a
 # structural models.json/settings.json merge, reversed by the uninstaller
-# rather than a single env/key line we can park and restore.
-if [ "$mode" != "install" ] && [ "$target" = "pi" ]; then
+# rather than a single env/key line we can park and restore. `update` is not a
+# toggle: it rewrites that same structural config in place, exactly as install
+# does, so it belongs with install here.
+if [ "$mode" != "install" ] && [ "$mode" != "update" ] && [ "$target" = "pi" ]; then
   err "Toggle verbs (off/on/status) aren't supported for --pi. Use 'npx @workweave/router --uninstall --pi' to remove, or re-run the installer to refresh."
   exit 2
 fi
@@ -1156,7 +1361,9 @@ fi
 
 # ---------- pre-flight ----------
 
-if [ "$mode" != "install" ] && [ "$mode" != "update" ]; then
+# `models` skips this line: it prints its own header carrying the endpoint it
+# resolved, which is the part a reader actually needs.
+if [ "$mode" != "install" ] && [ "$mode" != "update" ] && [ "$mode" != "models" ]; then
   [ "$quiet" = "true" ] || info "mode=${C_BOLD}${mode}${C_RESET}  scope=${C_BOLD}${scope}${C_RESET}  target=${C_BOLD}${target}${C_RESET}"
 fi
 
@@ -1164,15 +1371,26 @@ fi
 # Claude Code's settings.json and opencode's opencode.json patching both use
 # jq to deep-merge / structurally rewrite JSON. Toggling those clients reads
 # and rewrites the same JSON, so jq is required there too.
-if [ "$target" = "claude" ] || [ "$target" = "opencode" ] || [ "$target" = "pi" ]; then
+#
+# `models` is the exception for Codex: it renders and edits the router's JSON
+# payloads with jq regardless of which client's config supplied the endpoint,
+# so require it there too rather than dying mid-render on `jq: command not
+# found`. Installing Codex itself still needs no jq.
+if [ "$target" = "claude" ] || [ "$target" = "opencode" ] || [ "$target" = "pi" ] \
+   || { [ "$mode" = "models" ] && [ "$target" = "codex" ]; }; then
   require_cmd jq    "macOS: 'brew install jq' · Debian/Ubuntu: 'sudo apt install jq'"
 fi
-# curl is only used by the install/update paths' health/validate probes;
-# toggles never hit the network.
-if [ "$mode" = "install" ] || [ "$mode" = "update" ]; then
+# curl is used by the install/update paths' health/validate probes and by every
+# `models` call; the on/off/status toggles never hit the network.
+if [ "$mode" = "install" ] || [ "$mode" = "update" ] || [ "$mode" = "models" ]; then
   require_cmd curl  "macOS/Linux: usually preinstalled — check your package manager"
 fi
 
+# Every warning below says the client's config will be written anyway, which is
+# true for install/update/toggles and false for `models` — it only reads that
+# config to find the router. Whether the client itself is installed has no
+# bearing on a model-selection call, so skip the check there entirely.
+if [ "$mode" != "models" ]; then
 case "$target" in
   claude)
     if ! command -v claude >/dev/null 2>&1; then
@@ -1199,9 +1417,121 @@ case "$target" in
     fi
     ;;
 esac
+fi
 
 script_dir="$(cd "$(dirname "$0")" 2>/dev/null && pwd || true)"
 
+# ---------- directive registry (embedded) ----------
+#
+# install.sh is served standalone (WorkWeave serves it for `curl | sh`), so it
+# cannot source install/registry.sh or read install/directives.tsv. Both are
+# embedded here verbatim; install/tests/registry_test.sh asserts they never
+# drift from the canonical files.
+WEAVE_REGISTRY_DATA=$(cat <<'WEAVE_REGISTRY_EOF'
+# Weave Router directive registry
+# canonical|aliases|capability|claude|codex|opencode|pi|cursor|adapter
+# aliases are comma-separated; client columns are yes/no. adapter is the native asset kind.
+force-model|fm|prompt|yes|yes|yes|yes|manual|command,skill
+unforce-model|ufm|prompt|yes|yes|yes|yes|manual|command,skill
+router-feedback|rf|prompt|yes|yes|yes|no|manual|command,skill
+router-off||local-toggle|yes|yes|no|no|manual|command,skill
+router-on||local-toggle|yes|yes|no|no|manual|command,skill
+router-status||local-toggle|yes|yes|no|no|manual|command,skill
+router-session||prompt|yes|no|no|no|manual|command
+router-models|models|local-toggle|yes|yes|no|no|manual|command,skill
+disable-routing||local-toggle|no|yes|no|no|manual|skill
+beta||prompt|yes|no|no|yes|manual|command
+WEAVE_REGISTRY_EOF
+)
+
+# >>> weave-router registry lib >>>
+weave_registry_rows() {
+  if [ -n "${WEAVE_REGISTRY_DATA:-}" ]; then
+    printf '%s\n' "$WEAVE_REGISTRY_DATA" | awk -F '|' '!/^([[:space:]]*#|[[:space:]]*$)/ { print }'
+    return 0
+  fi
+  local registry="${WEAVE_REGISTRY_FILE:-}"
+  if [ -z "$registry" ]; then
+    local dir
+    dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" 2>/dev/null && pwd -P)" || return 1
+    registry="$dir/directives.tsv"
+  fi
+  [ -f "$registry" ] || return 1
+  awk -F '|' '!/^([[:space:]]*#|[[:space:]]*$)/ { print }' "$registry"
+}
+
+# weave_registry_names lists every canonical name and alias a client installs.
+weave_registry_names() {
+  local target="$1" canonical aliases capability claude codex opencode pi cursor adapter
+  while IFS='|' read -r canonical aliases capability claude codex opencode pi cursor adapter; do
+    case "$target" in
+      claude) [ "$claude" = yes ] || continue ;; codex) [ "$codex" = yes ] || continue ;;
+      opencode) [ "$opencode" = yes ] || continue ;; pi) [ "$pi" = yes ] || continue ;;
+      cursor) [ "$cursor" = yes ] || continue ;;
+    esac
+    printf '%s\n' "$canonical"
+    [ -n "$aliases" ] && printf '%s\n' "$aliases" | tr ',' '\n'
+  done <<EOF
+$(weave_registry_rows)
+EOF
+}
+
+# weave_registry_skill_names lists the prompt directives a client exposes as a
+# native skill. Local-config toggles are excluded: they mutate config this
+# installer owns and are handled per target, not as a generic prompt.
+weave_registry_skill_names() {
+  local target="$1" canonical aliases capability claude codex opencode pi cursor adapter
+  while IFS='|' read -r canonical aliases capability claude codex opencode pi cursor adapter; do
+    [ "$capability" = prompt ] || continue
+    case "$target" in
+      claude) [ "$claude" = yes ] || continue ;; codex) [ "$codex" = yes ] || continue ;;
+      opencode) [ "$opencode" = yes ] || continue ;; pi) [ "$pi" = yes ] || continue ;;
+      cursor) [ "$cursor" = yes ] || continue ;;
+    esac
+    printf '%s\n' "$canonical"
+    [ -n "$aliases" ] && printf '%s\n' "$aliases" | tr ',' '\n'
+  done <<EOF
+$(weave_registry_rows)
+EOF
+}
+
+# weave_registry_skill_assets lists every directive a client ships as a skill
+# file, including local-config toggles such as Codex's disable-routing. Install
+# and uninstall use this for file management; weave_registry_skill_names is the
+# narrower prompt-only set used when generating prompt adapters.
+weave_registry_skill_assets() {
+  local target="$1" canonical aliases capability claude codex opencode pi cursor adapter
+  while IFS='|' read -r canonical aliases capability claude codex opencode pi cursor adapter; do
+    case ",$adapter," in *,skill,*) ;; *) continue ;; esac
+    case "$target" in
+      claude) [ "$claude" = yes ] || continue ;; codex) [ "$codex" = yes ] || continue ;;
+      opencode) [ "$opencode" = yes ] || continue ;; pi) [ "$pi" = yes ] || continue ;;
+      cursor) [ "$cursor" = yes ] || continue ;;
+    esac
+    printf '%s\n' "$canonical"
+    [ -n "$aliases" ] && printf '%s\n' "$aliases" | tr ',' '\n'
+  done <<EOF
+$(weave_registry_rows)
+EOF
+}
+
+# weave_registry_canonical_for resolves a name or alias to its canonical
+# directive, and fails when the name is not in the registry at all.
+weave_registry_canonical_for() {
+  local wanted="$1" canonical aliases capability claude codex opencode pi cursor adapter alias
+  while IFS='|' read -r canonical aliases capability claude codex opencode pi cursor adapter; do
+    [ "$wanted" = "$canonical" ] && { printf '%s' "$canonical"; return 0; }
+    IFS=',' read -ra _aliases <<< "$aliases"
+    for alias in ${_aliases[@]+"${_aliases[@]}"}; do
+      [ "$wanted" = "$alias" ] && { printf '%s' "$canonical"; return 0; }
+    done
+  done <<EOF
+$(weave_registry_rows)
+EOF
+  return 1
+}
+# <<< weave-router registry lib <<<
+
 # Resolve the base directory. User scope always uses $HOME. Project scope uses
 # --dir if given, otherwise the CWD's git root. --dir alone (no --scope) is a
 # throwaway user-style install.
@@ -1276,10 +1606,18 @@ elif [ "$target" = "codex" ]; then
   # teammate — .codex/config.toml goes in .gitignore in project scope.
   codex_dir="$settings_base/.codex"
   codex_config_file="$codex_dir/config.toml"
+  if [ "$scope" = "user" ] && [ -z "$install_dir" ]; then
+    codex_status_file="$settings_base/.weave/codex-status.sh"
+  else
+    codex_status_file="$codex_dir/weave-status.sh"
+  fi
+  codex_status_disabled_marker="$(dirname "$codex_status_file")/.weave-router-disabled"
 
   if [ "$scope" = "project" ] || [ -n "$install_dir" ]; then
     refuse_if_symlink "$codex_dir"
     refuse_if_symlink "$codex_config_file"
+    refuse_if_symlink "$codex_status_file"
+    refuse_if_symlink "$codex_status_disabled_marker"
   fi
 
   mkdir -p "$codex_dir"
@@ -1396,6 +1734,240 @@ claude_key_present() {
   [ -n "$(read_claude_key "$1")" ]
 }
 
+# key_source_is_own returns 0 when a config file is safe to read a router key
+# back out of. Codex, opencode, and pi all embed the key in a file that lives
+# INSIDE the project in project scope, and the installer gitignores each one —
+# so a file git tracks is by definition not this user's own install. A hostile
+# checkout could commit one carrying an attacker's rk_ key, and adopting it
+# would bill the developer's traffic to whoever wrote the repo. Same tracked-file
+# test models_endpoint_is_trusted applies to a planted endpoint.
+#
+# Claude Code deliberately does NOT go through this: read_installed_key is
+# documented to pick up a committed header from an older install, which is a
+# supported case there.
+key_source_is_own() {
+  local f="$1"
+  [ -f "$f" ] || return 1
+  [ -L "$f" ] && return 1
+  # Only project-scoped installs put the file somewhere a repo can reach.
+  [ "$scope" = "project" ] && [ -z "$install_dir" ] || return 0
+  command -v git >/dev/null 2>&1 || return 1
+  git -C "$(dirname "$f")" ls-files --error-unmatch -- "$f" >/dev/null 2>&1 && return 1
+  return 0
+}
+
+# read_codex_key prints the router key out of Codex's config.toml, or nothing.
+# Scoped to the managed block so a key-shaped string the user wrote elsewhere in
+# the file is never adopted. awk rather than jq on purpose: the Codex path is the
+# one target that doesn't require jq (see the require_cmd block above).
+read_codex_key() {
+  local f="$1"
+  key_source_is_own "$f" || return 0
+  awk -v begin="$WEAVE_CODEX_BEGIN_MARKER" -v end="$WEAVE_CODEX_END_MARKER" '
+    $0 == begin { inblk = 1; next }
+    $0 == end   { inblk = 0; next }
+    inblk && match($0, /"X-Weave-Router-Key"[[:space:]]*=[[:space:]]*"[^"]*"/) {
+      hdr = substr($0, RSTART, RLENGTH)
+      sub(/^.*=[[:space:]]*"/, "", hdr)
+      sub(/"$/, "", hdr)
+      print hdr
+      exit
+    }
+  ' "$f" 2>/dev/null || true
+}
+
+# read_opencode_key prints the router key out of opencode.json's managed
+# provider, or nothing. The header is the authoritative copy — options.apiKey is
+# only a parse-time placeholder for the @ai-sdk/openai provider.
+read_opencode_key() {
+  local f="$1"
+  key_source_is_own "$f" || return 0
+  json_get "$f" '.provider.weave.options.headers["X-Weave-Router-Key"]'
+}
+
+# read_pi_key prints the router key this pi install already has. The dedicated
+# key file comes first — it is what the @workweave/router extension itself reads
+# at runtime — and models.json is the fallback for an install whose key file was
+# removed by hand.
+read_pi_key() {
+  local key=""
+  if key_source_is_own "$pi_key_file"; then
+    key="$(tr -d '[:space:]' <"$pi_key_file" 2>/dev/null || true)"
+  fi
+  if [ -z "$key" ] && key_source_is_own "$pi_models_file"; then
+    key="$(json_get "$pi_models_file" '.providers.weave.headers["X-Weave-Router-Key"]')"
+  fi
+  printf '%s' "$key"
+}
+
+# read_installed_key prints the router key this install already has on disk, or
+# nothing, for whichever client is being installed. Reading it back is what makes
+# a re-run painless — see the token-handling section below. Defined up here
+# rather than with the rest of token handling because `models` dispatches (and
+# needs a key) before that section runs.
+#
+# models_key_file_order echoes the precedence the Claude reader uses, so a caller
+# that needs to know *which* file the key came from can walk the same list (a
+# command substitution around this function would discard any global it set).
+# models_config_file_for_target names the single managed config that holds both
+# the endpoint and the key for a non-Claude client. Endpoint and credential from
+# the same file are self-consistent, which is exactly the case
+# models_endpoint_is_trusted already treats as always-safe.
+models_config_file_for_target() {
+  case "$target" in
+    codex)    printf '%s' "$codex_config_file" ;;
+    opencode) printf '%s' "$opencode_config_file" ;;
+    pi)       printf '%s' "$pi_models_file" ;;
+  esac
+}
+
+models_key_file_order() {
+  if [ "$scope" = "project" ] && [ -z "$install_dir" ]; then
+    printf '%s\n%s\n%s\n' "$local_settings_file" "$settings_file" "$settings_dir/.weave-parked.json"
+  else
+    printf '%s\n%s\n%s\n' "$settings_file" "$local_settings_file" "$settings_dir/.weave-parked.json"
+  fi
+}
+
+read_claude_installed_key() {
+  local key="" candidate
+  # Mirror where the install path writes the key: project scope (no --dir) puts
+  # it in the gitignored settings.local.json, everything else inlines it into
+  # settings.json. Check the other file too — a scope was possibly changed, or a
+  # project checkout may carry a committed header from an older install.
+  # The parked sidecar is last: `off` moves the key header out of the settings
+  # files and into it, so a run while toggled off finds nothing above even
+  # though the key is still on disk. Same {"env":{…}} shape, so read_claude_key
+  # reads it directly.
+  while IFS= read -r candidate; do
+    [ -n "$candidate" ] || continue
+    key="$(read_claude_key "$candidate")"
+    [ -n "$key" ] && break
+  done <<<"$(models_key_file_order)"
+  printf '%s' "$key"
+}
+
+read_installed_key() {
+  case "$target" in
+    claude)   read_claude_installed_key ;;
+    codex)    read_codex_key "$codex_config_file" ;;
+    opencode) read_opencode_key "$opencode_config_file" ;;
+    pi)       read_pi_key ;;
+  esac
+}
+
+# resolve_installed_base_url prints the router endpoint this Claude Code install
+# already points at, or nothing when none of its files carry a router-shaped
+# one. The parked sidecar comes first: `off` moves the router URL there and
+# leaves api.anthropic.com in the live file, so reading the live file while
+# toggled off would report Anthropic as the router.
+#
+# models_base_file_order echoes that same precedence for callers that need to
+# know which file supplied the endpoint (see models_key_file_order).
+models_base_file_order() {
+  printf '%s\n%s\n%s\n' "$settings_dir/.weave-parked.json" "$settings_file" "$local_settings_file"
+}
+
+resolve_installed_base_url() {
+  local candidate found
+  while IFS= read -r candidate; do
+    [ -n "$candidate" ] || continue
+    found="$(json_get "$candidate" '.env.ANTHROPIC_BASE_URL')"
+    if router_shaped_url "$found"; then
+      printf '%s' "${found%/}"
+      return 0
+    fi
+  done <<<"$(models_base_file_order)"
+  printf ''
+}
+
+# resolve_installed_endpoint prints the router endpoint this install already
+# points at, for whichever client is being installed, or nothing. `update` uses
+# it so a refresh never silently retargets a self-hosted install at the hosted
+# default.
+#
+# The stored shapes differ by client and are normalized back to the root the
+# installer takes on the command line: Codex and opencode hold an OpenAI-style
+# base ending in /v1, while pi holds the bare root (its Anthropic SDK appends
+# /v1/messages itself). Same tracked-file gate as the key readers — a config the
+# repo supplied is not this user's install, whichever field is being read.
+resolve_installed_endpoint() {
+  local found=""
+  case "$target" in
+    claude)
+      resolve_installed_base_url
+      return 0
+      ;;
+    codex)
+      if key_source_is_own "$codex_config_file"; then
+        found="$(awk -v begin="$WEAVE_CODEX_BEGIN_MARKER" -v end="$WEAVE_CODEX_END_MARKER" '
+          $0 == begin { inblk = 1; next }
+          $0 == end   { inblk = 0; next }
+          inblk && match($0, /^[[:space:]]*base_url[[:space:]]*=[[:space:]]*"[^"]*"/) {
+            line = substr($0, RSTART, RLENGTH)
+            sub(/^.*=[[:space:]]*"/, "", line)
+            sub(/"$/, "", line)
+            print line
+            exit
+          }
+        ' "$codex_config_file" 2>/dev/null || true)"
+      fi
+      found="${found%/v1}"
+      ;;
+    opencode)
+      if key_source_is_own "$opencode_config_file"; then
+        found="$(json_get "$opencode_config_file" '.provider.weave.options.baseURL')"
+      fi
+      found="${found%/v1}"
+      ;;
+    pi)
+      if key_source_is_own "$pi_models_file"; then
+        found="$(json_get "$pi_models_file" '.providers.weave.baseUrl')"
+      fi
+      ;;
+  esac
+  printf '%s' "${found%/}"
+}
+
+# models_endpoint_is_trusted returns 0 when it is safe to send the router key
+# resolved from $2 to the endpoint resolved from $1.
+#
+# Project scope deliberately splits the two: the endpoint lives in the
+# committed settings.json (teammates share it) while each teammate's key lives
+# in the gitignored settings.local.json. That split is fine on its own, but it
+# means a *hostile* repo can commit a settings.json naming an endpoint it
+# controls and have this command mail the developer's key to it. Endpoint and
+# credential from the same file are self-consistent and always fine. When they
+# differ, the endpoint must be one the user vouched for out-of-band — the
+# hosted default, or an explicit --base-url — rather than whatever the checkout
+# happened to contain.
+models_endpoint_is_trusted() {
+  local url="$1" base_src="$2" key_src="$3"
+  [ "$base_url_explicit" = "true" ] && return 0
+  [ "$url" = "$HOSTED_BASE_URL" ] && return 0
+  [ -n "$base_src" ] && [ "$base_src" = "$key_src" ] && return 0
+  # Project-scoped self-hosted installs intentionally split the endpoint and
+  # key. The installer writes a gitignored marker beside the key; require that
+  # marker to match before trusting the split. A tracked/symlinked local file is
+  # not a teammate's private configuration and cannot vouch for an endpoint.
+  if [ "$key_src" = "$local_settings_file" ] && [ ! -L "$key_src" ]; then
+    local marked_url
+    marked_url="$(json_get "$key_src" '.env.WEAVE_ROUTER_BASE_URL')"
+    if [ "${marked_url%/}" = "${url%/}" ]; then
+      command -v git >/dev/null 2>&1 || return 1
+      git -C "$(dirname "$key_src")" ls-files --error-unmatch -- "$key_src" >/dev/null 2>&1 && return 1
+      return 0
+    fi
+  fi
+  # A repo can only pre-plant a file git tracks; an untracked local file is the
+  # user's own. If the endpoint's file isn't tracked, it wasn't planted. Checked
+  # inline rather than via weave_command_tracked_by_git, which is defined further
+  # down (inside the statusline heredoc's neighborhood) and isn't in scope here.
+  command -v git >/dev/null 2>&1 || return 1
+  git -C "$(dirname "$base_src")" ls-files --error-unmatch -- "$base_src" >/dev/null 2>&1 || return 0
+  return 1
+}
+
 # gitignore_add appends an entry to the repo .gitignore in project scope so a
 # parked sidecar (which may carry the router key header) never gets committed.
 # No-op for user scope and --dir, matching how install handles its own ignores.
@@ -1595,6 +2167,9 @@ toggle_codex() {
         {print}
       ' "$f" >"$tmp" && mv "$tmp" "$f"
       chmod 600 "$f"
+      if [ -f "$codex_status_file" ] && grep -Fq '<!-- weave-router managed codex status -->' "$codex_status_file"; then
+        "$codex_status_file" --off >/dev/null 2>&1 || true
+      fi
       ok "Codex is ${C_BOLD}off${C_RESET} (default provider). Takes effect on your next 'codex' run."
       ;;
     on)
@@ -1610,6 +2185,9 @@ toggle_codex() {
         {print}
       ' "$f" >"$tmp" && mv "$tmp" "$f"
       chmod 600 "$f"
+      if [ -f "$codex_status_file" ] && grep -Fq '<!-- weave-router managed codex status -->' "$codex_status_file"; then
+        "$codex_status_file" --on >/dev/null 2>&1 || true
+      fi
       ok "Codex is ${C_BOLD}on${C_RESET} (routing through the Weave Router). Takes effect on your next 'codex' run."
       ;;
   esac
@@ -1698,6 +2276,407 @@ toggle_opencode() {
   esac
 }
 
+# ---------- model selection ----------
+#
+# `models` reads and edits the installation's model/provider selection through
+# the router's /admin/v1 API — the same lists the router dashboard's settings
+# page renders, backed by the same columns. Nothing local is written: the
+# endpoint and router key are read out of the install already on disk so a
+# self-hosted install talks to its own router with its own key.
+#
+# The Weave-hosted router runs in `managed` mode and mounts no /admin/v1 at
+# all — there model selection belongs to the organization and is edited in the
+# Weave dashboard. That surfaces as a 404, which reads (for a list) as "fall
+# back to the public catalog and say where to edit" and (for an edit) as a
+# refusal naming the dashboard.
+
+# Public, unauthed catalog of everything the router can route to. Mounted in
+# both deployment modes, so it is the one listing that always works.
+MODELS_CATALOG_PATH="/v1/router/models"
+MODELS_DASHBOARD_URL="https://router.workweave.ai/dashboard/settings"
+
+# Set by models_api on every call.
+models_http_status=""
+models_http_body=""
+
+# models_api METHOD PATH [JSON_BODY] — call the router and capture status+body.
+# The key rides in on stdin (curl --header @-) rather than a -H argument so it
+# never appears in the process arg list, which any other local user can read.
+models_api() {
+  local method="$1" path="$2" body="${3:-}"
+  local out status=""
+  out="$(mktemp)" || { err "Could not create a temp file."; exit 1; }
+  if [ -n "$body" ]; then
+    status="$(printf '%s: %s\n' "$router_key_header" "$api_key" \
+      | curl -sS --max-time 20 -X "$method" \
+             -H 'Content-Type: application/json' --data-binary "$body" \
+             --header @- -o "$out" -w '%{http_code}' "$base_url$path" 2>/dev/null)" || status=""
+  else
+    status="$(printf '%s: %s\n' "$router_key_header" "$api_key" \
+      | curl -sS --max-time 20 -X "$method" \
+             --header @- -o "$out" -w '%{http_code}' "$base_url$path" 2>/dev/null)" || status=""
+  fi
+  models_http_status="$status"
+  models_http_body="$(cat "$out" 2>/dev/null || true)"
+  rm -f "$out"
+  case "$models_http_status" in
+    2*) return 0 ;;
+    *)  return 1 ;;
+  esac
+}
+
+# models_api_error prints the router's own `error` field, when it sent one.
+models_api_error() {
+  printf '%s' "$models_http_body" | jq -r '.error // empty' 2>/dev/null || true
+}
+
+# models_fail turns the status left by models_api into a message that says what
+# to do next, then exits. $1 names the attempted operation.
+models_fail() {
+  local what="$1" detail
+  detail="$(models_api_error)"
+  case "$models_http_status" in
+    ""|000)
+      err "Could not reach the router at $base_url. Is it running?"
+      ;;
+    401|403)
+      # 403 with a message is the ROUTER_EXCLUDED_MODELS/PROVIDERS env pin,
+      # which is actionable on its own; a bare 401/403 is a key problem.
+      if [ -n "$detail" ]; then
+        err "$detail"
+      else
+        err "The router rejected this installation's key. Re-run 'npx @workweave/router --$target --rotate-key' to install a current one."
+      fi
+      ;;
+    404)
+      err "This router does not expose the model-selection API, so $what is not available here."
+      printf "  %sWeave-hosted routers keep model selection with the organization — edit it at %s%s\n" \
+        "$C_DIM" "$MODELS_DASHBOARD_URL" "$C_RESET" >&2
+      printf "  %sSelf-hosted? Update the router to a build that serves /admin/v1/models.%s\n" \
+        "$C_DIM" "$C_RESET" >&2
+      ;;
+    *)
+      if [ -n "$detail" ]; then
+        err "$what failed (HTTP $models_http_status): $detail"
+      else
+        err "$what failed (HTTP $models_http_status)."
+      fi
+      ;;
+  esac
+  exit 1
+}
+
+# models_render_list prints the [{model,provider,enabled}] payload as a
+# provider-grouped checklist. The API sorts by provider then model, which is
+# what group_by needs, and what keeps two runs comparable.
+models_render_list() {
+  local payload="$1" total enabled
+  total="$(printf '%s' "$payload" | jq 'length')"
+  enabled="$(printf '%s' "$payload" | jq '[.[] | select(.enabled)] | length')"
+  printf "%s%sWeave Router models%s %s· %s%s\n" "$C_BOLD" "$C_BRAND" "$C_RESET" "$C_DIM" "$base_url" "$C_RESET"
+  printf "%s%s of %s enabled%s\n\n" "$C_DIM" "$enabled" "$total" "$C_RESET"
+  printf '%s' "$payload" | jq -r --arg on "$C_GREEN" --arg off "$C_DIM" --arg reset "$C_RESET" --arg bold "$C_BOLD" '
+    group_by(.provider)[]
+    | ($bold + .[0].provider + $reset),
+      (.[] | if .enabled
+             then "  " + $on + "[x]" + $reset + " " + .model
+             else "  " + $off + "[ ] " + .model + $reset
+             end)
+  '
+}
+
+# models_render_providers prints the [{provider,enabled}] payload.
+models_render_providers() {
+  local payload="$1"
+  printf "%s%sWeave Router providers%s %s· %s%s\n\n" "$C_BOLD" "$C_BRAND" "$C_RESET" "$C_DIM" "$base_url" "$C_RESET"
+  printf '%s' "$payload" | jq -r --arg on "$C_GREEN" --arg off "$C_DIM" --arg reset "$C_RESET" '
+    .[] | if .enabled
+          then "  " + $on + "[x]" + $reset + " " + .provider
+          else "  " + $off + "[ ] " + .provider + $reset
+          end
+  '
+}
+
+# models_print_preferred appends the priority ranking when one is set. Absent
+# is the norm (the router picks per turn), so silence is the right output.
+models_print_preferred() {
+  models_api GET "/admin/v1/preferred-models" || return 0
+  local list
+  list="$(printf '%s' "$models_http_body" | jq -r '(.preferred // []) | join(" > ")' 2>/dev/null || true)"
+  [ -n "$list" ] || return 0
+  printf "\n%sPreferred order:%s %s\n" "$C_DIM" "$C_RESET" "$list"
+}
+
+# models_list_catalog is the read-only fallback for a router with no
+# model-selection API: list what it can route to and say where to change it.
+# Deliberately not rendered as a checklist — this endpoint reports the deployed
+# catalog, not the installation's selection, so marking every row [x] would
+# claim models are enabled that the dashboard may well have excluded.
+#
+# $1 selects what to print from the same catalog payload: "models" (the
+# default) or "providers" — `models providers` hits this same 404 and must
+# degrade the same way `models list` does rather than hard-failing, since both
+# are read-only listing commands.
+models_list_catalog() {
+  local what="${1:-models}"
+  models_api GET "$MODELS_CATALOG_PATH" || models_fail "listing $what"
+  if [ "$models_json" = "true" ]; then
+    if [ "$what" = "providers" ]; then
+      printf '%s' "$models_http_body" | jq -c '[.models[].provider] | unique'
+    else
+      printf '%s\n' "$models_http_body"
+    fi
+    return 0
+  fi
+  printf "%s%sWeave Router %s%s %s· %s%s\n" "$C_BOLD" "$C_BRAND" "$what" "$C_RESET" "$C_DIM" "$base_url" "$C_RESET"
+  printf "%severything this router can route to%s\n\n" "$C_DIM" "$C_RESET"
+  if [ "$what" = "providers" ]; then
+    printf '%s' "$models_http_body" | jq -r '[.models[].provider] | unique[] | "  " + .'
+  else
+    printf '%s' "$models_http_body" | jq -r --arg reset "$C_RESET" --arg bold "$C_BOLD" '
+      .models | group_by(.provider)[]
+      | ($bold + .[0].provider + $reset),
+        (.[] | "  " + .model)
+    '
+  fi
+  printf "\n%sThis router does not report which of them your installation has enabled:%s\n" "$C_DIM" "$C_RESET"
+  printf "%sselection is an organization-wide setting here. See it, and change it, at%s\n" "$C_DIM" "$C_RESET"
+  printf "%s%s%s\n" "$C_DIM" "$MODELS_DASHBOARD_URL" "$C_RESET"
+}
+
+models_list() {
+  if ! models_api GET "/admin/v1/models"; then
+    # Only a missing API is worth degrading for; anything else is a real error.
+    [ "$models_http_status" = "404" ] || models_fail "listing models"
+    models_list_catalog models
+    return 0
+  fi
+  if [ "$models_json" = "true" ]; then
+    printf '%s\n' "$models_http_body"
+    return 0
+  fi
+  models_render_list "$models_http_body"
+  models_print_preferred
+  printf "\n%sEnable a model:%s  npx @workweave/router models enable <id> --%s\n" "$C_DIM" "$C_RESET" "$target"
+  printf "%sDisable a model:%s npx @workweave/router models disable <id> --%s\n" "$C_DIM" "$C_RESET" "$target"
+}
+
+models_providers_list() {
+  if ! models_api GET "/admin/v1/providers"; then
+    # Same 404 degrade as models_list: a router with no model-selection API
+    # still answers the unauthed catalog, and this is a read-only listing
+    # command same as `models list` — no reason to hard-fail one and not
+    # the other.
+    [ "$models_http_status" = "404" ] || models_fail "listing providers"
+    models_list_catalog providers
+    return 0
+  fi
+  if [ "$models_json" = "true" ]; then
+    printf '%s\n' "$models_http_body"
+    return 0
+  fi
+  models_render_providers "$models_http_body"
+}
+
+# models_toggle KIND ACTION IDS — flip one or more models/providers on or off.
+# Each id is its own request so a typo in the third id can't roll back the two
+# that already applied, and so the report names exactly what changed.
+models_toggle() {
+  local kind="$1" action="$2" ids="$3"
+  local path body id label doing
+  case "$kind" in
+    model)    path="/admin/v1/excluded-models"    ; label="model"    ;;
+    provider) path="/admin/v1/excluded-providers" ; label="provider" ;;
+  esac
+  # Enabling means dropping the id from the exclusion list, disabling means
+  # adding it — the API's remove/add endpoints, inverted here so the CLI reads
+  # the way the dashboard's checkboxes do.
+  doing="disabling"
+  if [ "$action" = "enable" ]; then
+    doing="enabling"
+    path="$path/remove"
+  fi
+
+  # Fed by a here-string, not a pipe: a pipe would run the loop in a subshell
+  # where models_fail's exit only kills that subshell.
+  while IFS= read -r id; do
+    [ -n "$id" ] || continue
+    body="$(jq -nc --arg v "$id" --arg k "$label" '{($k): $v}')"
+    if ! models_api POST "$path" "$body"; then
+      models_fail "$doing $label '$id'"
+    fi
+    # Under --json the router's own response body is the output: a scripted
+    # caller parses stdout, and printing prose there makes it report a parse
+    # failure for a mutation that already succeeded.
+    if [ "$models_json" = "true" ]; then
+      printf '%s\n' "$models_http_body"
+    elif [ "$action" = "enable" ]; then
+      printf "%s✓%s %s %s%s%s is enabled\n" "$C_GREEN" "$C_RESET" "$label" "$C_BOLD" "$id" "$C_RESET"
+    else
+      printf "%s✓%s %s %s%s%s is disabled — the router will not pick it\n" "$C_GREEN" "$C_RESET" "$label" "$C_BOLD" "$id" "$C_RESET"
+    fi
+  done <<<"$ids"
+}
+
+# models_prefer replaces the priority ranking outright (the API's PUT), because
+# a ranking is an ordering: appending one id at a time can't express "this one
+# first". `clear` drops it and returns the installation to plain routing.
+models_prefer() {
+  local ids="$1" body stored
+  if [ "$ids" = "clear" ] || [ "$ids" = "none" ]; then
+    body='{"preferred":[]}'
+  else
+    body="$(printf '%s' "$ids" | jq -c -R -s '{preferred: (split("\n") | map(select(length > 0)))}')"
+  fi
+  models_api PUT "/admin/v1/preferred-models" "$body" || models_fail "setting the preferred-model ranking"
+  if [ "$models_json" = "true" ]; then
+    printf '%s\n' "$models_http_body"
+    return 0
+  fi
+  stored="$(printf '%s' "$models_http_body" | jq -r '(.preferred // []) | join(" > ")')"
+  if [ -n "$stored" ]; then
+    printf "%s✓%s Preferred order: %s\n" "$C_GREEN" "$C_RESET" "$stored"
+  else
+    printf "%s✓%s Preferred-model ranking cleared.\n" "$C_GREEN" "$C_RESET"
+  fi
+}
+
+models_usage() {
+  # Echo back the client the caller actually named, so a Codex user is never
+  # told to run a command that would target (or create) a Claude Code install.
+  local c="--${target}"
+  err "$1"
+  printf '%s\n' \
+    "  npx @workweave/router models $c                          # list models" \
+    "  npx @workweave/router models enable  <id> [<id>…] $c" \
+    "  npx @workweave/router models disable <id> [<id>…] $c" \
+    "  npx @workweave/router models providers $c                # list providers" \
+    "  npx @workweave/router models providers disable <name> $c" \
+    "  npx @workweave/router models prefer <id> [<id>…] $c      # ranking ('clear' to drop)" >&2
+  exit 2
+}
+
+run_models() {
+  local verb operands
+  verb="$(printf '%s' "$models_args" | head -n 1)"
+  operands="$(printf '%s' "$models_args" | tail -n +2)"
+
+  # `models providers …` shifts one more word: the sub-verb is the second word.
+  case "$verb" in
+    ""|list)
+      [ -z "$operands" ] || models_usage "'models $verb' takes no arguments."
+      models_list
+      ;;
+    enable|disable)
+      [ -n "$operands" ] || models_usage "'models $verb' needs at least one model id."
+      models_toggle model "$verb" "$operands"
+      ;;
+    prefer)
+      [ -n "$operands" ] || models_usage "'models prefer' needs model ids, or 'clear'."
+      models_prefer "$operands"
+      ;;
+    providers)
+      local sub rest
+      sub="$(printf '%s' "$operands" | head -n 1)"
+      rest="$(printf '%s' "$operands" | tail -n +2)"
+      case "$sub" in
+        ""|list)
+          models_providers_list
+          ;;
+        enable|disable)
+          [ -n "$rest" ] || models_usage "'models providers $sub' needs at least one provider name."
+          models_toggle provider "$sub" "$rest"
+          ;;
+        *)
+          models_usage "Unknown providers sub-command: '$sub'."
+          ;;
+      esac
+      ;;
+    *)
+      models_usage "Unknown models sub-command: '$verb'."
+      ;;
+  esac
+}
+
+if [ "$mode" = "models" ]; then
+  # Which file supplied the endpoint / the key. Empty means "not from a settings
+  # file" — an explicit --base-url, or WEAVE_ROUTER_KEY. Initialized before the
+  # branches below so `set -u` holds on every path.
+  models_base_source=""
+  models_key_source=""
+  # Editing model selection needs the endpoint and key of one specific install,
+  # never the hosted defaults: a self-hosted user pointing at their own router
+  # would otherwise silently edit the hosted one's installation.
+  if [ "$base_url_explicit" != "true" ]; then
+    models_base="$(resolve_installed_endpoint)"
+    if [ -z "$models_base" ]; then
+      err "No Weave Router install found for $target in this scope. Run 'npx @workweave/router --$target' first, or pass --base-url."
+      exit 1
+    fi
+    base_url="$models_base"
+    # resolve_installed_endpoint ran in a command substitution, so any global it
+    # set died with that subshell. Recover the source by walking the same
+    # precedence to find which file holds the endpoint we just adopted. Only
+    # Claude Code spreads its endpoint across several files; every other client
+    # keeps endpoint and key in one managed config, which is self-consistent by
+    # construction (see models_endpoint_is_trusted's same-file rule).
+    if [ "$target" = "claude" ]; then
+      while IFS= read -r models_src_candidate; do
+        [ -n "$models_src_candidate" ] || continue
+        models_src_url="$(json_get "$models_src_candidate" '.env.ANTHROPIC_BASE_URL')"
+        if [ "${models_src_url%/}" = "$models_base" ]; then
+          models_base_source="$models_src_candidate"
+          break
+        fi
+      done <<<"$(models_base_file_order)"
+    else
+      models_base_source="$(models_config_file_for_target)"
+    fi
+  fi
+  # WEAVE_ROUTER_KEY is the user's own choice, so it pairs with any endpoint.
+  if [ -n "${WEAVE_ROUTER_KEY:-}" ]; then
+    api_key="$WEAVE_ROUTER_KEY"
+    models_key_source="env:WEAVE_ROUTER_KEY"
+  else
+    api_key="$(read_installed_key)"
+    # Same subshell caveat as the endpoint above: recover which file the key
+    # came from by re-reading them in read_installed_key's own precedence.
+    models_key_source=""
+    if [ "$target" = "claude" ]; then
+      while IFS= read -r models_src_candidate; do
+        [ -n "$models_src_candidate" ] || continue
+        if [ -n "$(read_claude_key "$models_src_candidate")" ]; then
+          models_key_source="$models_src_candidate"
+          break
+        fi
+      done <<<"$(models_key_file_order)"
+    else
+      models_key_source="$(models_config_file_for_target)"
+    fi
+  fi
+  if [ -z "$api_key" ]; then
+    err "No router key found for $target in this scope. Re-run 'npx @workweave/router --$target', or export WEAVE_ROUTER_KEY."
+    exit 1
+  fi
+  # Never send a key to an endpoint the checkout supplied. See
+  # models_endpoint_is_trusted: a hostile repo can commit a settings.json naming
+  # its own router, and pairing that with the teammate key from the gitignored
+  # settings.local.json would hand the key to whoever wrote the repo.
+  if [ "$models_key_source" != "env:WEAVE_ROUTER_KEY" ] \
+     && ! models_endpoint_is_trusted "$base_url" "$models_base_source" "$models_key_source"; then
+    err "Refusing to send this installation's router key to $base_url."
+    printf "  %sThat endpoint comes from %s, which git tracks — a checked-out repo can set it —%s\n" \
+      "$C_DIM" "${models_base_source##*/}" "$C_RESET" >&2
+    printf "  %swhile the key comes from %s. Pass --base-url <url> to confirm the endpoint,%s\n" \
+      "$C_DIM" "${models_key_source##*/}" "$C_RESET" >&2
+    printf "  %sor re-run 'npx @workweave/router --claude' to install against the one you want.%s\n" \
+      "$C_DIM" "$C_RESET" >&2
+    exit 1
+  fi
+  run_models
+  exit 0
+fi
+
 if [ "$mode" != "install" ] && [ "$mode" != "update" ]; then
   case "$target" in
     claude)   toggle_claude ;;
@@ -1718,17 +2697,8 @@ fi
 # `off` parks the router URL and points Claude Code at Anthropic, so the parked
 # sidecar is the authority while toggled off — reading the live file there would
 # pin the install to api.anthropic.com.
-if [ "$mode" = "update" ] && [ "$base_url_explicit" != "true" ] && [ "$target" = "claude" ]; then
-  installed_base=""
-  for candidate in \
-    "$settings_dir/.weave-parked.json" \
-    "$settings_file" \
-    "$local_settings_file"
-  do
-    installed_base="$(json_get "$candidate" '.env.ANTHROPIC_BASE_URL')"
-    router_shaped_url "$installed_base" && break
-    installed_base=""
-  done
+if [ "$mode" = "update" ] && [ "$base_url_explicit" != "true" ]; then
+  installed_base="$(resolve_installed_endpoint)"
   if [ -n "$installed_base" ]; then
     base_url="${installed_base%/}"
   fi
@@ -1747,30 +2717,7 @@ fi
 # a re-run painless — the installer refreshes assets and config shape often
 # enough that users re-run it routinely, and re-pasting a key every time is pure
 # friction. --rotate-key skips the read-back so a new key can replace the old.
-
-# read_installed_key prints the router key this install already has on disk, or
-# nothing. Only Claude Code is supported today; the other targets still prompt.
-read_installed_key() {
-  [ "$target" = "claude" ] || return 0
-  local key=""
-  # Mirror where the install path writes the key: project scope (no --dir) puts
-  # it in the gitignored settings.local.json, everything else inlines it into
-  # settings.json. Check the other file too — a scope was possibly changed, or a
-  # project checkout may carry a committed header from an older install.
-  if [ "$scope" = "project" ] && [ -z "$install_dir" ]; then
-    key="$(read_claude_key "$local_settings_file")"
-    [ -n "$key" ] || key="$(read_claude_key "$settings_file")"
-  else
-    key="$(read_claude_key "$settings_file")"
-    [ -n "$key" ] || key="$(read_claude_key "$local_settings_file")"
-  fi
-  # Last resort: `off` moves the key header out of the settings files and into
-  # the parked sidecar, so an install/update run while toggled off finds nothing
-  # above even though the key is still on disk. Same {"env":{…}} shape, so
-  # read_claude_key reads it directly.
-  [ -n "$key" ] || key="$(read_claude_key "$settings_dir/.weave-parked.json")"
-  printf '%s' "$key"
-}
+# read_installed_key itself is defined above, next to the other settings readers.
 
 # prompt_for_key reads a key from the controlling terminal into $api_key. Only
 # ever called on an interactive install; callers check first.
@@ -1862,11 +2809,12 @@ fi
 #   Claude:  <settings_dir>/commands/{force-model,unforce-model}.md  → /force-model
 #   opencode: <commands_dir>/{force-model,unforce-model}.md          → /force-model
 #
-# Codex intentionally is not listed: its slash menu only exposes built-in
-# commands and does not load these Markdown wrappers. A user can send a router
-# directive by starting it with one literal space (for example,
-# ` /force-model gpt-5.6-terra`); Codex submits the trimmed prompt to the
-# router without interpreting it as a local slash command.
+# Codex is intentionally not listed here: its slash menu only exposes built-in
+# commands and does not load these Markdown wrappers. Codex instead gets native
+# `$name` skills (see install_codex_prompt_skills), each of which sends the
+# leading-space prompt form (for example, ` /force-model gpt-5.6-terra`) that
+# the router parses. Which client gets which directive comes from the embedded
+# registry, not from a list here.
 #
 # Files come from install/commands/ in the repo (or the colocated commands/
 # directory the npm package ships alongside install.sh).
@@ -1893,13 +2841,22 @@ install_slash_commands() {
   # command-capable clients. The router-off/on/status wrappers shell out to
   # this installer to flip the *local* config, so they're Claude Code-only and
   # need the install scope baked into the command (the .md can't discover it
-  # at invocation time). {{SCOPE}} is substituted accordingly.
-  installed="force-model, unforce-model, router-feedback, fm, ufm, rf"
-  cmds="force-model unforce-model router-feedback fm ufm rf"
-  if [ "$target" = "claude" ]; then
-    cmds="$cmds router-off router-on router-status router-session"
-    installed="$installed, router-off, router-on, router-status, router-session"
-  fi
+  # at invocation time). {{SCOPE}} is substituted accordingly. router-models
+  # (alias models) is in the same boat: it shells out to read this install's
+  # endpoint and key.
+  cmds=""
+  while IFS= read -r cmd; do
+    [ -f "$commands_src_dir/$cmd.md" ] || continue
+    case ",$cmd," in
+      *,router-off,*|*,router-on,*|*,router-status,*|*,router-session,*|*,router-models,*|*,models,*)
+        [ "$target" = "claude" ] || continue ;;
+    esac
+    [ -n "$cmds" ] && cmds="$cmds "
+    cmds="$cmds$cmd"
+  done <<EOF
+$(weave_registry_names "$target")
+EOF
+  installed="$(printf '%s' "$cmds" | tr ' ' ',' | sed 's/,/, /g')"
 
   # Bake the same scope selector the toggle needs to find this install: --dir
   # overrides scope (mirrors install/uninstall path resolution), so a sandbox
@@ -1923,7 +2880,21 @@ install_slash_commands() {
     # cp-equivalent for the others since the token is absent).
     local body; body="$(cat "$src")"
     body="${body//\{\{SCOPE\}\}/$scope_args}"
-    printf '%s\n' "$body" >"$dst"
+    # Wrappers installed before ownership markers existed carry no marker. A
+    # file whose body still matches what this installer would write is one of
+    # ours from an older version, so adopt it rather than treating it as
+    # user-owned — otherwise every pre-marker install is stranded: never
+    # refreshed, never uninstalled, and skipped by the statusline refresh.
+    # Anything that does not match byte-for-byte is left alone.
+    if [ -e "$dst" ] && { [ ! -f "$dst" ] || ! grep -Fq "<!-- weave-router managed command: $cmd -->" "$dst"; }; then
+      if [ -f "$dst" ] && [ "$(cat "$dst")" = "$body" ]; then
+        : # an unmarked copy of our own wrapper; fall through and adopt it
+      else
+        warn "A user-owned $target command already exists at $dst; leaving it untouched."
+        continue
+      fi
+    fi
+    printf '%s\n<!-- weave-router managed command: %s -->' "$body" "$cmd" >"$dst"
   done
   seed_command_baseline "$commands_src_dir" "$cmds"
   ok "Slash commands written to $dst_dir ($installed)"
@@ -1984,77 +2955,541 @@ remove_obsolete_codex_prompt_wrappers() {
     refuse_if_symlink "$dst_dir"
   fi
 
-  for cmd in force-model unforce-model router-feedback fm ufm rf; do
+  while IFS= read -r cmd; do
     src="$commands_src_dir/$cmd.md"
     dst="$dst_dir/$cmd.md"
     [ -f "$src" ] && [ -f "$dst" ] || continue
-    # A symlink is user-controlled at user scope. Leave it untouched; project
-    # scope rejects it through the same guard used by normal installs.
     [ -L "$dst" ] && continue
     if [ "$scope" = "project" ] || [ -n "$install_dir" ]; then
       refuse_if_symlink "$dst"
     fi
     cmp -s "$src" "$dst" && rm -f "$dst"
-  done
+  done <<EOF
+$(weave_registry_names codex)
+EOF
   rmdir "$dst_dir" 2>/dev/null || true
 }
 
-# Codex skills are the supported local extension surface for an action that
-# must edit Codex's configuration. A literal third-party slash command cannot
-# do this because Codex reserves `/…` for built-ins. The skill is invoked as
-# `$disable-routing`, asks Codex to run the existing safe toggle, and leaves
-# the managed router block in place for a later re-enable.
-install_codex_disable_routing_skill() {
-  local skill_src=""
-  local candidate dst_dir dst_file scope_args body
-  for candidate in \
-    "$script_dir/codex-skills/disable-routing/SKILL.md" \
-    "$script_dir/../codex-skills/disable-routing/SKILL.md"
-  do
-    if [ -f "$candidate" ]; then
+
+# Install every Codex-native skill the registry declares for this client:
+# prompt directives, their aliases, and local-config toggles like $router-off
+# that shell out to this installer's own verbs. weave_registry_skill_assets is
+# the union, canonical names plus aliases — Codex discovers skills by directory
+# name, so an advertised $fm needs its own installed skill rather than a
+# pointer to $force-model.
+#
+# A name with no SKILL.md is skipped: an alias may exist for the Claude command
+# surface without a Codex skill behind it (registry_test.sh pins which ones do).
+install_codex_prompt_skills() {
+  local canonical candidate skill_src dst_dir dst_file emit_src emit_dst scope_args body
+  while IFS= read -r canonical; do
+    skill_src=""
+    for candidate in \
+      "$script_dir/codex-skills/$canonical/SKILL.md" \
+      "$script_dir/../codex-skills/$canonical/SKILL.md"
+    do
+      [ -f "$candidate" ] || continue
       skill_src="$candidate"
       break
+    done
+    [ -n "$skill_src" ] || continue
+    grep -Fq "<!-- weave-router managed $canonical skill -->" "$skill_src" || continue
+    dst_dir="$codex_dir/skills/$canonical"
+    dst_file="$dst_dir/SKILL.md"
+    if [ "$scope" = "project" ] || [ -n "$install_dir" ]; then
+      refuse_if_symlink "$codex_dir/skills"
+      refuse_if_symlink "$dst_dir"
+      refuse_if_symlink "$dst_file"
+    elif [ -L "$codex_dir/skills" ] || [ -L "$dst_dir" ] || [ -L "$dst_file" ]; then
+      warn "Codex skill path contains a symlink; leaving $canonical untouched."
+      continue
     fi
-  done
-  [ -n "$skill_src" ] || { warn "Codex disable-routing skill template is missing; router configuration is still installed."; return 0; }
-  grep -Fq "$WEAVE_CODEX_SKILL_MARKER" "$skill_src" \
-    || { warn "Codex disable-routing skill template has no ownership marker; leaving skills unchanged."; return 0; }
+    if [ -e "$dst_file" ] && { [ ! -f "$dst_file" ] || ! grep -Fq "<!-- weave-router managed $canonical skill -->" "$dst_file"; }; then
+      warn "A user-owned Codex $canonical skill already exists at $dst_file; leaving it untouched."
+      continue
+    fi
+    mkdir -p "$dst_dir"
+    scope_args=""
+    if [ -n "$install_dir" ]; then scope_args=" --dir $(printf '%q' "$install_dir")"
+    elif [ "$scope" = project ]; then scope_args=" --scope project"; fi
+    body="$(<"$skill_src")"
+    body="${body//\{\{SCOPE\}\}/$scope_args}"
+    printf '%s\n' "$body" >"$dst_file"
+    # Prompt skills emit their directive through a script Codex execs; toggles
+    # shell out to the installer's own verbs and ship none.
+    emit_src="${skill_src%/SKILL.md}/scripts/emit.sh"
+    if [ -f "$emit_src" ]; then
+      mkdir -p "$dst_dir/scripts"
+      emit_dst="$dst_dir/scripts/emit.sh"
+      if [ "$scope" = "project" ] || [ -n "$install_dir" ]; then
+        refuse_if_symlink "$dst_dir/scripts"
+        refuse_if_symlink "$emit_dst"
+      elif [ -L "$dst_dir/scripts" ] || [ -L "$emit_dst" ]; then
+        warn "Codex skill script path contains a symlink; leaving $canonical emit.sh untouched."
+      else
+        cp "$emit_src" "$emit_dst"
+        chmod +x "$emit_dst"
+      fi
+    fi
+    ok "Codex skill installed: \$$canonical"
+  done <<EOF
+$(weave_registry_skill_assets codex)
+EOF
+}
 
-  dst_dir="$codex_dir/skills/disable-routing"
-  dst_file="$dst_dir/SKILL.md"
-  if [ "$scope" = "project" ] || [ -n "$install_dir" ]; then
-    refuse_if_symlink "$codex_dir/skills"
-    refuse_if_symlink "$dst_dir"
-    refuse_if_symlink "$dst_file"
-  elif [ -L "$codex_dir/skills" ] || [ -L "$dst_dir" ] || [ -L "$dst_file" ]; then
-    warn "Codex disable-routing skill path contains a symlink; leaving it untouched."
-    return 0
+# ---------- post-install verification (shared by every target) ----------
+#
+# Every client gets the same two probes — reach the router, then prove the key
+# it was just handed actually authenticates — so a working install produces the
+# same green checks regardless of which one was installed.
+
+# validate_key asks the router whether $api_key is live. The key goes over stdin
+# (`@-`) rather than a -H argument so it never appears in the process arg list,
+# where `ps` / /proc would expose it to other local users on a shared machine.
+# Wrapped in a function so the spinner's exec form sees a single command argv.
+validate_key() {
+  printf '%s: %s\n' "$router_key_header" "$api_key" \
+    | curl -fsS --max-time 5 --header @- "$base_url/validate"
+}
+
+# rewrite_installed_key rewrites this target's managed config with the key in $1.
+# Used by the rejected-key fallback below to swap in a replacement without
+# re-running the whole install.
+rewrite_installed_key() {
+  local key="$1"
+  case "$target" in
+    claude)   write_claude_settings "$key" ;;
+    codex)    write_codex_config "$codex_config_file" "$base_url" "$key" "$user_email" "$user_name" ;;
+    opencode) write_opencode_config "$opencode_config_file" "$base_url" "$key" "$user_email" "$user_name" ;;
+    pi)
+      write_pi_models_config "$pi_models_file" "$base_url" "$key" "$user_email" "$user_name"
+      printf '%s\n' "$key" >"$pi_key_file"
+      chmod 600 "$pi_key_file"
+      ;;
+  esac
+}
+
+verify_install() {
+  if [ "$quiet" != "true" ]; then
+    if ! spin "Pinging $base_url/health" curl -fsS --max-time 5 "$base_url/health"; then
+      warn "Could not reach $base_url/health within 5s. Settings are written; verify the router is running."
+    fi
   fi
-  if [ -e "$dst_file" ] && { [ ! -f "$dst_file" ] || ! grep -Fq "$WEAVE_CODEX_SKILL_MARKER" "$dst_file"; }; then
-    warn "A user-owned Codex disable-routing skill already exists at $dst_file; leaving it untouched."
+
+  [ -n "$api_key" ] || return 0
+
+  spin "Validating API key" validate_key && return 0
+
+  # A key we read back off disk can have been revoked or rotated since it was
+  # installed, and reusing it silently would leave a broken install behind
+  # exactly where the old behavior (always prompt) would have fixed it. Ask
+  # once, then rewrite the config with whatever the user pastes. Anywhere a
+  # prompt isn't available — non-interactive, update, --quiet, no tty, or a
+  # key that didn't come from disk — keep the historical warn-and-continue.
+  if [ "$api_key_source" = "disk" ] && [ "$non_interactive" != "true" ] \
+     && [ "$quiet" != "true" ] && [ -r /dev/tty ]; then
+    warn "The router key already installed was rejected (revoked or rotated)."
+    prompt_for_key
+    rewrite_installed_key "$api_key"
+    if ! spin "Validating API key" validate_key; then
+      warn "Router rejected the API key (check it matches the dashboard at $base_url)."
+    fi
     return 0
   fi
-  mkdir -p "$dst_dir"
 
-  scope_args=""
-  if [ -n "$install_dir" ]; then
-    scope_args=" --dir $(printf '%q' "$install_dir")"
-  elif [ "$scope" = "project" ]; then
-    scope_args=" --scope project"
+  if [ "$mode" = "update" ]; then
+    # update is meant for cron/scripting: a rejected key is a real failure,
+    # not a note in the log. --quiet callers opted out of the noise, not out
+    # of the nonzero exit — a scheduled run that reports success here would
+    # hide a revoked key indefinitely.
+    if [ "$quiet" = "true" ]; then
+      warn "Router rejected the installed API key. Re-run the installer to set a new one."
+    else
+      err "Router rejected the installed API key. Re-run the installer to set a new one."
+    fi
+    exit 1
   fi
-  body="$(<"$skill_src")"
-  body="${body//\{\{SCOPE\}\}/$scope_args}"
-  printf '%s\n' "$body" >"$dst_file"
-  ok "Codex skill installed: \$disable-routing"
+
+  warn "Router rejected the API key (check it matches the dashboard at $base_url)."
+}
+
+# announce_done prints the closing line for the client named in $1. `update`
+# refreshed an existing install rather than creating one, so it says so and
+# skips the uninstall hint — that run was never the user's first contact with
+# the installer.
+announce_done() {
+  printf "\n"
+  if [ "$mode" = "update" ]; then
+    printf "%s✓%s %s%sWeave Router config refreshed for %s.%s\n" \
+      "$C_GREEN" "$C_RESET" "$C_BOLD" "$C_BRAND" "$1" "$C_RESET"
+    return 0
+  fi
+  printf "%s✓%s %s%sWeave Router installed for %s.%s\n" \
+    "$C_GREEN" "$C_RESET" "$C_BOLD" "$C_BRAND" "$1" "$C_RESET"
 }
 
 # ---------- codex install path (dispatch + exit before the Claude-only writes) ----------
 
+# Install the Codex lifecycle helper that reflects the active router and the
+# latest known routed model in the terminal title. The embedded copy keeps the
+# standalone curl installer feature-complete; packaged installs use the
+# canonical sibling asset.
+install_codex_status_script() {
+  local candidate status_src=""
+  for candidate in \
+    "$script_dir/codex-status.sh" \
+    "$script_dir/../codex-status.sh"
+  do
+    if [ -f "$candidate" ]; then
+      status_src="$candidate"
+      break
+    fi
+  done
+  if [ "$scope" = "user" ] && [ -z "$install_dir" ]; then
+    mkdir -p "$(dirname "$codex_status_file")"
+  else
+    refuse_if_symlink "$codex_status_file"
+  fi
+  if [ -e "$codex_status_file" ] && { [ ! -f "$codex_status_file" ] || ! grep -Fq '<!-- weave-router managed codex status -->' "$codex_status_file"; }; then
+    warn "A user-owned Codex status helper already exists at $codex_status_file; leaving it untouched."
+    return 1
+  fi
+  if [ -n "$status_src" ]; then
+    grep -Fq '<!-- weave-router managed codex status -->' "$status_src" || {
+      warn "Codex status helper has no ownership marker; leaving it unchanged."
+      return 1
+    }
+    cp "$status_src" "$codex_status_file"
+  else
+    cat >"$codex_status_file" <<'CODEX_STATUS_EOF'
+#!/usr/bin/env bash
+# <!-- weave-router managed codex status -->
+#
+# Codex lifecycle hook for the Weave Router. Codex passes a JSON object on
+# stdin; the Stop hook includes the last assistant message, which carries the
+# router's routed-model marker when the selected model changes. The helper
+# keeps the last known routed model per session and reflects it in the terminal
+# title, so the active router remains visible between turns without injecting
+# another message into the conversation.
+#
+# Savings come from the router, not from local arithmetic. Codex records its
+# own requested model on every turn and never the served one, so the per-turn
+# pricing the Claude Code statusline does cannot be reproduced here — it would
+# price both sides of the comparison at the same model and report zero. The
+# router already sums the real thing per session, so the hook fetches
+# GET <base>/v1/sessions/<id>/cost and renders what it returns. The fetch runs
+# in a detached subshell writing a cache the NEXT turn reads, so no turn ever
+# blocks on the network, and every failure path leaves the title model-only.
+
+set -euo pipefail
+
+state_root="${XDG_CACHE_HOME:-$HOME/.cache}/weave-router/codex"
+helper_dir="$(cd "$(dirname "$0")" 2>/dev/null && pwd -P)"
+disabled_marker="$helper_dir/.weave-router-disabled"
+router_badge_sentinel=$'⁣⁠⁣⁠'
+# Must stay verbatim in sync with install.sh / uninstall.sh: the endpoint read
+# below is scoped to this block so a key-shaped string elsewhere in the user's
+# config.toml is never adopted.
+codex_begin_marker="# >>> weave-router managed (do not edit between markers) >>>"
+codex_end_marker="# <<< weave-router managed <<<"
+
+emit_title() {
+  local title="$1"
+  if [ -n "${WEAVE_CODEX_STATUS_TITLE_FILE:-}" ]; then
+    printf '%s\n' "$title" >"$WEAVE_CODEX_STATUS_TITLE_FILE"
+  elif [ -w /dev/tty ]; then
+    printf '\033]0;%s\007' "$title" >/dev/tty
+  fi
+}
+
+safe_session_id() {
+  local id="$1"
+  case "$id" in
+    ''|*[!A-Za-z0-9._-]*) return 1 ;;
+  esac
+  [ "${#id}" -le 128 ] || return 1
+  printf '%s' "$id"
+}
+
+safe_display_value() {
+  printf '%s' "$1" | sed 's/[^A-Za-z0-9._:\/-]//g' | cut -c1-128
+}
+
+state_file_for() {
+  local id
+  id="$(safe_session_id "$1")" || return 1
+  printf '%s/%s.state' "$state_root" "$id"
+}
+
+read_state() {
+  local file="$1" key value
+  [ -f "$file" ] || return 0
+  while IFS='=' read -r key value; do
+    case "$key" in
+      routed_model) routed_model="$value" ;;
+    esac
+  done <"$file"
+}
+
+write_state() {
+  local file="$1" tmp
+  mkdir -p "$state_root"
+  chmod 700 "$state_root"
+  tmp="$(mktemp "$state_root/.state.XXXXXX")"
+  printf 'requested_model=%s\nrouted_model=%s\n' "$requested_model" "$routed_model" >"$tmp"
+  chmod 600 "$tmp"
+  mv "$tmp" "$file"
+}
+
+cost_file_for() {
+  local id
+  id="$(safe_session_id "$1")" || return 1
+  printf '%s/%s.cost' "$state_root" "$id"
+}
+
+# Reads the router base URL and key out of the Codex config this install owns.
+# Resolved from the helper's own location first so a project-scope install never
+# reads (or leaks) the user-scope key: the project helper lives in the same
+# .codex directory as its config, while the user-scope helper sits in ~/.weave
+# and reads ~/.codex. Values are scoped to the managed block so a key-shaped
+# string the user wrote elsewhere in the file is never adopted. awk, not a TOML
+# parser, because the Codex target deliberately does not require jq for config
+# reads.
+read_codex_endpoint() {
+  local config=""
+  # Project/custom installs name the helper weave-status.sh and keep it next
+  # to their config.toml. Falling through to ~/.codex would fetch another
+  # installation's session cost with that key. The user-scope helper
+  # (codex-status.sh in ~/.weave) has no adjacent config and owns HOME.
+  if [ -f "$helper_dir/config.toml" ]; then
+    config="$helper_dir/config.toml"
+  elif [ "$(basename "$0")" != "weave-status.sh" ] && [ -f "$HOME/.codex/config.toml" ]; then
+    config="$HOME/.codex/config.toml"
+  fi
+  [ -n "$config" ] || return 0
+  awk -v begin="$codex_begin_marker" -v end="$codex_end_marker" '
+    $0 == begin { inblk = 1; next }
+    $0 == end   { inblk = 0; next }
+    !inblk { next }
+    match($0, /base_url[[:space:]]*=[[:space:]]*"[^"]*"/) {
+      v = substr($0, RSTART, RLENGTH)
+      sub(/^.*=[[:space:]]*"/, "", v); sub(/"$/, "", v)
+      url = v
+    }
+    match($0, /"X-Weave-Router-Key"[[:space:]]*=[[:space:]]*"[^"]*"/) {
+      v = substr($0, RSTART, RLENGTH)
+      sub(/^.*=[[:space:]]*"/, "", v); sub(/"$/, "", v)
+      key = v
+    }
+    END { if (url != "" && key != "") printf "%s\n%s\n", url, key }
+  ' "$config" 2>/dev/null || true
+}
+
+# Kicks off a detached fetch of this session's committed cost. The result lands
+# in a cache the next turn reads; this turn renders whatever is already there.
+# Fire-and-forget on purpose — a slow or unreachable router must never stall a
+# Codex turn, and every failure simply leaves the previous cache in place.
+refresh_session_cost() {
+  local id="$1" file="$2"
+  [ "${WEAVE_CODEX_STATUS_SAVINGS:-1}" = "0" ] && return 0
+  command -v curl >/dev/null 2>&1 || return 0
+
+  local endpoint base_url key
+  endpoint="$(read_codex_endpoint)" || return 0
+  base_url="$(printf '%s' "$endpoint" | sed -n 1p)"
+  key="$(printf '%s' "$endpoint" | sed -n 2p)"
+  [ -n "$base_url" ] && [ -n "$key" ] || return 0
+
+  mkdir -p "$state_root" 2>/dev/null || return 0
+  chmod 700 "$state_root" 2>/dev/null || true
+
+  (
+    exec </dev/null
+    # mkdir is the portable atomic test-and-set. A crashed holder would block
+    # refreshes forever, so a lock older than the fetch timeout is reclaimed.
+    lock="$file.lock"
+    if ! mkdir "$lock" 2>/dev/null; then
+      lock_mtime="$(stat -c %Y "$lock" 2>/dev/null || stat -f %m "$lock" 2>/dev/null)" || lock_mtime=0
+      lock_now="$(date +%s 2>/dev/null)" || lock_now=0
+      if [ "${lock_mtime:-0}" -le 0 ] || [ $(( lock_now - lock_mtime )) -le 30 ]; then
+        exit 0
+      fi
+      rm -rf "$lock" 2>/dev/null
+      mkdir "$lock" 2>/dev/null || exit 0
+    fi
+    trap 'rmdir "$lock" 2>/dev/null' EXIT
+
+    # A file:// base is the offline/test seam: curl reads it as the response
+    # body directly, so the endpoint path is meaningless for it.
+    url="${base_url%/}"
+    case "$url" in
+      file://*) ;;
+      *) url="${url%/v1}/v1/sessions/$id/cost" ;;
+    esac
+    body="$(curl -fsS --max-time 5 -H "X-Weave-Router-Key: $key" "$url" 2>/dev/null)" || exit 0
+    # savings_usd is the router's own (requested - actual). A body without it
+    # (404, error envelope, older router) writes nothing and leaves the cache.
+    savings="$(printf '%s' "$body" | jq -r '.savings_usd // empty' 2>/dev/null)" || exit 0
+    case "$savings" in
+      ''|*[!0-9.eE+-]*) exit 0 ;;
+    esac
+    tmp="$file.tmp.$$"
+    mkdir -p "$(dirname "$file")" 2>/dev/null
+    if printf '%s' "$savings" >"$tmp" 2>/dev/null; then
+      chmod 600 "$tmp" 2>/dev/null
+      mv "$tmp" "$file" 2>/dev/null
+    fi
+    rm -f "$tmp" 2>/dev/null
+  ) >/dev/null 2>&1 &
+  disown 2>/dev/null || true
+}
+
+# Renders the cached savings as a display clause, or nothing. Values below a
+# cent read as "<$0.01" rather than "$0.00", which would be indistinguishable
+# from "the router ran and did not beat your selection". Negative totals are
+# omitted entirely: the router picked a pricier model for quality on this
+# session and "saved -$0.02" is a worse answer than staying quiet.
+savings_clause() {
+  local file="$1" raw
+  [ "${WEAVE_CODEX_STATUS_SAVINGS:-1}" = "0" ] && return 0
+  [ -f "$file" ] || return 0
+  raw="$(cat "$file" 2>/dev/null)" || return 0
+  case "$raw" in
+    ''|*[!0-9.eE+-]*) return 0 ;;
+  esac
+  awk -v v="$raw" 'BEGIN{
+    v = v + 0
+    if (v < 0.005) { exit }
+    if (v < 0.01)  { printf " · saved <$0.01"; exit }
+    printf " · saved $%.2f", v
+  }' 2>/dev/null || true
+}
+
+set -e
+
+case "${1:-hook}" in
+  --direct)
+    emit_title "Codex · direct"
+    exit 0
+    ;;
+  --on)
+    rm -f "$disabled_marker"
+    emit_title "Weave Router · active"
+    exit 0
+    ;;
+  --off)
+    [ ! -L "$disabled_marker" ] || exit 0
+    : >"$disabled_marker"
+    chmod 600 "$disabled_marker"
+    emit_title "Codex · direct"
+    exit 0
+    ;;
+esac
+
+payload="$(cat)"
+[ -n "$payload" ] || exit 0
+command -v jq >/dev/null 2>&1 || exit 0
+jq -e . >/dev/null 2>&1 <<<"$payload" || exit 0
+
+hook_event_name="$(jq -r '.hook_event_name // ""' <<<"$payload")"
+if [ "$hook_event_name" = "SessionStart" ]; then
+  if [ -f "$disabled_marker" ]; then
+    emit_title "Codex · direct"
+    jq -cn '{systemMessage:"Codex direct · Weave Router is off"}'
+  else
+    emit_title "Weave Router · active"
+    jq -cn '{systemMessage:"Weave Router active · routed model appears in the terminal title"}'
+  fi
+  exit 0
+fi
+
+if [ -f "$disabled_marker" ]; then
+  exit 0
+fi
+
+requested_model="$(safe_display_value "$(jq -r '.model // ""' <<<"$payload")")"
+routed_model=""
+session_id="$(jq -r '.session_id // ""' <<<"$payload")"
+last_assistant_message="$(jq -r '.last_assistant_message // ""' <<<"$payload")"
+
+file=""
+if file="$(state_file_for "$session_id" 2>/dev/null)"; then
+  read_state "$file"
+fi
+
+# The marker is intentionally matched only at the beginning of the assistant
+# message. Do not treat ordinary prose that mentions the heading as metadata.
+first_line="${last_assistant_message%%$'\n'*}"
+marker_model=""
+force_model=""
+case "$first_line" in
+  "${router_badge_sentinel}✦ **Weave Router** → "*)
+    marker_model="${first_line#"${router_badge_sentinel}✦ **Weave Router** → "}"
+    marker_model="${marker_model%% ·*}"
+    ;;
+  "✦ **Weave Router** → "*)
+    marker_model="${first_line#"✦ **Weave Router** → "}"
+    marker_model="${marker_model%% ·*}"
+    ;;
+esac
+case "$first_line" in
+  "Weave Router: force-model applied: "*" ("*)
+    force_model="${first_line#"Weave Router: force-model applied: "}"
+    force_model="${force_model%% (*}"
+    ;;
+esac
+if [ -n "$marker_model" ]; then
+  routed_model="$(safe_display_value "$marker_model")"
+elif [ -n "$force_model" ]; then
+  routed_model="$(safe_display_value "$force_model")"
+else
+  routed_model="$(safe_display_value "$routed_model")"
+fi
+
+if [ -n "$file" ]; then
+  write_state "$file"
+fi
+
+# The cache holds the previous turn's fetch; the refresh below serves the next
+# one. Router telemetry is written asynchronously anyway, so a just-finished
+# turn would not be included even in a blocking read — reading first and
+# refreshing after costs a turn of freshness and buys never blocking Codex.
+savings=""
+cost_file=""
+if cost_file="$(cost_file_for "$session_id" 2>/dev/null)"; then
+  savings="$(savings_clause "$cost_file")"
+  refresh_session_cost "$(safe_session_id "$session_id")" "$cost_file"
+fi
+
+if [ -n "$routed_model" ] && [ -n "$requested_model" ] && [ "$routed_model" != "$requested_model" ]; then
+  title="Weave Router · $routed_model ← $requested_model$savings"
+elif [ -n "$routed_model" ]; then
+  title="Weave Router · $routed_model$savings"
+elif [ -n "$requested_model" ]; then
+  title="Weave Router · active ← $requested_model$savings"
+else
+  title="Weave Router · active$savings"
+fi
+emit_title "$title"
+if [ -n "$marker_model" ] || [ -n "$force_model" ]; then
+  printf '%s' "$title" | jq -Rc '{systemMessage: .}'
+fi
+CODEX_STATUS_EOF
+  fi
+  chmod 700 "$codex_status_file"
+  "$codex_status_file" --on >/dev/null 2>&1 || true
+  ok "Codex status integration installed at $codex_status_file"
+}
+
 if [ "$target" = "codex" ]; then
+  if ! install_codex_status_script; then
+    err "Cannot install the Codex status helper safely; refusing to write hooks that could execute unowned code."
+    exit 1
+  fi
   write_codex_config "$codex_config_file" "$base_url" "$api_key" "$user_email" "$user_name"
   ok "Codex config written to $codex_config_file"
   remove_obsolete_codex_prompt_wrappers "$codex_dir/prompts"
-  install_codex_disable_routing_skill
+  install_codex_prompt_skills
   info "Codex router directives: begin the message with one space, e.g. ' /force-model gpt-5.6-terra'."
 
   # Project scope: ensure the per-teammate config (which holds the router key)
@@ -2065,44 +3500,26 @@ if [ "$target" = "codex" ]; then
     gitignore="$git_root/.gitignore"
     refuse_if_symlink "$gitignore"
     for entry in \
-      ".codex/config.toml"
+      ".codex/config.toml" \
+      ".codex/weave-status.sh" \
+      ".codex/.weave-router-disabled"
     do
       if [ ! -f "$gitignore" ] || ! grep -qxF "$entry" "$gitignore"; then
         printf '%s\n' "$entry" >>"$gitignore"
       fi
     done
-    ok "Updated $gitignore (ignored .codex/config.toml)"
-  fi
-
-  # Post-install verification: same probes the Claude path runs so a working
-  # install gives the same green checks regardless of target.
-  if [ "$quiet" != "true" ]; then
-    if ! spin "Pinging $base_url/health" curl -fsS --max-time 5 "$base_url/health"; then
-      warn "Could not reach $base_url/health within 5s. Settings are written; verify the router is running."
-    fi
+    ok "Updated $gitignore (ignored Codex router config and status helper)"
   fi
 
-  if [ -n "$api_key" ]; then
-    # Pass the router key via stdin (`@-`) instead of -H so it never lands in
-    # the process arg list. Mirrors the Claude-path validate logic.
-    validate_codex_key() {
-      printf '%s: %s\n' "$router_key_header" "$api_key" \
-        | curl -fsS --max-time 5 --header @- "$base_url/validate"
-    }
-    if ! spin "Validating API key" validate_codex_key; then
-      warn "Router rejected the API key (check it matches the dashboard at $base_url/ui/)."
-    fi
-  fi
+  verify_install
 
-  printf "\n"
-  printf "%s✓%s %s%sWeave Router installed for Codex.%s\n" \
-    "$C_GREEN" "$C_RESET" "$C_BOLD" "$C_BRAND" "$C_RESET"
+  announce_done "Codex"
   if [ "$scope" = "project" ] || [ -n "$install_dir" ]; then
     # Codex auto-discovers ~/.codex; for non-user installs the caller has to
     # point CODEX_HOME at the directory we wrote so Codex finds our config.
     info "Run Codex with CODEX_HOME=$codex_dir codex so it picks up this config."
   fi
-  print_uninstall_hint
+  [ "$mode" = "update" ] || print_uninstall_hint
   exit 0
 fi
 
@@ -2150,26 +3567,9 @@ if [ "$target" = "opencode" ]; then
     info "opencode restart required for commands to take effect."
   fi
 
-  # Post-install verification: same probes the Claude/Codex paths run.
-  if [ "$quiet" != "true" ]; then
-    if ! spin "Pinging $base_url/health" curl -fsS --max-time 5 "$base_url/health"; then
-      warn "Could not reach $base_url/health within 5s. Settings are written; verify the router is running."
-    fi
-  fi
+  verify_install
 
-  if [ -n "$api_key" ]; then
-    validate_opencode_key() {
-      printf '%s: %s\n' "$router_key_header" "$api_key" \
-        | curl -fsS --max-time 5 --header @- "$base_url/validate"
-    }
-    if ! spin "Validating API key" validate_opencode_key; then
-      warn "Router rejected the API key (check it matches the dashboard at $base_url/ui/)."
-    fi
-  fi
-
-  printf "\n"
-  printf "%s✓%s %s%sWeave Router installed for opencode.%s\n" \
-    "$C_GREEN" "$C_RESET" "$C_BOLD" "$C_BRAND" "$C_RESET"
+  announce_done "opencode"
   # Surface the optional subscription-routing path only when this run actually
   # registered the weave-claude login provider (which is written together with
   # the plugin). Gate on its presence in the written config (authoritative)
@@ -2184,7 +3584,7 @@ if [ "$target" = "opencode" ]; then
     # has to point opencode at the file explicitly.
     info "Run opencode with OPENCODE_CONFIG=$opencode_config_file opencode."
   fi
-  print_uninstall_hint
+  [ "$mode" = "update" ] || print_uninstall_hint
   exit 0
 fi
 
@@ -2225,26 +3625,13 @@ if [ "$target" = "pi" ]; then
     ok "Updated $gitignore (ignored repo-local .pi router config)"
   fi
 
-  # Post-install verification: same probes the Claude/Codex/opencode paths run.
-  if [ "$quiet" != "true" ]; then
-    if ! spin "Pinging $base_url/health" curl -fsS --max-time 5 "$base_url/health"; then
-      warn "Could not reach $base_url/health within 5s. Settings are written; verify the router is running."
-    fi
-  fi
+  verify_install
 
-  if [ -n "$api_key" ]; then
-    validate_pi_key() {
-      printf '%s: %s\n' "$router_key_header" "$api_key" \
-        | curl -fsS --max-time 5 --header @- "$base_url/validate"
-    }
-    if ! spin "Validating API key" validate_pi_key; then
-      warn "Router rejected the API key (check it matches the dashboard at $base_url/ui/)."
-    fi
+  if [ -n "$lsp_langs" ]; then
+    install_lsp_servers "$lsp_langs"
   fi
 
-  printf "\n"
-  printf "%s✓%s %s%sWeave Router installed for pi.%s\n" \
-    "$C_GREEN" "$C_RESET" "$C_BOLD" "$C_BRAND" "$C_RESET"
+  announce_done "pi"
   # Billing note: pi normally draws on a Claude subscription (OAuth); routing
   # through the router switches to per-token billing on the router deployment
   # key (or BYOK). Surface it at install so the change isn't a surprise.
@@ -2252,7 +3639,7 @@ if [ "$target" = "pi" ]; then
   if [ "$scope" = "project" ] || [ -n "$install_dir" ]; then
     info "Run pi with PI_CODING_AGENT_DIR=$pi_dir pi so it picks up this config."
   fi
-  print_uninstall_hint
+  [ "$mode" = "update" ] || print_uninstall_hint
   exit 0
 fi
 
@@ -2277,9 +3664,9 @@ cat > "$statusline_file" << 'STATUSLINE_EOF'
 # Renders:
 #   WEAVE ROUTER — claude-sonnet-4-5 ← claude-opus-4-7 · saved $1.23 · 12.4k in / 3.1k out / 45.2k cached
 #
-# Pricing source of truth: router/eval/pricing.py. Keep these maps in lockstep
-# when prices change. Cache multipliers (1.25× / 0.1×) follow Anthropic's
-# published cache pricing and are stable across the Claude family.
+# Pricing source of truth: internal/router/catalog. Input/output prices and
+# cache-read multipliers are generated by cmd/genprices. Cache creation remains
+# at 1.25× input pending TTL-aware pricing.
 
 set -euo pipefail
 
@@ -2420,6 +3807,23 @@ weave_command_tracked_by_git() {
   git -C "$(dirname "$1")" ls-files --error-unmatch -- "$1" >/dev/null 2>&1
 }
 
+# weave_installed_command_names lists the wrappers this install may refresh.
+# The statusline ships standalone (no registry.sh beside it), so the installed
+# set — itself written from the registry — is the only source of truth here.
+#
+# Files written before ownership markers existed carry none, so matching on the
+# marker alone would freeze every pre-marker install out of refreshes forever.
+# List every wrapper instead and let the baseline comparison below decide: a
+# file is replaced only when its bytes still match the last canonical copy, so
+# a user-authored command is never touched whether or not it carries a marker.
+weave_installed_command_names() {
+  local dir="$1" file
+  for file in "$dir"/*.md; do
+    [ -f "$file" ] || continue
+    printf '%s\n' "$(basename "$file" .md)"
+  done
+}
+
 # weave_render_command prints $1 with the installer's {{SCOPE}} placeholder
 # replaced by $2, matching how install_slash_commands writes the same file.
 # Trailing newlines are stripped on both sides of every comparison below.
@@ -2489,8 +3893,7 @@ weave_sync_commands() {
     # Detach stdin (CC pipes JSON to us) so curl can't consume it, and silence
     # everything so no output leaks into the statusline.
     exec </dev/null
-    for name in force-model unforce-model router-feedback fm ufm rf \
-                router-off router-on router-status router-session; do
+    while IFS= read -r name; do
       installed="$cmd_dir/$name.md"
       # Only ever refresh a wrapper that is already installed: a missing one
       # was uninstalled or deliberately deleted, and resurrecting it would be
@@ -2519,10 +3922,10 @@ weave_sync_commands() {
       if [ -f "$prev" ]; then
         new_body="$(weave_render_command "$raw" "$scope_args")"
         prev_body="$(weave_render_command "$prev" "$scope_args")"
-        installed_body="$(cat "$installed" 2>/dev/null)" || installed_body=""
+        installed_body="$(cat "$installed" 2>/dev/null | sed '/^<!-- weave-router managed command: .* -->$/d')" || installed_body=""
         if [ "$prev_body" = "$installed_body" ] && [ "$new_body" != "$installed_body" ]; then
           tmp="$installed.tmp.$$"
-          if printf '%s\n' "$new_body" >"$tmp" 2>/dev/null; then
+          if printf '%s\n<!-- weave-router managed command: %s -->' "$new_body" "$name" >"$tmp" 2>/dev/null; then
             mv "$tmp" "$installed" 2>/dev/null || rm -f "$tmp"
           else
             rm -f "$tmp"
@@ -2530,13 +3933,152 @@ weave_sync_commands() {
         fi
       fi
       mv "$raw" "$prev" 2>/dev/null || rm -f "$raw"
-    done
+    done <<EOF
+$(weave_installed_command_names "$cmd_dir")
+EOF
   ) >/dev/null 2>&1 &
   disown 2>/dev/null || true
   return 0
 }
 weave_sync_commands 2>/dev/null || true
 
+# ---------- org "hide terminal surfaces" gate ----------
+#
+# When the org has hidden the router's terminal surfaces, the statusline
+# renders nothing: this prints no output and exits 0, leaving the slot blank.
+# The setting comes from GET /v1/display-settings with the install's own
+# router key, but the foreground path NEVER touches the network: it decides
+# solely from a per-install cache file (TTL WEAVE_DISPLAY_SETTINGS_TTL_SECONDS,
+# default 1h), and a missing or stale cache fails open — the statusline
+# renders normally. When the cache is missing or stale a detached background
+# refresh re-fetches the setting and rewrites the cache atomically, so the
+# next turn picks up the fresh value; a refresh failure simply leaves the
+# cache stale, which keeps failing open rather than pinning the gate closed.
+#
+# Claude Code runs the statusline every turn, so several invocations can see a
+# stale cache at once. Letting each fetch independently is not safe: the
+# responses can land out of order, and the loser's mv would replace a newer
+# setting with an older one AND stamp it fresh, pinning the gate on a stale
+# value for a full TTL. Refreshes are therefore serialized per cache key on a
+# mkdir mutex (atomic everywhere; flock is absent on macOS), held across both
+# the fetch and the write. A refresh that finds the mutex held exits rather
+# than queueing — the in-flight one is at least as fresh as anything it would
+# fetch, so waiting only to overwrite it is the bug. The one path that is not
+# strictly exclusive is reclaiming a lock whose holder died; see below.
+weave_hidden_gate() {
+  command -v curl >/dev/null 2>&1 || return 1
+  command -v jq >/dev/null 2>&1 || return 1
+
+  local cache_dir="${XDG_CACHE_HOME:-$HOME/.cache}/weave-router"
+  mkdir -p "$cache_dir" 2>/dev/null || return 1
+  local self="${BASH_SOURCE[0]:-$0}"
+  local script_slug
+  script_slug="$(printf '%s' "$self" | tr -c 'A-Za-z0-9._-' '_')"
+  local cache="$cache_dir/display-settings${script_slug}"
+  local ttl="${WEAVE_DISPLAY_SETTINGS_TTL_SECONDS:-3600}"
+
+  local now mtime fresh="false"
+  now="$(date +%s 2>/dev/null)" || now=0
+  if [ -f "$cache" ]; then
+    mtime="$(stat -c %Y "$cache" 2>/dev/null || stat -f %m "$cache" 2>/dev/null)" || mtime=0
+    if [ -n "${mtime:-}" ] && [ "$mtime" -gt 0 ] && [ $(( now - mtime )) -lt "$ttl" ]; then
+      fresh="true"
+    fi
+  fi
+
+  # Foreground decision: only a fresh cache hides the surfaces. Anything else
+  # (no cache, stale cache, unreadable cache) renders normally so a slow or
+  # unreachable router can never stall a turn or wedge the statusline blank.
+  if [ "$fresh" = "true" ]; then
+    [ "$(cat "$cache" 2>/dev/null)" = "1" ]
+    return
+  fi
+
+  # Background refresh for the next invocation. Resolve the router base URL
+  # and key inside the subshell from the Claude Code settings the installer
+  # wrote: project/--dir installs put both under <base>/.claude alongside
+  # this script (key in settings.local.json), while a user-scope install
+  # lives under ~/.weave and reads ~/.claude. Resolve relative to the
+  # script's own location, falling back to user scope, so a project install
+  # never reads (or leaks) the user-scope key. ANTHROPIC_BASE_URL and
+  # WEAVE_ROUTER_BASE_URL may also be set in the environment. A file:// base
+  # URL is the offline/test seam: curl reads it as the response body
+  # directly, so the endpoint path is meaningless for it; real router URLs
+  # (https) get /v1/display-settings appended.
+  (
+    exec </dev/null
+
+    # Take the per-cache-key mutex, or bail. mkdir is the portable atomic
+    # test-and-set. A crashed holder would otherwise block refreshes forever,
+    # so a lock older than the fetch timeout is treated as abandoned and
+    # reclaimed. Releasing from a trap covers every exit path below.
+    lock="$cache.lock"
+    if ! mkdir "$lock" 2>/dev/null; then
+      lock_mtime="$(stat -c %Y "$lock" 2>/dev/null || stat -f %m "$lock" 2>/dev/null)" || lock_mtime=0
+      lock_now="$(date +%s 2>/dev/null)" || lock_now=0
+      if [ "${lock_mtime:-0}" -le 0 ] || [ $(( lock_now - lock_mtime )) -le 30 ]; then
+        exit 0
+      fi
+      # Reclaiming an abandoned lock must not be delete-then-recreate. With
+      # `rm -rf` + `mkdir`, refreshers that all see the same stale lock each
+      # delete the next one's freshly created directory, so many end up holding
+      # it at once (measured at 50 claimants: 4-11 concurrent holders) and their
+      # writes can land out of order. Renaming is atomic, so only one racer can
+      # move a given directory aside and the losers exit instead of clobbering
+      # the winner (same measurement: 1-2). It is not a perfect mutex — a
+      # straggler can still reclaim the new lock a winner just created, since
+      # nothing distinguishes it from the stale one — but real refreshes arrive
+      # one per turn rather than 50 at once, and the staleness threshold below
+      # is what bounds the rest.
+      dead="$lock.dead.$$"
+      mv "$lock" "$dead" 2>/dev/null || exit 0
+      rm -rf "$dead" 2>/dev/null
+      mkdir "$lock" 2>/dev/null || exit 0
+    fi
+    trap 'rmdir "$lock" 2>/dev/null' EXIT
+
+    self_dir="$(cd "$(dirname "$self")" 2>/dev/null && pwd)"
+    settings_base="$HOME"
+    case "$self_dir" in
+      */.claude) settings_base="${self_dir%/.claude}" ;;
+    esac
+    settings="$settings_base/.claude/settings.json"
+    local_settings="$settings_base/.claude/settings.local.json"
+    base_url="${WEAVE_ROUTER_BASE_URL:-${ANTHROPIC_BASE_URL:-}}"
+    key="${WEAVE_ROUTER_KEY:-}"
+    if [ -z "$key" ] && [ -f "$settings" ]; then
+      key="$(jq -r '.env.ANTHROPIC_CUSTOM_HEADERS // "" | split("\n")[] | select(startswith("X-Weave-Router-Key:")) | sub("^X-Weave-Router-Key:[[:space:]]*";"")' "$settings" 2>/dev/null | head -n1)"
+    fi
+    if [ -z "$key" ] && [ -f "$local_settings" ]; then
+      key="$(jq -r '.env.ANTHROPIC_CUSTOM_HEADERS // "" | split("\n")[] | select(startswith("X-Weave-Router-Key:")) | sub("^X-Weave-Router-Key:[[:space:]]*";"")' "$local_settings" 2>/dev/null | head -n1)"
+    fi
+    if [ -z "$base_url" ] && [ -f "$settings" ]; then
+      base_url="$(jq -r '.env.ANTHROPIC_BASE_URL // empty' "$settings" 2>/dev/null)"
+    fi
+    [ -n "$base_url" ] && [ -n "$key" ] || exit 0
+    url="${base_url%/}"
+    case "$url" in
+      file://*) ;;
+      *) url="$url/v1/display-settings" ;;
+    esac
+    body="$(curl -fsS --max-time 5 -H "X-Weave-Router-Key: $key" "$url" 2>/dev/null)" || exit 0
+    hidden="$(printf '%s' "$body" | jq -r '.hide_terminal_surfaces // false' 2>/dev/null)"
+    tmp="$cache.tmp.$$"
+    if [ "$hidden" = "true" ]; then
+      printf '1' >"$tmp" 2>/dev/null && mv "$tmp" "$cache" 2>/dev/null
+    else
+      printf '0' >"$tmp" 2>/dev/null && mv "$tmp" "$cache" 2>/dev/null
+    fi
+    rm -f "$tmp" 2>/dev/null
+  ) >/dev/null 2>&1 &
+  disown 2>/dev/null || true
+  return 1
+}
+
+if weave_hidden_gate </dev/null; then
+  exit 0
+fi
+
 input="$(cat)"
 transcript_path="$(printf '%s' "$input" | jq -r '.transcript_path // empty')"
 # Prefer model.id over display_name: pricing keys + the routed model id in
@@ -2577,6 +4119,7 @@ prices='{
     "claude-sonnet-5":                  0.003,
     "deepseek/deepseek-v4-flash":       0.0001134,
     "deepseek/deepseek-v4-pro":         0.00174,
+    "deepseek/deepseek-v4-pro-0813":    0.00174,
     "gemini-2.0-flash":                 0.0001,
     "gemini-2.0-flash-lite":            0.000075,
     "gemini-2.5-flash":                 0.0003,
@@ -2589,6 +4132,7 @@ prices='{
     "gemini-3.5-flash":                 0.0015,
     "gemini-3.5-flash-lite":            0.0003,
     "gemini-3.6-flash":                 0.0015,
+    "gemini-3.7-flash":                 0.0015,
     "google/gemma-4-26b-a4b-it":        0.00015,
     "gpt-4.1":                          0.002,
     "gpt-4.1-mini":                     0.0004,
@@ -2608,7 +4152,9 @@ prices='{
     "gpt-5.5-nano":                     0.00015,
     "gpt-5.5-pro":                      0.03,
     "gpt-5.6-luna":                     0.001,
+    "gpt-5.6-luna-pro":                 0.001,
     "gpt-5.6-sol":                      0.005,
+    "gpt-5.6-sol-pro":                  0.005,
     "gpt-5.6-terra":                    0.0025,
     "grok-4.5":                         0.002,
     "grok-4.6":                         0.002,
@@ -2631,7 +4177,9 @@ prices='{
     "xiaomi/mimo-v2.5-pro":             0.001,
     "z-ai/glm-5":                       0.001,
     "z-ai/glm-5.1":                     0.0014,
-    "z-ai/glm-5.2":                     0.0014
+    "z-ai/glm-5.2":                     0.0014,
+    "z-ai/glm-5.3":                     0.0014,
+    "z-ai/glm-5.3-flash":               0.00015
   },
   "output": {
     "claude-fable-5":                   0.05,
@@ -2648,6 +4196,7 @@ prices='{
     "claude-sonnet-5":                  0.015,
     "deepseek/deepseek-v4-flash":       0.0002791,
     "deepseek/deepseek-v4-pro":         0.00348,
+    "deepseek/deepseek-v4-pro-0813":    0.00348,
     "gemini-2.0-flash":                 0.0004,
     "gemini-2.0-flash-lite":            0.0003,
     "gemini-2.5-flash":                 0.0012,
@@ -2660,6 +4209,7 @@ prices='{
     "gemini-3.5-flash":                 0.009,
     "gemini-3.5-flash-lite":            0.0025,
     "gemini-3.6-flash":                 0.0075,
+    "gemini-3.7-flash":                 0.0075,
     "google/gemma-4-26b-a4b-it":        0.0006,
     "gpt-4.1":                          0.008,
     "gpt-4.1-mini":                     0.0016,
@@ -2679,7 +4229,9 @@ prices='{
     "gpt-5.5-nano":                     0.0006,
     "gpt-5.5-pro":                      0.18,
     "gpt-5.6-luna":                     0.006,
+    "gpt-5.6-luna-pro":                 0.006,
     "gpt-5.6-sol":                      0.03,
+    "gpt-5.6-sol-pro":                  0.03,
     "gpt-5.6-terra":                    0.015,
     "grok-4.5":                         0.006,
     "grok-4.6":                         0.006,
@@ -2702,7 +4254,86 @@ prices='{
     "xiaomi/mimo-v2.5-pro":             0.003,
     "z-ai/glm-5":                       0.0032,
     "z-ai/glm-5.1":                     0.0044,
-    "z-ai/glm-5.2":                     0.0044
+    "z-ai/glm-5.2":                     0.0044,
+    "z-ai/glm-5.3":                     0.0044,
+    "z-ai/glm-5.3-flash":               0.0005
+  },
+  "cache_read": {
+    "claude-fable-5":                   0.1,
+    "claude-haiku-4-5":                 0.1,
+    "claude-opus-4-0":                  0.1,
+    "claude-opus-4-1":                  0.1,
+    "claude-opus-4-5":                  0.1,
+    "claude-opus-4-6":                  0.1,
+    "claude-opus-4-7":                  0.1,
+    "claude-opus-4-8":                  0.1,
+    "claude-opus-5":                    0.1,
+    "claude-sonnet-4-5":                0.1,
+    "claude-sonnet-4-6":                0.1,
+    "claude-sonnet-5":                  0.1,
+    "deepseek/deepseek-v4-flash":       0.2,
+    "deepseek/deepseek-v4-pro":         0.11494252873563218,
+    "deepseek/deepseek-v4-pro-0813":    0.11494252873563218,
+    "gemini-2.0-flash":                 0.25,
+    "gemini-2.0-flash-lite":            0.25,
+    "gemini-2.5-flash":                 0.1,
+    "gemini-2.5-flash-lite":            0.1,
+    "gemini-2.5-pro":                   0.1,
+    "gemini-3-flash-preview":           0.1,
+    "gemini-3-pro-preview":             0.1,
+    "gemini-3.1-flash-lite-preview":    0.1,
+    "gemini-3.1-pro-preview":           0.1,
+    "gemini-3.5-flash":                 0.1,
+    "gemini-3.5-flash-lite":            0.1,
+    "gemini-3.6-flash":                 0.1,
+    "gemini-3.7-flash":                 0.1,
+    "google/gemma-4-26b-a4b-it":        0.1,
+    "gpt-4.1":                          0.25,
+    "gpt-4.1-mini":                     0.25,
+    "gpt-4.1-nano":                     0.25,
+    "gpt-4o":                           0.5,
+    "gpt-4o-mini":                      0.5,
+    "gpt-5":                            0.1,
+    "gpt-5-chat":                       0.1,
+    "gpt-5-mini":                       0.1,
+    "gpt-5-nano":                       0.1,
+    "gpt-5.4":                          0.1,
+    "gpt-5.4-mini":                     0.1,
+    "gpt-5.4-nano":                     0.1,
+    "gpt-5.4-pro":                      1,
+    "gpt-5.5":                          0.1,
+    "gpt-5.5-mini":                     0.1,
+    "gpt-5.5-nano":                     0.1,
+    "gpt-5.5-pro":                      1,
+    "gpt-5.6-luna":                     0.1,
+    "gpt-5.6-luna-pro":                 0.1,
+    "gpt-5.6-sol":                      0.1,
+    "gpt-5.6-sol-pro":                  0.1,
+    "gpt-5.6-terra":                    0.1,
+    "grok-4.5":                         0.25,
+    "grok-4.6":                         0.25,
+    "minimax/minimax-m2.7":             0.2,
+    "minimax/minimax-m3":               0.2,
+    "mistralai/mistral-small-2603":     0.1,
+    "moonshotai/kimi-k2.5":             0.5,
+    "moonshotai/kimi-k2.6":             0.1684,
+    "moonshotai/kimi-k2.7":             0.2,
+    "moonshotai/kimi-k3":               0.1,
+    "qwen/qwen3-235b-a22b-2507":        0.5,
+    "qwen/qwen3-30b-a3b-instruct-2507": 0.1684,
+    "qwen/qwen3-coder":                 0.1684,
+    "qwen/qwen3-coder-next":            0.5,
+    "qwen/qwen3-next-80b-a3b-instruct": 0.5,
+    "qwen/qwen3.5-flash-02-23":         0.1,
+    "qwen/qwen3.6-35b-a3b":             0.1,
+    "qwen/qwen3.7-plus":                0.2,
+    "qwen/qwen3.8-max":                 0.125,
+    "xiaomi/mimo-v2.5-pro":             0.1,
+    "z-ai/glm-5":                       0.2,
+    "z-ai/glm-5.1":                     0.18571428571428572,
+    "z-ai/glm-5.2":                     0.18571428571428572,
+    "z-ai/glm-5.3":                     0.18571428571428572,
+    "z-ai/glm-5.3-flash":               0.2
   }
 }'
 # END_GENERATED_PRICES
@@ -2757,6 +4388,12 @@ if [[ -n "$transcript_path" && -f "$transcript_path" ]]; then
   #   * unrecognized model        → "… isn't a recognized model · keeping
   #                                  automatic routing" — a NO-OP: the prior
   #                                  pin, if any, is left untouched
+  #   * listing (historical)      → "… pick a model by id …" / "no models are
+  #                                  available to pin …" — also NO-OPs. The
+  #                                  router no longer emits these, but a
+  #                                  transcript written while it did still
+  #                                  carries them, and they must not read as
+  #                                  a clear or a live pin loses its [forced]
   # These persist on disk (the ingress stripper only scrubs them from upstream
   # requests). Classify each weave-router turn newest-first, skip the no-op
   # "rejected" acks, and let the latest real state change decide: an "applied"
@@ -2770,6 +4407,7 @@ if [[ -n "$transcript_path" && -f "$transcript_path" ]]; then
         | ([.message.content[]? | select(.type? == "text") | .text] | join(" ") | gsub("[\n\r]"; " ")) as $t
         | if ($t | test("force-model applied:")) then "APPLIED " + ($t | capture("force-model applied: (?<m>[^ ]+)").m)
           elif ($t | test("isn.t a recognized model")) then "REJECTED"
+          elif ($t | test("pick a model by id|no models are available to pin")) then "REJECTED"
           else "CLEARED" end' 2>/dev/null \
     | grep -m1 -v '^REJECTED$' || true)"
   if [[ "$force_state" == APPLIED\ * ]]; then
@@ -2780,12 +4418,9 @@ if [[ -n "$transcript_path" && -f "$transcript_path" ]]; then
   # Compute a session running total: savings across every assistant turn
   # whose marker reports a requested ≠ routed swap, plus cumulative token
   # counts across every assistant turn (rerouted or not — total work the
-  # session has done). cache_creation is priced at 1.25× input, cache_read
-  # at 0.1× — both ratios are stable across the Claude family and a no-op
-  # when the provider doesn't return those fields. Cache reads ARE included
-  # in the savings comparison: both costs apply the same 0.1× weight to
-  # cache_read_input_tokens, so the delta reflects the model-price
-  # difference on the cached portion as well.
+  # session has done). cache_creation is priced at 1.25× input; cache_read
+  # uses each model's generated catalog multiplier. Both are no-ops when the
+  # provider does not return those fields.
   #
   # The marker regex tolerates the optional "(<provider>)" segment and a
   # `[1m]` / `-YYYYMMDD` suffix on either model name so transcripts written
@@ -2818,14 +4453,17 @@ if [[ -n "$transcript_path" && -f "$transcript_path" ]]; then
       } as $t |
       (if $requested == "" or $requested == $rm then 0
        else
-         ($p.input[$rm] // null)        as $rin  | ($p.output[$rm] // null)        as $rout |
-         ($p.input[$requested] // null) as $sin  | ($p.output[$requested] // null) as $sout |
-         if ($rin == null or $rout == null or $sin == null or $sout == null) then 0
+         ($p.input[$rm] // null)             as $rin  | ($p.output[$rm] // null)             as $rout |
+         ($p.cache_read[$rm] // null)        as $rcr  |
+         ($p.input[$requested] // null)      as $sin  | ($p.output[$requested] // null)      as $sout |
+         ($p.cache_read[$requested] // null) as $scr  |
+         if ($rin == null or $rout == null or $rcr == null or $sin == null or $sout == null or $scr == null) then 0
          else
-           (($t.in + 1.25 * $t.cwrt + 0.1 * $t.crd) / 1000) as $input_units |
-           ($t.out / 1000)                                  as $output_units |
-           ($input_units * $rin + $output_units * $rout)    as $routed_cost |
-           ($input_units * $sin + $output_units * $sout)    as $requested_cost |
+           (($t.in + 1.25 * $t.cwrt + $rcr * $t.crd) / 1000) as $routed_input_units |
+           (($t.in + 1.25 * $t.cwrt + $scr * $t.crd) / 1000) as $requested_input_units |
+           ($t.out / 1000)                                    as $output_units |
+           ($routed_input_units * $rin + $output_units * $rout)       as $routed_cost |
+           ($requested_input_units * $sin + $output_units * $sout)    as $requested_cost |
            ($requested_cost - $routed_cost)
          end
        end) as $savings |
@@ -3034,8 +4672,8 @@ write_claude_settings() {
   ok "Settings written to $settings_file"
 
   if [ "$scope" = "project" ] && [ -z "$install_dir" ]; then
-    jq -n --arg header "$custom_headers" '{
-      env: { ANTHROPIC_CUSTOM_HEADERS: $header }
+    jq -n --arg header "$custom_headers" --arg router_url "$base_url" '{
+      env: { ANTHROPIC_CUSTOM_HEADERS: $header, WEAVE_ROUTER_BASE_URL: $router_url }
     }' >"$tmp_patch"
     if [ -f "$local_settings_file" ]; then
       # Also strip ANTHROPIC_BASE_URL: `off` in project scope points this file
@@ -3097,61 +4735,9 @@ fi
 
 # ---------- post-install verification ----------
 
-if [ "$quiet" != "true" ]; then
-  if ! spin "Pinging $base_url/health" curl -fsS --max-time 5 "$base_url/health"; then
-    warn "Could not reach $base_url/health within 5s. Settings are written; verify the router is running."
-  fi
-fi
-
-if [ -n "$api_key" ]; then
-  # Pass the router key via stdin (`@-`) instead of a -H argument so the key
-  # never appears in the process arg list (visible via `ps` / /proc to other
-  # local users on shared machines). We feed stdin via a small wrapper so the
-  # spinner's exec form sees a single command argv.
-  validate_key() {
-    printf '%s: %s\n' "$router_key_header" "$api_key" \
-      | curl -fsS --max-time 5 --header @- "$base_url/validate"
-  }
-  if ! spin "Validating API key" validate_key; then
-    # A key we read back off disk can have been revoked or rotated since it was
-    # installed, and reusing it silently would leave a broken install behind
-    # exactly where the old behavior (always prompt) would have fixed it. Ask
-    # once, then rewrite the settings with whatever the user pastes. Anywhere a
-    # prompt isn't available — non-interactive, update, --quiet, no tty, or a
-    # key that didn't come from disk — keep the historical warn-and-continue.
-    if [ "$api_key_source" = "disk" ] && [ "$non_interactive" != "true" ] \
-       && [ "$quiet" != "true" ] && [ -r /dev/tty ]; then
-      warn "The router key already installed was rejected (revoked or rotated)."
-      prompt_for_key
-      write_claude_settings "$api_key"
-      if ! spin "Validating API key" validate_key; then
-        warn "Router rejected the API key (check it matches the dashboard at $base_url)."
-      fi
-    elif [ "$mode" = "update" ]; then
-      # update is meant for cron/scripting: a rejected key is a real failure,
-      # not a note in the log. --quiet callers opted out of the noise, not out
-      # of the nonzero exit — a scheduled run that reports success here would
-      # hide a revoked key indefinitely.
-      if [ "$quiet" = "true" ]; then
-        warn "Router rejected the installed API key. Re-run the installer to set a new one."
-      else
-        err "Router rejected the installed API key. Re-run the installer to set a new one."
-      fi
-      exit 1
-    else
-      warn "Router rejected the API key (check it matches the dashboard at $base_url)."
-    fi
-  fi
-fi
+verify_install
 
 # ---------- done ----------
 
-printf "\n"
-if [ "$mode" = "update" ]; then
-  printf "%s✓%s %s%sWeave Router config refreshed for Claude Code.%s\n" \
-    "$C_GREEN" "$C_RESET" "$C_BOLD" "$C_BRAND" "$C_RESET"
-  exit 0
-fi
-printf "%s✓%s %s%sWeave Router installed for Claude Code.%s\n" \
-  "$C_GREEN" "$C_RESET" "$C_BOLD" "$C_BRAND" "$C_RESET"
-print_uninstall_hint
+announce_done "Claude Code"
+[ "$mode" = "update" ] || print_uninstall_hint