@workweave/router 0.2.9 → 0.2.11

package/install.sh

@@ -37,14 +37,23 @@
 #   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
 #   npx @workweave/router --base-url http://localhost:8080 # self-hosted, custom port
 #   npx @workweave/router --non-interactive                # require WEAVE_ROUTER_KEY env var (defaults target to claude)
 #   npx @workweave/router --quiet                          # suppress banner, ping check, and trailing tips
+#   npx @workweave/router --rotate-key                     # ignore the installed key and prompt for a new one
 #   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:
+#   npx @workweave/router update --claude                  # refresh the Claude Code install in place
+#
 # 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
 # explicit client (--claude / --codex / --opencode); they only flip config
@@ -57,6 +66,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
 
@@ -71,6 +102,7 @@ scope="user"
 scope_explicit="false"
 install_dir=""
 base_url=""
+base_url_explicit="false"
 non_interactive="false"
 quiet="false"
 router_key_header="X-Weave-Router-Key"
@@ -86,12 +118,33 @@ router_key_header="X-Weave-Router-Key"
 target="claude"
 target_explicit="false"
 
-# Operation mode. "install" (default) writes/refreshes config. "off"/"on"/
+# Operation mode. "install" (default) writes/refreshes config. "update" is a
+# 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"
+# Where $api_key came from: env | disk | prompt. Drives the fallback re-prompt
+# when /validate rejects a key we read back off disk.
+api_key_source=""
+
 # ---------- helpers ----------
 
 # Detect whether stdout is a real terminal that grokks ANSI escapes. Pipes,
@@ -470,14 +523,9 @@ 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 block
@@ -787,8 +835,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 },
@@ -843,6 +891,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
@@ -926,10 +1037,12 @@ while [ $# -gt 0 ]; do
     --base-url)
       base_url="${2:-}"; shift 2
       [ -n "$base_url" ] || { err "--base-url requires a value."; exit 2; }
+      base_url_explicit="true"
       ;;
     --local)
       # Shorthand for local dev: localhost:8080 (matches `wv mr` / `make dev` default PORT).
       base_url="http://localhost:8080"
+      base_url_explicit="true"
       shift
       ;;
     --non-interactive)
@@ -938,6 +1051,9 @@ while [ $# -gt 0 ]; do
     --quiet)
       quiet="true"; shift
       ;;
+    --rotate-key)
+      rotate_key="true"; shift
+      ;;
     --dir)
       install_dir="${2:-}"; shift 2
       [ -n "$install_dir" ] || { err "--dir requires a path."; exit 2; }
@@ -951,6 +1067,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
@@ -962,21 +1082,55 @@ while [ $# -gt 0 ]; do
       # npm wrapper forwards argv verbatim so either form reaches us.
       mode="${1#--}"; shift
       ;;
+    update|--update)
+      # Non-interactive refresh of an existing install. Takes the same target
+      # and scope flags as install; resolves the key from env or disk only.
+      mode="update"; shift
+      ;;
     disable-routing|--disable-routing)
       # Convenience alias for the Codex-specific off toggle. Unlike generic
       # `off`, it deliberately resolves the target after all flags are parsed,
       # 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."
@@ -988,11 +1142,51 @@ 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.
-if [ "$mode" != "install" ]; then
+# 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."
+    else
+      err "'$mode' requires an explicit client: --claude, --codex, or --opencode."
+    fi
+    exit 2
+  fi
+fi
+
+# Only Claude Code's settings are read back for a key today (read_installed_key),
+# so `models` can't authenticate as any other client. Fail fast here rather than
+# falling through to the toggle dispatch, which would flip config nobody asked
+# to change.
+if [ "$mode" = "models" ] && [ "$target" != "claude" ]; then
+  err "'models' currently supports --claude only (it reads the router key from Claude Code's settings)."
+  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
+# and assets using the key already on disk (or in the environment). Suppressing
+# prompts here also settles the target/scope pickers below on their defaults,
+# which is what a cron/script caller wants.
+if [ "$mode" = "update" ]; then
+  non_interactive="true"
+  if [ "$rotate_key" = "true" ]; 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
@@ -1114,9 +1308,9 @@ fi
 
 # ---------- pre-flight ----------
 
-if [ "$mode" = "install" ]; then
-  [ "$quiet" = "true" ] || info "scope=${C_BOLD}${scope}${C_RESET}  target=${C_BOLD}${target}${C_RESET}  base_url=${C_BOLD}${base_url}${C_RESET}"
-else
+# `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
 
@@ -1127,10 +1321,17 @@ fi
 if [ "$target" = "claude" ] || [ "$target" = "opencode" ] || [ "$target" = "pi" ]; then
   require_cmd jq    "macOS: 'brew install jq' · Debian/Ubuntu: 'sudo apt install jq'"
 fi
-# curl is only used by the install path's health/validate probes; toggles never
-# hit the network.
-[ "$mode" = "install" ] && require_cmd curl  "macOS/Linux: usually preinstalled — check your package manager"
+# 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
@@ -1157,9 +1358,118 @@ 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|no|no|no|manual|command
+router-on||local-toggle|yes|no|no|no|manual|command
+router-status||local-toggle|yes|no|no|no|manual|command
+router-session||prompt|yes|no|no|no|manual|command
+router-models|models|local-toggle|yes|no|no|no|manual|command
+disable-routing||local-toggle|no|yes|no|no|manual|skill
+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"
+  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"
+  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.
@@ -1331,6 +1641,19 @@ json_get() {
   jq -r "${2} // empty" "$1" 2>/dev/null || true
 }
 
+# read_claude_key prints the router key already installed in the given settings
+# file, or nothing when the file is absent / carries no key header. Claude Code
+# packs several headers into one newline-delimited ANTHROPIC_CUSTOM_HEADERS
+# value, so we pick the router-key line out of it and trim the header name.
+# Read-only and tolerant of every missing-file case — never trips set -e.
+read_claude_key() {
+  [ -n "${1:-}" ] || return 0
+  json_get "$1" '.env.ANTHROPIC_CUSTOM_HEADERS' \
+    | sed -n "s/^[[:space:]]*${router_key_header}:[[:space:]]*//p" \
+    | head -n 1 \
+    | tr -d '[:space:]'
+}
+
 # claude_key_present returns 0 when the given settings file's
 # env.ANTHROPIC_CUSTOM_HEADERS carries the router key header. "On" is only valid
 # when this is true: in project scope the committed settings.json holds the
@@ -1338,10 +1661,106 @@ json_get() {
 # (or the parked sidecar), so a router URL alone doesn't mean requests can
 # authenticate.
 claude_key_present() {
-  case "$(json_get "$1" '.env.ANTHROPIC_CUSTOM_HEADERS')" in
-    *X-Weave-Router-Key*) return 0 ;;
-    *) return 1 ;;
-  esac
+  [ -n "$(read_claude_key "$1")" ]
+}
+
+# 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.
+# 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 this 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_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_installed_key() {
+  [ "$target" = "claude" ] || return 0
+  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"
+}
+
+# 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 ''
+}
+
+# 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
@@ -1646,7 +2065,394 @@ toggle_opencode() {
   esac
 }
 
-if [ "$mode" != "install" ]; then
+# ---------- 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 --claude --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> --claude\n" "$C_DIM" "$C_RESET"
+  printf "%sDisable a model:%s npx @workweave/router models disable <id> --claude\n" "$C_DIM" "$C_RESET"
+}
+
+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() {
+  err "$1"
+  printf '%s\n' \
+    "  npx @workweave/router models --claude                          # list models" \
+    "  npx @workweave/router models enable  <id> [<id>…] --claude" \
+    "  npx @workweave/router models disable <id> [<id>…] --claude" \
+    "  npx @workweave/router models providers --claude                # list providers" \
+    "  npx @workweave/router models providers disable <name> --claude" \
+    "  npx @workweave/router models prefer <id> [<id>…] --claude      # 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_base_url)"
+    if [ -z "$models_base" ]; then
+      err "No Weave Router install found for Claude Code in this scope. Run 'npx @workweave/router --claude' first, or pass --base-url."
+      exit 1
+    fi
+    base_url="$models_base"
+    # resolve_installed_base_url 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.
+    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)"
+  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=""
+    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)"
+  fi
+  if [ -z "$api_key" ]; then
+    err "No router key found for Claude Code in this scope. Re-run 'npx @workweave/router --claude', 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 ;;
     codex)    toggle_codex ;;
@@ -1655,35 +2461,89 @@ if [ "$mode" != "install" ]; then
   exit 0
 fi
 
+# ---------- endpoint carry-over for update ----------
+#
+# `update` refreshes an install in place, so it must not silently retarget a
+# self-hosted or custom endpoint at the hosted default just because --base-url
+# wasn't repeated. Read the endpoint already configured and keep it; an explicit
+# --base-url / --local still wins, and install mode is untouched (it is how you
+# deliberately move an install to a new endpoint).
+#
+# `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="$(resolve_installed_base_url)"
+  if [ -n "$installed_base" ]; then
+    base_url="${installed_base%/}"
+  fi
+fi
+
+if [ "$mode" = "install" ]; then
+  [ "$quiet" = "true" ] || info "scope=${C_BOLD}${scope}${C_RESET}  target=${C_BOLD}${target}${C_RESET}  base_url=${C_BOLD}${base_url}${C_RESET}"
+else
+  [ "$quiet" = "true" ] || info "mode=${C_BOLD}update${C_RESET}  scope=${C_BOLD}${scope}${C_RESET}  target=${C_BOLD}${target}${C_RESET}  base_url=${C_BOLD}${base_url}${C_RESET}"
+fi
+
 # ---------- token handling ----------
+#
+# Resolution order: WEAVE_ROUTER_KEY, then the key this install already wrote to
+# disk, then an interactive prompt. Reading the installed key back is what makes
+# 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 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.
+prompt_for_key() {
+  # Read from /dev/tty explicitly so the prompt works under `curl -fsSL ... | sh`,
+  # where stdin is the curl pipe (already at EOF by the time we get here, and
+  # `set -e` would abort on read returning 1).
+  # _spin_cleanup (installed globally above) already restores stty echo on
+  # any exit path, so we don't need a separate trap here — that would
+  # overwrite the spinner cleanup and leak the cursor / child PID on Ctrl-C.
+  printf "%sGet your Weave Router API key at %s%s\n" "$C_BRAND" "$base_url" "$C_RESET"
+  printf "%sPaste your key here (rk_…):%s " "$C_DIM" "$C_RESET"
+  stty -echo </dev/tty 2>/dev/null || true
+  read -r api_key </dev/tty
+  stty echo </dev/tty 2>/dev/null || true
+  printf "\n"
+  api_key_source="prompt"
+  [ -n "$api_key" ] || { err "No key provided."; exit 1; }
+}
 
 api_key=""
+installed_key=""
+[ "$rotate_key" = "true" ] || installed_key="$(read_installed_key)"
+
 if [ -n "${WEAVE_ROUTER_KEY:-}" ]; then
-    api_key="$WEAVE_ROUTER_KEY"
-    info "Using WEAVE_ROUTER_KEY from environment."
-  elif [ "$non_interactive" = "true" ]; then
-    err "--non-interactive set but WEAVE_ROUTER_KEY is empty. Export it and re-run."
-    exit 1
+  api_key="$WEAVE_ROUTER_KEY"
+  api_key_source="env"
+  info "Using WEAVE_ROUTER_KEY from environment."
+elif [ -n "$installed_key" ]; then
+  api_key="$installed_key"
+  api_key_source="disk"
+  [ "$quiet" = "true" ] || info "Reusing the router key already installed (pass --rotate-key to replace it)."
+elif [ "$mode" = "update" ]; then
+  err "No router key found for $target. Export WEAVE_ROUTER_KEY, or run the installer once to set one up."
+  exit 1
+elif [ "$non_interactive" = "true" ]; then
+  if [ "$rotate_key" = "true" ]; then
+    err "--rotate-key needs either a prompt or WEAVE_ROUTER_KEY, and neither is available. Export the new key and re-run."
   else
-    # Read from /dev/tty explicitly so the prompt works under `curl -fsSL ... | sh`,
-    # where stdin is the curl pipe (already at EOF by the time we get here, and
-    # `set -e` would abort on read returning 1). If /dev/tty isn't available
-    # (e.g. CI without a controlling terminal) the user must use --non-interactive.
-    if [ ! -r /dev/tty ]; then
-      err "No controlling terminal — set WEAVE_ROUTER_KEY and re-run with --non-interactive."
-      exit 1
-    fi
-    # _spin_cleanup (installed globally above) already restores stty echo on
-    # any exit path, so we don't need a separate trap here — that would
-    # overwrite the spinner cleanup and leak the cursor / child PID on Ctrl-C.
-    printf "%sGet your Weave Router API key at %s%s\n" "$C_BRAND" "$base_url" "$C_RESET"
-    printf "%sPaste your key here (rk_…):%s " "$C_DIM" "$C_RESET"
-    stty -echo </dev/tty 2>/dev/null || true
-    read -r api_key </dev/tty
-    stty echo </dev/tty 2>/dev/null || true
-    printf "\n"
-    [ -n "$api_key" ] || { err "No key provided."; exit 1; }
+    err "--non-interactive set but WEAVE_ROUTER_KEY is empty and no installed key was found. Export it and re-run."
   fi
+  exit 1
+else
+  # If /dev/tty isn't available (e.g. CI without a controlling terminal) the
+  # user must use --non-interactive.
+  if [ ! -r /dev/tty ]; then
+    err "No controlling terminal — set WEAVE_ROUTER_KEY and re-run with --non-interactive."
+    exit 1
+  fi
+  prompt_for_key
+fi
 
 # ---------- identity (user email + name) ----------
 #
@@ -1724,11 +2584,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).
@@ -1755,13 +2616,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
@@ -1785,11 +2655,56 @@ 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)"
 }
 
+# seed_command_baseline records the canonical (unrendered) wrapper bodies this
+# run installed, in the cache dir the statusline's background refresh reads. The
+# refresh replaces an installed wrapper only when its bytes still match that
+# baseline, which is how it tells "stale copy" from "user edited it" — without a
+# seed it has to spend one whole interval establishing one. Claude Code only:
+# the statusline is the refresh point and it only ever runs there.
+#
+# Keyed off the statusline's own location, exactly as the refresh derives it, so
+# both sides land on the same cache path.
+seed_command_baseline() {
+  local src_dir="$1" names="$2"
+  [ "$target" = "claude" ] || return 0
+  local sl_dir cmd_dir
+  sl_dir="$(cd "$(dirname "$statusline_file")" 2>/dev/null && pwd -P)" || return 0
+  case "${sl_dir##*/}" in
+    .weave)  cmd_dir="${sl_dir%/*}/.claude/commands" ;;
+    .claude) cmd_dir="$sl_dir/commands" ;;
+    *)       return 0 ;;
+  esac
+  local dir_slug
+  dir_slug="$(printf '%s' "$cmd_dir" | tr -c 'A-Za-z0-9._-' '_')"
+  local baseline_dir="${XDG_CACHE_HOME:-$HOME/.cache}/weave-router/commands${dir_slug}"
+  mkdir -p "$baseline_dir" 2>/dev/null || return 0
+  local name
+  for name in $names; do
+    [ -f "$src_dir/$name.md" ] || continue
+    cp "$src_dir/$name.md" "$baseline_dir/$name.md" 2>/dev/null || true
+  done
+}
+
 # Codex builds before custom prompt discovery existed were given wrapper files
 # under ~/.codex/prompts. They were never invocable as the advertised aliases.
 # Remove only byte-for-byte copies of our old wrappers; retain any prompt the
@@ -1815,18 +2730,18 @@ 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
 }
 
@@ -1879,13 +2794,49 @@ install_codex_disable_routing_skill() {
   ok "Codex skill installed: \$disable-routing"
 }
 
-# ---------- codex install path (dispatch + exit before the Claude-only writes) ----------
+# Install prompt directives as Codex-native skills. The skill itself emits a
+# leading-space normal prompt, which is the only portable way to reach the
+# router directive parser without claiming Codex's reserved slash namespace.
+install_codex_prompt_skills() {
+  local canonical skill_src dst_dir dst_file scope_args body
+  while IFS= read -r canonical; do
+    skill_src="$script_dir/codex-skills/$canonical/SKILL.md"
+    [ -f "$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
+    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"
+    ok "Codex skill installed: \$$canonical"
+  done <<EOF
+$(weave_registry_skill_names codex)
+EOF
+}
+
 
 if [ "$target" = "codex" ]; then
   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)
@@ -2073,6 +3024,10 @@ if [ "$target" = "pi" ]; then
     fi
   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"
@@ -2217,6 +3172,312 @@ weave_self_refresh() {
 }
 weave_self_refresh 2>/dev/null || true
 
+# ---------- background slash-command refresh ----------
+#
+# The /force-model, /router-* … wrappers under <install>/.claude/commands/ are
+# written once at install time and then never touched again, so a user who
+# doesn't re-run the installer keeps whatever set shipped that day. This script
+# is the only thing Claude Code invokes on every turn, so it doubles as the
+# refresh point for them: same rate limit, same detached fork, same
+# content-diff no-op as the self-refresh above.
+#
+# Never clobber a wrapper the user edited. The only way to tell an edit from a
+# stale copy is to remember what we last downloaded, so each canonical file is
+# cached (unrendered) per install under the user cache dir and a wrapper is
+# replaced only when its bytes still match that baseline. With no baseline yet
+# we can't prove anything, so the first run only seeds the cache and a swap can
+# happen from the next one on. install.sh seeds it too, so fresh installs skip
+# that warm-up round.
+#
+# Never touch a wrapper git tracks either. A project-scope install writes the
+# wrappers into the repo's own .claude/commands/, and unlike cc-statusline.sh
+# the installer does not gitignore them — so an unattended weekly rewrite would
+# surface as unexplained dirty files (and could ride along in someone's commit).
+# Only the installer changes tracked files, and only when a human runs it.
+#
+# Opt out with WEAVE_COMMANDS_UPDATE=0 (WEAVE_STATUSLINE_UPDATE=0 disables this
+# too, along with every other network path here). Override the source with
+# WEAVE_COMMANDS_URL_BASE=..., e.g. for self-hosters who fork.
+
+# weave_command_tracked_by_git returns 0 when $1 is a file git tracks. Used to
+# leave repo-committed wrappers alone; no git (or no repo) means untracked.
+weave_command_tracked_by_git() {
+  command -v git >/dev/null 2>&1 || return 1
+  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.
+weave_render_command() {
+  local body
+  body="$(cat "$1" 2>/dev/null)" || return 1
+  printf '%s' "${body//\{\{SCOPE\}\}/$2}"
+}
+
+weave_sync_commands() {
+  [ "${WEAVE_STATUSLINE_UPDATE:-1}" = "0" ] && return 0
+  [ "${WEAVE_COMMANDS_UPDATE:-1}" = "0" ] && return 0
+  command -v curl >/dev/null 2>&1 || return 0
+
+  local self="${BASH_SOURCE[0]:-$0}" self_dir cmd_dir
+  self_dir="$(cd "$(dirname "$self")" 2>/dev/null && pwd -P)" || return 0
+  # User scope installs this script at <base>/.weave/, project and --dir at
+  # <base>/.claude/. Claude Code reads commands from <base>/.claude/commands in
+  # both layouts.
+  case "${self_dir##*/}" in
+    .weave)  cmd_dir="${self_dir%/*}/.claude/commands" ;;
+    .claude) cmd_dir="$self_dir/commands" ;;
+    *)       return 0 ;;
+  esac
+  [ -d "$cmd_dir" ] && [ -w "$cmd_dir" ] || return 0
+
+  local cache_dir="${XDG_CACHE_HOME:-$HOME/.cache}/weave-router"
+  local dir_slug
+  dir_slug="$(printf '%s' "$cmd_dir" | tr -c 'A-Za-z0-9._-' '_')"
+  # Baseline is keyed by install, not shared: two installs refresh on their own
+  # clocks, and a shared baseline updated by one would make the other's still-
+  # canonical wrappers look user-edited and freeze them forever.
+  local baseline_dir="$cache_dir/commands${dir_slug}"
+  local stamp="$cache_dir/checked-at${dir_slug}.commands"
+  mkdir -p "$baseline_dir" 2>/dev/null || return 0
+
+  local interval_days="${WEAVE_STATUSLINE_UPDATE_INTERVAL_DAYS:-7}"
+  local now stamp_mtime
+  now="$(date +%s 2>/dev/null)" || return 0
+  if [ -f "$stamp" ]; then
+    stamp_mtime="$(stat -c %Y "$stamp" 2>/dev/null || stat -f %m "$stamp" 2>/dev/null)" || stamp_mtime=0
+  else
+    stamp_mtime=0
+  fi
+  if [ -n "${stamp_mtime:-}" ] && [ "$stamp_mtime" -gt 0 ] \
+     && [ $(( now - stamp_mtime )) -lt $(( interval_days * 86400 )) ]; then
+    return 0
+  fi
+  # Stamp before forking, same as the self-refresh: Claude Code calls us on
+  # every turn and concurrent invocations must not all start downloading.
+  : > "$stamp" 2>/dev/null || return 0
+
+  # router-off/on/status bake this install's scope selector into their npx
+  # line (upstream carries {{SCOPE}} there). Recover it from the installed copy
+  # so a project or --dir install keeps toggling its own config; when it can't
+  # be recovered those three are skipped rather than rewritten to point at the
+  # user-scope install.
+  local scope_args="" scope_known="false" off="$cmd_dir/router-off.md"
+  if [ -f "$off" ] && grep -q '^`npx @workweave/router off --claude.*`$' "$off" 2>/dev/null; then
+    scope_known="true"
+    scope_args="$(sed -n 's|^`npx @workweave/router off --claude\(.*\)`$|\1|p' "$off" | head -n 1)"
+  fi
+
+  local url_base="${WEAVE_COMMANDS_URL_BASE:-https://raw.githubusercontent.com/workweave/router/main/install/commands}"
+  local name installed raw prev tmp new_body prev_body installed_body
+  (
+    # 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
+    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
+      # a surprise. A symlink is user-owned; leave it alone. A git-tracked
+      # wrapper belongs to the repo — rewriting it would dirty a working tree
+      # nobody asked us to touch.
+      [ -f "$installed" ] || continue
+      [ -L "$installed" ] && continue
+      weave_command_tracked_by_git "$installed" && continue
+
+      raw="$baseline_dir/$name.md.tmp.$$"
+      curl -fsSL --max-time 15 "$url_base/$name.md" -o "$raw" 2>/dev/null || { rm -f "$raw"; continue; }
+      # Shape check: every wrapper opens with YAML front matter, so a 404 page
+      # or a truncated body can never be installed as a command.
+      if [ ! -s "$raw" ] || [ "$(head -n 1 "$raw")" != "---" ]; then
+        rm -f "$raw"
+        continue
+      fi
+
+      prev="$baseline_dir/$name.md"
+      if grep -q '{{SCOPE}}' "$raw" && [ "$scope_known" != "true" ]; then
+        mv "$raw" "$prev" 2>/dev/null || rm -f "$raw"
+        continue
+      fi
+
+      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 | 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<!-- 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"
+          fi
+        fi
+      fi
+      mv "$raw" "$prev" 2>/dev/null || rm -f "$raw"
+    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
@@ -2257,6 +3518,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,
@@ -2269,6 +3531,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,
@@ -2288,7 +3551,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,
@@ -2311,7 +3576,8 @@ 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-flash":               0.00015
   },
   "output": {
     "claude-fable-5":                   0.05,
@@ -2328,6 +3594,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,
@@ -2340,6 +3607,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,
@@ -2359,7 +3627,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,
@@ -2382,7 +3652,8 @@ 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-flash":               0.0005
   }
 }'
 # END_GENERATED_PRICES
@@ -2437,6 +3708,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"
@@ -2450,6 +3727,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
@@ -2646,87 +3924,114 @@ tmp_patch="$(mktemp)"
 # leave the cursor hidden if Ctrl-C lands during settings.json patching.
 trap '_spin_cleanup; rm -f "$tmp_patch"' EXIT INT TERM HUP
 
-# Claude Code splits ANTHROPIC_CUSTOM_HEADERS on newlines, so multiple headers
-# ride in the same env var separated by \n. Append identity headers alongside
-# the router key so a single var carries them all. When email/name are empty
-# we keep the bare router-key form so a re-install for a user who opted out
-# cleanly removes the old line.
-custom_headers="$router_key_header: $api_key"
-if [ -n "$user_email" ]; then
-  custom_headers="$custom_headers"$'\n'"X-Weave-User-Email: $user_email"
-fi
-if [ -n "$user_name" ]; then
-  custom_headers="$custom_headers"$'\n'"X-Weave-User-Name: $user_name"
-fi
-custom_headers="$custom_headers"$'\n'"X-App: claude-code"
-
-# Setting ANTHROPIC_BASE_URL makes Claude Code treat us as non-first-party and
-# disable MCP tool-search deferral, inlining every tool schema into every request
-# — a large uncompactable prefix that can push a session into an autocompact
-# thrash loop. ENABLE_TOOL_SEARCH=auto restores on-demand loading (Claude Code's
-# own first-party default).
-if [ "$scope" = "project" ] && [ -z "$install_dir" ]; then
-  jq -n --arg url "$base_url" --arg sl "$statusline_path_for_settings" '{
-    env: { ANTHROPIC_BASE_URL: $url, ENABLE_TOOL_SEARCH: "auto" },
-    statusLine: { type: "command", command: $sl },
-    attribution: {
-      commit: "Co-Authored-By: Weave Router <router@workweave.ai>",
-      pr: "🤖 Generated with [Weave Router](https://router.workweave.ai)"
-    }
-  }' >"$tmp_patch"
-else
-  jq -n --arg url "$base_url" --arg header "$custom_headers" --arg sl "$statusline_path_for_settings" '{
-    env: { ANTHROPIC_BASE_URL: $url, ANTHROPIC_CUSTOM_HEADERS: $header, ENABLE_TOOL_SEARCH: "auto" },
-    statusLine: { type: "command", command: $sl },
-    attribution: {
-      commit: "Co-Authored-By: Weave Router <router@workweave.ai>",
-      pr: "🤖 Generated with [Weave Router](https://router.workweave.ai)"
-    }
-  }' >"$tmp_patch"
-fi
-
-# Merge with existing settings. Deep-merge env and replace statusLine.
-# We strip router-owned auth from the existing settings BEFORE merging —
-# otherwise switching auth mode (key→dev-mode) would leave stale credentials
-# behind. ANTHROPIC_AUTH_TOKEN/apiKeyHelper are also removed to migrate older
-# installs that used them for router auth.
-if [ -f "$settings_file" ]; then
-  merged="$(jq -s '.[0] as $a | .[1] as $b
-    | $a
-    | .env = (($a.env // {} | del(.ANTHROPIC_AUTH_TOKEN, .ANTHROPIC_CUSTOM_HEADERS)) + ($b.env // {}))
-    | (if (.env | length) == 0 then del(.env) else . end)
-    | del(.apiKeyHelper)
-    | (if $b.statusLine then .statusLine = $b.statusLine else . end)
-    | (if $b.attribution then .attribution = $b.attribution else . end)
-  ' "$settings_file" "$tmp_patch")"
-  printf '%s\n' "$merged" >"$settings_file"
-else
-  cp "$tmp_patch" "$settings_file"
-fi
-ok "Settings written to $settings_file"
+# write_claude_settings merges the router config into settings.json (and, in
+# project scope, the key header into settings.local.json) for the key in $1.
+# Factored out so the /validate fallback can rewrite both files with a
+# replacement key without re-running the whole install.
+write_claude_settings() {
+  local block_key="$1"
+
+  # Claude Code splits ANTHROPIC_CUSTOM_HEADERS on newlines, so multiple headers
+  # ride in the same env var separated by \n. Append identity headers alongside
+  # the router key so a single var carries them all. When email/name are empty
+  # we keep the bare router-key form so a re-install for a user who opted out
+  # cleanly removes the old line.
+  local custom_headers="$router_key_header: $block_key"
+  if [ -n "$user_email" ]; then
+    custom_headers="$custom_headers"$'\n'"X-Weave-User-Email: $user_email"
+  fi
+  if [ -n "$user_name" ]; then
+    custom_headers="$custom_headers"$'\n'"X-Weave-User-Name: $user_name"
+  fi
+  custom_headers="$custom_headers"$'\n'"X-App: claude-code"
 
-# Slash command wrappers — see install_slash_commands() below for the why.
-install_slash_commands "$settings_dir/commands"
+  # Setting ANTHROPIC_BASE_URL makes Claude Code treat us as non-first-party and
+  # disable MCP tool-search deferral, inlining every tool schema into every request
+  # — a large uncompactable prefix that can push a session into an autocompact
+  # thrash loop. ENABLE_TOOL_SEARCH=auto restores on-demand loading (Claude Code's
+  # own first-party default).
+  if [ "$scope" = "project" ] && [ -z "$install_dir" ]; then
+    jq -n --arg url "$base_url" --arg sl "$statusline_path_for_settings" '{
+      env: { ANTHROPIC_BASE_URL: $url, ENABLE_TOOL_SEARCH: "auto" },
+      statusLine: { type: "command", command: $sl },
+      attribution: {
+        commit: "Co-Authored-By: Weave Router <router@workweave.ai>",
+        pr: "🤖 Generated with [Weave Router](https://router.workweave.ai)"
+      }
+    }' >"$tmp_patch"
+  else
+    jq -n --arg url "$base_url" --arg header "$custom_headers" --arg sl "$statusline_path_for_settings" '{
+      env: { ANTHROPIC_BASE_URL: $url, ANTHROPIC_CUSTOM_HEADERS: $header, ENABLE_TOOL_SEARCH: "auto" },
+      statusLine: { type: "command", command: $sl },
+      attribution: {
+        commit: "Co-Authored-By: Weave Router <router@workweave.ai>",
+        pr: "🤖 Generated with [Weave Router](https://router.workweave.ai)"
+      }
+    }' >"$tmp_patch"
+  fi
 
-if [ "$scope" = "project" ] && [ -z "$install_dir" ]; then
-  jq -n --arg header "$custom_headers" '{
-    env: { ANTHROPIC_CUSTOM_HEADERS: $header }
-  }' >"$tmp_patch"
-  if [ -f "$local_settings_file" ]; then
+  # Merge with existing settings. Deep-merge env and replace statusLine.
+  # We strip router-owned auth from the existing settings BEFORE merging —
+  # otherwise switching auth mode (key→dev-mode) would leave stale credentials
+  # behind. ANTHROPIC_AUTH_TOKEN/apiKeyHelper are also removed to migrate older
+  # installs that used them for router auth.
+  local merged
+  if [ -f "$settings_file" ]; then
     merged="$(jq -s '.[0] as $a | .[1] as $b
       | $a
       | .env = (($a.env // {} | del(.ANTHROPIC_AUTH_TOKEN, .ANTHROPIC_CUSTOM_HEADERS)) + ($b.env // {}))
       | (if (.env | length) == 0 then del(.env) else . end)
       | del(.apiKeyHelper)
-    ' "$local_settings_file" "$tmp_patch")"
-    printf '%s\n' "$merged" >"$local_settings_file"
+      | (if $b.statusLine then .statusLine = $b.statusLine else . end)
+      | (if $b.attribution then .attribution = $b.attribution else . end)
+    ' "$settings_file" "$tmp_patch")"
+    printf '%s\n' "$merged" >"$settings_file"
   else
-    cp "$tmp_patch" "$local_settings_file"
+    cp "$tmp_patch" "$settings_file"
   fi
-  chmod 600 "$local_settings_file"
-  ok "Router key header written to $local_settings_file"
+  ok "Settings written to $settings_file"
+
+  if [ "$scope" = "project" ] && [ -z "$install_dir" ]; then
+    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
+      # straight at Anthropic (the committed settings.json carries the router
+      # URL instead). Leaving that override in place would have every request
+      # keep bypassing the router even though this install/update just wrote
+      # a fresh key and reports success.
+      merged="$(jq -s '.[0] as $a | .[1] as $b
+        | $a
+        | .env = (($a.env // {} | del(.ANTHROPIC_AUTH_TOKEN, .ANTHROPIC_CUSTOM_HEADERS, .ANTHROPIC_BASE_URL)) + ($b.env // {}))
+        | (if (.env | length) == 0 then del(.env) else . end)
+        | del(.apiKeyHelper)
+      ' "$local_settings_file" "$tmp_patch")"
+      printf '%s\n' "$merged" >"$local_settings_file"
+    else
+      cp "$tmp_patch" "$local_settings_file"
+    fi
+    chmod 600 "$local_settings_file"
+    ok "Router key header written to $local_settings_file"
+  fi
+}
+
+# write_claude_settings rewrites the full router config live, so a parked
+# sidecar left over from `off` is redundant afterward: the router is back on
+# and the key/base URL it preserved are in the settings files. Leave it in
+# place and `status` would keep reporting off, and `off` would no-op against
+# live router config the user can no longer toggle. Removed AFTER the write
+# succeeds (not before) — deleting it first would lose the only on-disk copy
+# of the key if the write itself failed midway under `set -e`.
+write_claude_settings "$api_key"
+
+if [ "$target" = "claude" ] && [ -f "$settings_dir/.weave-parked.json" ]; then
+  rm -f "$settings_dir/.weave-parked.json"
 fi
 
+# Slash command wrappers — see install_slash_commands() below for the why.
+install_slash_commands "$settings_dir/commands"
+
 # ---------- gitignore for project scope ----------
 
 if [ "$scope" = "project" ] && [ -z "$install_dir" ] && [ -n "${git_root:-}" ]; then
@@ -2766,13 +4071,45 @@ if [ -n "$api_key" ]; then
       | curl -fsS --max-time 5 --header @- "$base_url/validate"
   }
   if ! spin "Validating API key" validate_key; then
-    warn "Router rejected the API key (check it matches the dashboard at $base_url)."
+    # 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
 
 # ---------- 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