@workweave/router 0.2.9 → 0.2.11

package/README.md

@@ -14,6 +14,22 @@ npx @workweave/router --base-url https://router.acme.internal
 npx @workweave/router --non-interactive     # reads $WEAVE_ROUTER_KEY, no prompts (defaults to claude)
 ```
 
+Re-running the installer to pick up changes reuses the key already on disk, so
+you paste it once and never again. `update` is the never-prompting form of that
+(safe for cron; errors instead of asking when no key can be found):
+
+```bash
+npx @workweave/router --claude                # reuses the installed key
+npx @workweave/router --claude --rotate-key   # ignore it and prompt for a new one
+npx @workweave/router update --claude         # non-interactive refresh in place
+```
+
+For Claude Code the installed statusline and `/force-model`, `/router-*` slash
+commands also refresh themselves in the background about once a week (never
+overwriting a wrapper you edited). Opt out with `WEAVE_STATUSLINE_UPDATE=0`, or
+just the commands with `WEAVE_COMMANDS_UPDATE=0`. Codex, opencode, and pi have
+no per-turn hook to refresh from — re-run the installer for those.
+
 Version-pin for reproducible setups:
 
 ```bash
@@ -38,6 +54,19 @@ slash commands. The shell equivalent is `npx @workweave/router disable-routing`.
 Cursor has no config file we own — toggle its base URL override in **Settings →
 Models** instead.
 
+Pick which models the router is allowed to route to:
+
+```bash
+npx @workweave/router models --claude                  # list every model, with its on/off state
+npx @workweave/router models disable gpt-5.6 --claude  # take one out of rotation
+npx @workweave/router models enable gpt-5.6 --claude   # put it back
+```
+
+Inside Claude Code that's `/router-models` (alias `/models`). Editing needs a
+router that serves the model-selection API; against the Weave-hosted router the
+list still prints and points you at the dashboard, where model selection is an
+organization-wide setting.
+
 Uninstall:
 
 ```bash
@@ -66,9 +95,8 @@ Four install targets:
 - **Codex** (`--codex`) — patches `~/.codex/config.toml` (or
   `<repo>/.codex/config.toml`) with a managed `[model_providers.weave]`
   block plus `model_provider = "weave"`. The provider preserves the existing
-  ChatGPT OAuth login. The public hosted endpoint sends
-  `X-Weave-Router-Strategy: hmm`; `--local` and custom self-hosted URLs keep
-  their router's configured default because its HMM sidecar is optional. HMM or forced
+  ChatGPT OAuth login. No install pins `X-Weave-Router-Strategy`; every
+  endpoint keeps its router's configured default. HMM or forced
   `gpt-5.6-sol`, `gpt-5.6-terra`, and `gpt-5.6-luna` turns use that plan;
   every other selected model uses its WorkWeave deployment or BYOK credential.
   The block lives between begin/end markers

package/cc-statusline.sh

@@ -125,6 +125,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
@@ -165,6 +471,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,
@@ -177,6 +484,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,
@@ -196,7 +504,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,
@@ -219,7 +529,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,
@@ -236,6 +547,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,
@@ -248,6 +560,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,
@@ -267,7 +580,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,
@@ -290,7 +605,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
@@ -345,6 +661,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"
@@ -358,6 +680,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

package/codex-skills/force-model/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: force-model
+description: "Pin this Codex session to a specific model through the Weave Router."
+---
+
+<!-- weave-router managed force-model skill -->
+
+When the user invokes `$force-model <model-id>` (or asks to use the `$fm` alias), send a normal user message whose first character is one literal space, followed by `/force-model ` and the requested model id. Do not use a Codex slash command and do not omit the leading space. For example, send exactly:
+
+```text
+ /force-model gpt-5.6-terra
+```
+
+Preserve any model id exactly as provided. Report the router's response after it returns.

package/codex-skills/router-feedback/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: router-feedback
+description: "Submit feedback about a Weave Router decision or model performance."
+---
+
+<!-- weave-router managed router-feedback skill -->
+
+When the user invokes `$router-feedback <feedback>` (or asks to use the `$rf` alias), send a normal user message whose first character is one literal space, followed by `/router-feedback ` and the feedback text. Do not use a Codex slash command and do not omit the leading space. Preserve the feedback text exactly. For example:
+
+```text
+ /router-feedback the selected model struggled with this task
+```
+
+Report the router's response after it returns.

package/codex-skills/unforce-model/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: unforce-model
+description: "Clear the active Weave Router model pin for this Codex session."
+---
+
+<!-- weave-router managed unforce-model skill -->
+
+When the user invokes `$unforce-model` (or asks to use the `$ufm` alias), send a normal user message whose first character is one literal space, followed by `/unforce-model`. Do not use a Codex slash command and do not omit the leading space. Send exactly:
+
+```text
+ /unforce-model
+```
+
+Report the router's response after it returns.

package/commands/models.md

@@ -0,0 +1,46 @@
+---
+description: Alias for /router-models — list the models the Weave Router may route to, and turn them on or off.
+argument-hint: [model or provider to enable/disable]
+allowed-tools: Bash(npx:*)
+---
+
+Show me which models this installation lets the Weave Router pick from, and
+change that selection when I ask. This is the same list — and the same stored
+setting — as the checkboxes on the router dashboard's settings page.
+
+Start by running:
+
+`npx @workweave/router models --claude{{SCOPE}}`
+
+That prints every deployed model grouped by provider, with `[x]` for models the
+router may pick and `[ ]` for models it may not. Present it back to me as a
+compact checklist in that same `[x]` / `[ ]` form, keeping the provider
+grouping and the exact model ids — I select models by id.
+
+Then:
+
+- If I named models or providers in `$ARGUMENTS`, work out whether I want them
+  on or off from how I phrased it, and apply it with
+  `npx @workweave/router models enable <id>... --claude{{SCOPE}}` or
+  `npx @workweave/router models disable <id>... --claude{{SCOPE}}` (add
+  `providers` before `enable`/`disable` to switch a whole provider). Several
+  ids can go in one call. Then re-run the list and show me the result.
+- If I named nothing, stop after the list and ask which ones I want to change.
+  Don't change anything I didn't ask for.
+
+Other things I might ask for:
+
+- Rank models by preference:
+  `npx @workweave/router models prefer <id> <id>... --claude{{SCOPE}}` (order
+  matters), or `npx @workweave/router models prefer clear --claude{{SCOPE}}` to
+  drop the ranking.
+- Providers only: `npx @workweave/router models providers --claude{{SCOPE}}`.
+
+If the command reports that this router doesn't expose model selection, that's
+a Weave-hosted router: model selection belongs to the whole organization there,
+so tell me to change it at https://router.workweave.ai/dashboard/settings —
+don't try to work around it. Its listing carries no on/off state, so present it
+as a plain list; don't infer which models are enabled.
+
+Disabling a model takes effect on the router's next routing decision; no
+restart is needed.

package/commands/router-models.md

@@ -0,0 +1,46 @@
+---
+description: List the models the Weave Router may route to, and turn them on or off.
+argument-hint: [model or provider to enable/disable]
+allowed-tools: Bash(npx:*)
+---
+
+Show me which models this installation lets the Weave Router pick from, and
+change that selection when I ask. This is the same list — and the same stored
+setting — as the checkboxes on the router dashboard's settings page.
+
+Start by running:
+
+`npx @workweave/router models --claude{{SCOPE}}`
+
+That prints every deployed model grouped by provider, with `[x]` for models the
+router may pick and `[ ]` for models it may not. Present it back to me as a
+compact checklist in that same `[x]` / `[ ]` form, keeping the provider
+grouping and the exact model ids — I select models by id.
+
+Then:
+
+- If I named models or providers in `$ARGUMENTS`, work out whether I want them
+  on or off from how I phrased it, and apply it with
+  `npx @workweave/router models enable <id>... --claude{{SCOPE}}` or
+  `npx @workweave/router models disable <id>... --claude{{SCOPE}}` (add
+  `providers` before `enable`/`disable` to switch a whole provider). Several
+  ids can go in one call. Then re-run the list and show me the result.
+- If I named nothing, stop after the list and ask which ones I want to change.
+  Don't change anything I didn't ask for.
+
+Other things I might ask for:
+
+- Rank models by preference:
+  `npx @workweave/router models prefer <id> <id>... --claude{{SCOPE}}` (order
+  matters), or `npx @workweave/router models prefer clear --claude{{SCOPE}}` to
+  drop the ranking.
+- Providers only: `npx @workweave/router models providers --claude{{SCOPE}}`.
+
+If the command reports that this router doesn't expose model selection, that's
+a Weave-hosted router: model selection belongs to the whole organization there,
+so tell me to change it at https://router.workweave.ai/dashboard/settings —
+don't try to work around it. Its listing carries no on/off state, so present it
+as a plain list; don't infer which models are enabled.
+
+Disabling a model takes effect on the router's next routing decision; no
+restart is needed.

package/directives.tsv

@@ -0,0 +1,12 @@
+# 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