@workweave/router 0.2.10 → 0.2.11

package/install.sh

@@ -37,6 +37,8 @@
 #   npx @workweave/router --codex                          # skip the picker, target Codex
 #   npx @workweave/router --opencode                       # skip the picker, target opencode
 #   npx @workweave/router --pi                              # skip the picker, target pi
+#   npx @workweave/router --pi --lsp go,typescript          # also install language servers for pi's lsp tool
+#                                                             (go/typescript/python/rust; needs that language's toolchain)
 #   npx @workweave/router --scope project                  # commit-with-team install
 #   npx @workweave/router --dir /tmp/my-sandbox            # isolated throwaway install
 #   npx @workweave/router --local                          # local router on localhost:8080
@@ -64,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
 
@@ -98,9 +122,22 @@ target_explicit="false"
 # never-prompting install that reuses the key already on disk. "off"/"on"/
 # "status" toggle or report an existing install without touching the router
 # key/identity — see the toggle_* helpers and the dispatch block below.
+# "models" reads and edits the installation's model selection over the router's
+# admin API; it touches no local config at all.
 mode="install"
 disable_routing_alias="false"
 
+# `models` sub-verb plus its operands (model / provider ids), newline-delimited
+# in argument order. Catalog ids and provider names never contain whitespace,
+# so a newline-delimited string stays readable where a bash 3.2 array under
+# `set -u` would not. --json switches the output to the raw API payload.
+models_args=""
+models_json="false"
+
+# --lsp <langs>: comma-separated languages whose language servers to install
+# for the pi extension's `lsp` tool (pi target only). Empty = don't install any.
+lsp_langs=""
+
 # --rotate-key forces the interactive key prompt even when a usable key is
 # already installed, so a rotated key can replace it.
 rotate_key="false"
@@ -486,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
@@ -803,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 },
@@ -859,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
@@ -972,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
@@ -994,15 +1093,44 @@ while [ $# -gt 0 ]; do
       # so `disable-routing --claude` cannot silently change Claude settings.
       mode="off"; disable_routing_alias="true"; shift
       ;;
+    models|--models)
+      # Model selection. Sub-verb and operand collection happens in the
+      # catch-all arm below (guarded on mode="models"), not here — that lets
+      # `--claude`/`--json`/etc. appear before, after, or between operands
+      # instead of only after every operand has been consumed.
+      mode="models"; shift
+      ;;
+    --json)
+      models_json="true"; shift
+      ;;
     -h|--help)
       usage 0
       ;;
     *)
-      err "Unknown flag: $1."; usage 2
+      # In `models` mode, a bare (non-dashed) word is a sub-verb or operand —
+      # collect it and keep parsing, so a flag can appear before, after, or
+      # between them (`models --claude enable x` and `models enable x --claude`
+      # both work). A dashed token nothing above matched is still an error,
+      # models mode or not.
+      if [ "$mode" = "models" ] && [ "${1#-}" = "$1" ]; then
+        models_args="${models_args}${models_args:+$'\n'}$1"; shift
+      else
+        err "Unknown flag: $1."; usage 2
+      fi
       ;;
   esac
 done
 
+# --lsp is a pi-extension feature, so it implies the pi target; combining it
+# with another explicit target is a contradiction, not a preference.
+if [ -n "$lsp_langs" ]; then
+  if [ "$target_explicit" = "true" ] && [ "$target" != "pi" ]; then
+    err "--lsp only applies to the pi target (the lsp tool ships in the pi extension). Drop --lsp or use --pi."
+    exit 2
+  fi
+  target="pi"; target_explicit="true"
+fi
+
 if [ "$disable_routing_alias" = "true" ]; then
   if [ "$target_explicit" = "true" ] && [ "$target" != "codex" ]; then
     err "disable-routing only applies to Codex; omit the client flag or use --codex."
@@ -1014,15 +1142,39 @@ fi
 
 # Toggle verbs only flip config install.sh already wrote: no key, no identity,
 # no prompts. Require an explicit client so we never guess which config to
-# touch, and suppress every interactive prompt downstream.
+# touch, and suppress every interactive prompt downstream. `models` edits no
+# local config, but it still reads the endpoint and key out of one install, so
+# it needs the same explicit choice.
 if [ "$mode" != "install" ] && [ "$mode" != "update" ]; then
   non_interactive="true"
   if [ "$target_explicit" != "true" ]; then
-    err "'$mode' requires an explicit client: --claude, --codex, or --opencode."
+    if [ "$mode" = "models" ]; then
+      err "'models' requires an explicit client: --claude."
+    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,
@@ -1156,7 +1308,9 @@ fi
 
 # ---------- pre-flight ----------
 
-if [ "$mode" != "install" ] && [ "$mode" != "update" ]; then
+# `models` skips this line: it prints its own header carrying the endpoint it
+# resolved, which is the part a reader actually needs.
+if [ "$mode" != "install" ] && [ "$mode" != "update" ] && [ "$mode" != "models" ]; then
   [ "$quiet" = "true" ] || info "mode=${C_BOLD}${mode}${C_RESET}  scope=${C_BOLD}${scope}${C_RESET}  target=${C_BOLD}${target}${C_RESET}"
 fi
 
@@ -1167,12 +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/update paths' health/validate probes;
-# toggles never hit the network.
-if [ "$mode" = "install" ] || [ "$mode" = "update" ]; then
+# curl is used by the install/update paths' health/validate probes and by every
+# `models` call; the on/off/status toggles never hit the network.
+if [ "$mode" = "install" ] || [ "$mode" = "update" ] || [ "$mode" = "models" ]; then
   require_cmd curl  "macOS/Linux: usually preinstalled — check your package manager"
 fi
 
+# Every warning below says the client's config will be written anyway, which is
+# true for install/update/toggles and false for `models` — it only reads that
+# config to find the router. Whether the client itself is installed has no
+# bearing on a model-selection call, so skip the check there entirely.
+if [ "$mode" != "models" ]; then
 case "$target" in
   claude)
     if ! command -v claude >/dev/null 2>&1; then
@@ -1199,9 +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.
@@ -1396,6 +1664,105 @@ claude_key_present() {
   [ -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
 # parked sidecar (which may carry the router key header) never gets committed.
 # No-op for user scope and --dir, matching how install handles its own ignores.
@@ -1698,6 +2065,393 @@ toggle_opencode() {
   esac
 }
 
+# ---------- model selection ----------
+#
+# `models` reads and edits the installation's model/provider selection through
+# the router's /admin/v1 API — the same lists the router dashboard's settings
+# page renders, backed by the same columns. Nothing local is written: the
+# endpoint and router key are read out of the install already on disk so a
+# self-hosted install talks to its own router with its own key.
+#
+# The Weave-hosted router runs in `managed` mode and mounts no /admin/v1 at
+# all — there model selection belongs to the organization and is edited in the
+# Weave dashboard. That surfaces as a 404, which reads (for a list) as "fall
+# back to the public catalog and say where to edit" and (for an edit) as a
+# refusal naming the dashboard.
+
+# Public, unauthed catalog of everything the router can route to. Mounted in
+# both deployment modes, so it is the one listing that always works.
+MODELS_CATALOG_PATH="/v1/router/models"
+MODELS_DASHBOARD_URL="https://router.workweave.ai/dashboard/settings"
+
+# Set by models_api on every call.
+models_http_status=""
+models_http_body=""
+
+# models_api METHOD PATH [JSON_BODY] — call the router and capture status+body.
+# The key rides in on stdin (curl --header @-) rather than a -H argument so it
+# never appears in the process arg list, which any other local user can read.
+models_api() {
+  local method="$1" path="$2" body="${3:-}"
+  local out status=""
+  out="$(mktemp)" || { err "Could not create a temp file."; exit 1; }
+  if [ -n "$body" ]; then
+    status="$(printf '%s: %s\n' "$router_key_header" "$api_key" \
+      | curl -sS --max-time 20 -X "$method" \
+             -H 'Content-Type: application/json' --data-binary "$body" \
+             --header @- -o "$out" -w '%{http_code}' "$base_url$path" 2>/dev/null)" || status=""
+  else
+    status="$(printf '%s: %s\n' "$router_key_header" "$api_key" \
+      | curl -sS --max-time 20 -X "$method" \
+             --header @- -o "$out" -w '%{http_code}' "$base_url$path" 2>/dev/null)" || status=""
+  fi
+  models_http_status="$status"
+  models_http_body="$(cat "$out" 2>/dev/null || true)"
+  rm -f "$out"
+  case "$models_http_status" in
+    2*) return 0 ;;
+    *)  return 1 ;;
+  esac
+}
+
+# models_api_error prints the router's own `error` field, when it sent one.
+models_api_error() {
+  printf '%s' "$models_http_body" | jq -r '.error // empty' 2>/dev/null || true
+}
+
+# models_fail turns the status left by models_api into a message that says what
+# to do next, then exits. $1 names the attempted operation.
+models_fail() {
+  local what="$1" detail
+  detail="$(models_api_error)"
+  case "$models_http_status" in
+    ""|000)
+      err "Could not reach the router at $base_url. Is it running?"
+      ;;
+    401|403)
+      # 403 with a message is the ROUTER_EXCLUDED_MODELS/PROVIDERS env pin,
+      # which is actionable on its own; a bare 401/403 is a key problem.
+      if [ -n "$detail" ]; then
+        err "$detail"
+      else
+        err "The router rejected this installation's key. Re-run 'npx @workweave/router --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 ;;
@@ -1719,16 +2473,7 @@ fi
 # sidecar is the authority while toggled off — reading the live file there would
 # pin the install to api.anthropic.com.
 if [ "$mode" = "update" ] && [ "$base_url_explicit" != "true" ] && [ "$target" = "claude" ]; then
-  installed_base=""
-  for candidate in \
-    "$settings_dir/.weave-parked.json" \
-    "$settings_file" \
-    "$local_settings_file"
-  do
-    installed_base="$(json_get "$candidate" '.env.ANTHROPIC_BASE_URL')"
-    router_shaped_url "$installed_base" && break
-    installed_base=""
-  done
+  installed_base="$(resolve_installed_base_url)"
   if [ -n "$installed_base" ]; then
     base_url="${installed_base%/}"
   fi
@@ -1747,30 +2492,7 @@ fi
 # a re-run painless — the installer refreshes assets and config shape often
 # enough that users re-run it routinely, and re-pasting a key every time is pure
 # friction. --rotate-key skips the read-back so a new key can replace the old.
-
-# read_installed_key prints the router key this install already has on disk, or
-# nothing. Only Claude Code is supported today; the other targets still prompt.
-read_installed_key() {
-  [ "$target" = "claude" ] || return 0
-  local key=""
-  # Mirror where the install path writes the key: project scope (no --dir) puts
-  # it in the gitignored settings.local.json, everything else inlines it into
-  # settings.json. Check the other file too — a scope was possibly changed, or a
-  # project checkout may carry a committed header from an older install.
-  if [ "$scope" = "project" ] && [ -z "$install_dir" ]; then
-    key="$(read_claude_key "$local_settings_file")"
-    [ -n "$key" ] || key="$(read_claude_key "$settings_file")"
-  else
-    key="$(read_claude_key "$settings_file")"
-    [ -n "$key" ] || key="$(read_claude_key "$local_settings_file")"
-  fi
-  # Last resort: `off` moves the key header out of the settings files and into
-  # the parked sidecar, so an install/update run while toggled off finds nothing
-  # above even though the key is still on disk. Same {"env":{…}} shape, so
-  # read_claude_key reads it directly.
-  [ -n "$key" ] || key="$(read_claude_key "$settings_dir/.weave-parked.json")"
-  printf '%s' "$key"
-}
+# read_installed_key itself is defined above, next to the other settings readers.
 
 # prompt_for_key reads a key from the controlling terminal into $api_key. Only
 # ever called on an interactive install; callers check first.
@@ -1862,11 +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).
@@ -1893,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
@@ -1923,7 +2655,21 @@ install_slash_commands() {
     # cp-equivalent for the others since the token is absent).
     local body; body="$(cat "$src")"
     body="${body//\{\{SCOPE\}\}/$scope_args}"
-    printf '%s\n' "$body" >"$dst"
+    # Wrappers installed before ownership markers existed carry no marker. A
+    # file whose body still matches what this installer would write is one of
+    # ours from an older version, so adopt it rather than treating it as
+    # user-owned — otherwise every pre-marker install is stranded: never
+    # refreshed, never uninstalled, and skipped by the statusline refresh.
+    # Anything that does not match byte-for-byte is left alone.
+    if [ -e "$dst" ] && { [ ! -f "$dst" ] || ! grep -Fq "<!-- weave-router managed command: $cmd -->" "$dst"; }; then
+      if [ -f "$dst" ] && [ "$(cat "$dst")" = "$body" ]; then
+        : # an unmarked copy of our own wrapper; fall through and adopt it
+      else
+        warn "A user-owned $target command already exists at $dst; leaving it untouched."
+        continue
+      fi
+    fi
+    printf '%s\n<!-- weave-router managed command: %s -->' "$body" "$cmd" >"$dst"
   done
   seed_command_baseline "$commands_src_dir" "$cmds"
   ok "Slash commands written to $dst_dir ($installed)"
@@ -1984,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
 }
 
@@ -2048,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)
@@ -2242,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"
@@ -2420,6 +3206,23 @@ weave_command_tracked_by_git() {
   git -C "$(dirname "$1")" ls-files --error-unmatch -- "$1" >/dev/null 2>&1
 }
 
+# weave_installed_command_names lists the wrappers this install may refresh.
+# The statusline ships standalone (no registry.sh beside it), so the installed
+# set — itself written from the registry — is the only source of truth here.
+#
+# Files written before ownership markers existed carry none, so matching on the
+# marker alone would freeze every pre-marker install out of refreshes forever.
+# List every wrapper instead and let the baseline comparison below decide: a
+# file is replaced only when its bytes still match the last canonical copy, so
+# a user-authored command is never touched whether or not it carries a marker.
+weave_installed_command_names() {
+  local dir="$1" file
+  for file in "$dir"/*.md; do
+    [ -f "$file" ] || continue
+    printf '%s\n' "$(basename "$file" .md)"
+  done
+}
+
 # weave_render_command prints $1 with the installer's {{SCOPE}} placeholder
 # replaced by $2, matching how install_slash_commands writes the same file.
 # Trailing newlines are stripped on both sides of every comparison below.
@@ -2489,8 +3292,7 @@ weave_sync_commands() {
     # Detach stdin (CC pipes JSON to us) so curl can't consume it, and silence
     # everything so no output leaks into the statusline.
     exec </dev/null
-    for name in force-model unforce-model router-feedback fm ufm rf \
-                router-off router-on router-status router-session; do
+    while IFS= read -r name; do
       installed="$cmd_dir/$name.md"
       # Only ever refresh a wrapper that is already installed: a missing one
       # was uninstalled or deliberately deleted, and resurrecting it would be
@@ -2519,10 +3321,10 @@ weave_sync_commands() {
       if [ -f "$prev" ]; then
         new_body="$(weave_render_command "$raw" "$scope_args")"
         prev_body="$(weave_render_command "$prev" "$scope_args")"
-        installed_body="$(cat "$installed" 2>/dev/null)" || installed_body=""
+        installed_body="$(cat "$installed" 2>/dev/null | sed '/^<!-- weave-router managed command: .* -->$/d')" || installed_body=""
         if [ "$prev_body" = "$installed_body" ] && [ "$new_body" != "$installed_body" ]; then
           tmp="$installed.tmp.$$"
-          if printf '%s\n' "$new_body" >"$tmp" 2>/dev/null; then
+          if printf '%s\n<!-- weave-router managed command: %s -->' "$new_body" "$name" >"$tmp" 2>/dev/null; then
             mv "$tmp" "$installed" 2>/dev/null || rm -f "$tmp"
           else
             rm -f "$tmp"
@@ -2530,13 +3332,152 @@ weave_sync_commands() {
         fi
       fi
       mv "$raw" "$prev" 2>/dev/null || rm -f "$raw"
-    done
+    done <<EOF
+$(weave_installed_command_names "$cmd_dir")
+EOF
   ) >/dev/null 2>&1 &
   disown 2>/dev/null || true
   return 0
 }
 weave_sync_commands 2>/dev/null || true
 
+# ---------- org "hide terminal surfaces" gate ----------
+#
+# When the org has hidden the router's terminal surfaces, the statusline
+# renders nothing: this prints no output and exits 0, leaving the slot blank.
+# The setting comes from GET /v1/display-settings with the install's own
+# router key, but the foreground path NEVER touches the network: it decides
+# solely from a per-install cache file (TTL WEAVE_DISPLAY_SETTINGS_TTL_SECONDS,
+# default 1h), and a missing or stale cache fails open — the statusline
+# renders normally. When the cache is missing or stale a detached background
+# refresh re-fetches the setting and rewrites the cache atomically, so the
+# next turn picks up the fresh value; a refresh failure simply leaves the
+# cache stale, which keeps failing open rather than pinning the gate closed.
+#
+# Claude Code runs the statusline every turn, so several invocations can see a
+# stale cache at once. Letting each fetch independently is not safe: the
+# responses can land out of order, and the loser's mv would replace a newer
+# setting with an older one AND stamp it fresh, pinning the gate on a stale
+# value for a full TTL. Refreshes are therefore serialized per cache key on a
+# mkdir mutex (atomic everywhere; flock is absent on macOS), held across both
+# the fetch and the write. A refresh that finds the mutex held exits rather
+# than queueing — the in-flight one is at least as fresh as anything it would
+# fetch, so waiting only to overwrite it is the bug. The one path that is not
+# strictly exclusive is reclaiming a lock whose holder died; see below.
+weave_hidden_gate() {
+  command -v curl >/dev/null 2>&1 || return 1
+  command -v jq >/dev/null 2>&1 || return 1
+
+  local cache_dir="${XDG_CACHE_HOME:-$HOME/.cache}/weave-router"
+  mkdir -p "$cache_dir" 2>/dev/null || return 1
+  local self="${BASH_SOURCE[0]:-$0}"
+  local script_slug
+  script_slug="$(printf '%s' "$self" | tr -c 'A-Za-z0-9._-' '_')"
+  local cache="$cache_dir/display-settings${script_slug}"
+  local ttl="${WEAVE_DISPLAY_SETTINGS_TTL_SECONDS:-3600}"
+
+  local now mtime fresh="false"
+  now="$(date +%s 2>/dev/null)" || now=0
+  if [ -f "$cache" ]; then
+    mtime="$(stat -c %Y "$cache" 2>/dev/null || stat -f %m "$cache" 2>/dev/null)" || mtime=0
+    if [ -n "${mtime:-}" ] && [ "$mtime" -gt 0 ] && [ $(( now - mtime )) -lt "$ttl" ]; then
+      fresh="true"
+    fi
+  fi
+
+  # Foreground decision: only a fresh cache hides the surfaces. Anything else
+  # (no cache, stale cache, unreadable cache) renders normally so a slow or
+  # unreachable router can never stall a turn or wedge the statusline blank.
+  if [ "$fresh" = "true" ]; then
+    [ "$(cat "$cache" 2>/dev/null)" = "1" ]
+    return
+  fi
+
+  # Background refresh for the next invocation. Resolve the router base URL
+  # and key inside the subshell from the Claude Code settings the installer
+  # wrote: project/--dir installs put both under <base>/.claude alongside
+  # this script (key in settings.local.json), while a user-scope install
+  # lives under ~/.weave and reads ~/.claude. Resolve relative to the
+  # script's own location, falling back to user scope, so a project install
+  # never reads (or leaks) the user-scope key. ANTHROPIC_BASE_URL and
+  # WEAVE_ROUTER_BASE_URL may also be set in the environment. A file:// base
+  # URL is the offline/test seam: curl reads it as the response body
+  # directly, so the endpoint path is meaningless for it; real router URLs
+  # (https) get /v1/display-settings appended.
+  (
+    exec </dev/null
+
+    # Take the per-cache-key mutex, or bail. mkdir is the portable atomic
+    # test-and-set. A crashed holder would otherwise block refreshes forever,
+    # so a lock older than the fetch timeout is treated as abandoned and
+    # reclaimed. Releasing from a trap covers every exit path below.
+    lock="$cache.lock"
+    if ! mkdir "$lock" 2>/dev/null; then
+      lock_mtime="$(stat -c %Y "$lock" 2>/dev/null || stat -f %m "$lock" 2>/dev/null)" || lock_mtime=0
+      lock_now="$(date +%s 2>/dev/null)" || lock_now=0
+      if [ "${lock_mtime:-0}" -le 0 ] || [ $(( lock_now - lock_mtime )) -le 30 ]; then
+        exit 0
+      fi
+      # Reclaiming an abandoned lock must not be delete-then-recreate. With
+      # `rm -rf` + `mkdir`, refreshers that all see the same stale lock each
+      # delete the next one's freshly created directory, so many end up holding
+      # it at once (measured at 50 claimants: 4-11 concurrent holders) and their
+      # writes can land out of order. Renaming is atomic, so only one racer can
+      # move a given directory aside and the losers exit instead of clobbering
+      # the winner (same measurement: 1-2). It is not a perfect mutex — a
+      # straggler can still reclaim the new lock a winner just created, since
+      # nothing distinguishes it from the stale one — but real refreshes arrive
+      # one per turn rather than 50 at once, and the staleness threshold below
+      # is what bounds the rest.
+      dead="$lock.dead.$$"
+      mv "$lock" "$dead" 2>/dev/null || exit 0
+      rm -rf "$dead" 2>/dev/null
+      mkdir "$lock" 2>/dev/null || exit 0
+    fi
+    trap 'rmdir "$lock" 2>/dev/null' EXIT
+
+    self_dir="$(cd "$(dirname "$self")" 2>/dev/null && pwd)"
+    settings_base="$HOME"
+    case "$self_dir" in
+      */.claude) settings_base="${self_dir%/.claude}" ;;
+    esac
+    settings="$settings_base/.claude/settings.json"
+    local_settings="$settings_base/.claude/settings.local.json"
+    base_url="${WEAVE_ROUTER_BASE_URL:-${ANTHROPIC_BASE_URL:-}}"
+    key="${WEAVE_ROUTER_KEY:-}"
+    if [ -z "$key" ] && [ -f "$settings" ]; then
+      key="$(jq -r '.env.ANTHROPIC_CUSTOM_HEADERS // "" | split("\n")[] | select(startswith("X-Weave-Router-Key:")) | sub("^X-Weave-Router-Key:[[:space:]]*";"")' "$settings" 2>/dev/null | head -n1)"
+    fi
+    if [ -z "$key" ] && [ -f "$local_settings" ]; then
+      key="$(jq -r '.env.ANTHROPIC_CUSTOM_HEADERS // "" | split("\n")[] | select(startswith("X-Weave-Router-Key:")) | sub("^X-Weave-Router-Key:[[:space:]]*";"")' "$local_settings" 2>/dev/null | head -n1)"
+    fi
+    if [ -z "$base_url" ] && [ -f "$settings" ]; then
+      base_url="$(jq -r '.env.ANTHROPIC_BASE_URL // empty' "$settings" 2>/dev/null)"
+    fi
+    [ -n "$base_url" ] && [ -n "$key" ] || exit 0
+    url="${base_url%/}"
+    case "$url" in
+      file://*) ;;
+      *) url="$url/v1/display-settings" ;;
+    esac
+    body="$(curl -fsS --max-time 5 -H "X-Weave-Router-Key: $key" "$url" 2>/dev/null)" || exit 0
+    hidden="$(printf '%s' "$body" | jq -r '.hide_terminal_surfaces // false' 2>/dev/null)"
+    tmp="$cache.tmp.$$"
+    if [ "$hidden" = "true" ]; then
+      printf '1' >"$tmp" 2>/dev/null && mv "$tmp" "$cache" 2>/dev/null
+    else
+      printf '0' >"$tmp" 2>/dev/null && mv "$tmp" "$cache" 2>/dev/null
+    fi
+    rm -f "$tmp" 2>/dev/null
+  ) >/dev/null 2>&1 &
+  disown 2>/dev/null || true
+  return 1
+}
+
+if weave_hidden_gate </dev/null; then
+  exit 0
+fi
+
 input="$(cat)"
 transcript_path="$(printf '%s' "$input" | jq -r '.transcript_path // empty')"
 # Prefer model.id over display_name: pricing keys + the routed model id in
@@ -2577,6 +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,
@@ -2589,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,
@@ -2608,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,
@@ -2631,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,
@@ -2648,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,
@@ -2660,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,
@@ -2679,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,
@@ -2702,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
@@ -2757,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"
@@ -2770,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
@@ -3034,8 +3992,8 @@ write_claude_settings() {
   ok "Settings written to $settings_file"
 
   if [ "$scope" = "project" ] && [ -z "$install_dir" ]; then
-    jq -n --arg header "$custom_headers" '{
-      env: { ANTHROPIC_CUSTOM_HEADERS: $header }
+    jq -n --arg header "$custom_headers" --arg router_url "$base_url" '{
+      env: { ANTHROPIC_CUSTOM_HEADERS: $header, WEAVE_ROUTER_BASE_URL: $router_url }
     }' >"$tmp_patch"
     if [ -f "$local_settings_file" ]; then
       # Also strip ANTHROPIC_BASE_URL: `off` in project scope points this file