@indigoai-us/hq-cli 5.345.15 → 5.345.17

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## [Unreleased]
 
+## [5.345.17] — 2026-10-06
+- Git Bash forwarders now keep slash commands intact and convert file path arguments that hq needs on Windows.
+
+## [5.345.16] — 2026-10-06
+- Claude account model settings are defaults, so explicit lane models remain eligible; explicit account selections on create, resume, and message are recorded as CLI choices.
+- When `hq-anywhere-runtime` is enabled, `hq install --global --runtime claude --via plugin` installs the `hq` plugin from the `indigoai-us/hq-packages` Claude marketplace, and `hq install @indigoai-us/hq-anywhere` installs the Codex pack from that repository. The flag-off path refuses the HQ Anywhere alias without fetching a package source.
+
 ## [5.345.15] — 2026-10-06
 - Route live hook Sentry reports through the fast CLI path.
 

package/assets/scaffold/core/scripts/generate-workers-registry.sh

@@ -1,13 +1,33 @@
 #!/usr/bin/env bash
-# FORWARDER — native implementation: `hq core generate-workers-registry`.
+# FORWARDER — the implementation of this script now lives in the hq CLI.
 #
-# This preserves the legacy script ABI. It discovers the live HQ root exactly
-# as the original script did, forwards every argument untouched, and execs the
-# CLI so stdout, stderr, exit status, and signal disposition remain the child's.
+# It ships at assets/scaffold/core/scripts/generate-workers-registry.sh inside @indigoai-us/hq-cli and
+# runs as the hidden command `hq core generate-workers-registry`. This file stays behind so every
+# existing caller — skills, other scripts, CI, and muscle memory — keeps working
+# against the path it already knows.
+#
+# Why the implementation moved: it is a derived-index generator invoked explicitly and by reindex, so
+# process startup is immaterial and the CLI already owns the index primitives.
+#
+# Equivalence is not assumed. The CLI's native implementation is pinned against a
+# byte-frozen copy of this script's pre-migration source by a differential suite
+# (hq-cli e2e/registry-scan-differential.test.ts), which compares exit status,
+# stdout, stderr and a sha256 manifest of every file touched, across repeated runs.
+#
+# The ABI is preserved exactly: arguments are forwarded unchanged, stdin is never
+# read by this file, stdout and stderr are inherited untouched, and the child
+# replaces this process so its exit code and signal disposition become the
+# caller's.
 
 set -euo pipefail
 
-HQ_ROOT="${HQ_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)}"
+FORWARDER_PATH="${BASH_SOURCE[0]}"
+FORWARDER_DIR="${FORWARDER_PATH%/*}"
+[ "$FORWARDER_DIR" != "$FORWARDER_PATH" ] || FORWARDER_DIR=.
+SCRIPT_DIR="$(cd "$FORWARDER_DIR" && pwd)"
+
+# This forwarder sits in the tree it targets, so its own location IS the root.
+HQ_ROOT="${HQ_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
 
 if ! command -v hq >/dev/null 2>&1; then
   echo "generate-workers-registry.sh: requires the hq CLI — this script's implementation now ships with it." >&2
@@ -15,4 +35,108 @@ if ! command -v hq >/dev/null 2>&1; then
   exit 127
 fi
 
-exec hq core --hq-root "$HQ_ROOT" generate-workers-registry "$@"
+if [ -f "$SCRIPT_DIR/lib/hq-cli-floor.sh" ]; then
+  # shellcheck source=lib/hq-cli-floor.sh
+  . "$SCRIPT_DIR/lib/hq-cli-floor.sh"
+  hq_cli_floor_check "generate-workers-registry.sh" "5.78.0"
+fi
+
+# MSYS path conversion is disabled for the hq process so slash commands arrive unchanged.
+# Convert only this generated root path to Windows form for the native CLI.
+if command -v cygpath >/dev/null 2>&1; then
+  HQ_ROOT="$(cygpath -m "$HQ_ROOT")"
+fi
+
+forwarded_args=("$@")
+forwarded_arg_count=$#
+PATH_OPERANDS=none
+convert_forwarded_path() {
+  local arg_index="$1"
+  local value="${forwarded_args[$arg_index]}"
+  case "$value" in
+    /*) forwarded_args[$arg_index]="$(cygpath -m "$value")" ;;
+  esac
+}
+
+if command -v cygpath >/dev/null 2>&1; then
+  IFS=';' read -r -a path_rules <<< "$PATH_OPERANDS"
+  for path_rule in "${path_rules[@]}"; do
+    case "$path_rule" in
+      none) ;;
+      position:*)
+        index="${path_rule#position:}"
+        if (( index < forwarded_arg_count )); then convert_forwarded_path "$index"; fi
+        ;;
+      first-nonoption)
+        for ((index = 0; index < forwarded_arg_count; index++)); do
+          case "${forwarded_args[index]}" in --*) ;; *) convert_forwarded_path "$index"; break ;; esac
+        done
+        ;;
+      all-nonoptions)
+        for ((index = 0; index < forwarded_arg_count; index++)); do
+          case "${forwarded_args[index]}" in --*) ;; *) convert_forwarded_path "$index" ;; esac
+        done
+        ;;
+      options:*)
+        IFS=, read -r -a path_options <<< "${path_rule#options:}"
+        for ((index = 0; index < forwarded_arg_count; index++)); do
+          for path_option in "${path_options[@]}"; do
+            case "${forwarded_args[index]}" in
+              "$path_option")
+                index=$((index + 1))
+                if (( index < forwarded_arg_count )); then convert_forwarded_path "$index"; fi
+                break
+                ;;
+              "$path_option"=*)
+                value="${forwarded_args[index]#*=}"
+                case "$value" in /*) forwarded_args[index]="${path_option}=$(cygpath -m "$value")" ;; esac
+                break
+                ;;
+            esac
+          done
+        done
+        ;;
+      comma:*)
+        path_option="${path_rule#comma:}"
+        for ((index = 0; index < forwarded_arg_count; index++)); do
+          case "${forwarded_args[index]}" in
+            "$path_option")
+              index=$((index + 1))
+              if (( index < forwarded_arg_count )); then
+                IFS=, read -r -a path_values <<< "${forwarded_args[index]}"
+                converted_values=()
+                for path_value in "${path_values[@]}"; do
+                  case "$path_value" in /*) converted_values+=("$(cygpath -m "$path_value")") ;; *) converted_values+=("$path_value") ;; esac
+                done
+                value="$(IFS=,; printf '%s' "${converted_values[*]}")"
+                forwarded_args[index]="$value"
+              fi
+              break
+              ;;
+            "$path_option"=*)
+              value="${forwarded_args[index]#*=}"
+              case "$value" in
+                /*,*|/*)
+                  IFS=, read -r -a path_values <<< "$value"
+                  converted_values=()
+                  for path_value in "${path_values[@]}"; do
+                    case "$path_value" in /*) converted_values+=("$(cygpath -m "$path_value")") ;; *) converted_values+=("$path_value") ;; esac
+                  done
+                  value="$(IFS=,; printf '%s' "${converted_values[*]}")"
+                  forwarded_args[index]="${path_option}=$value"
+                  ;;
+              esac
+              break
+              ;;
+          esac
+        done
+        ;;
+      *) echo "unknown path_operands rule: $path_rule" >&2; exit 70 ;;
+    esac
+  done
+fi
+if [ "$forwarded_arg_count" -gt 0 ]; then
+  MSYS2_ARG_CONV_EXCL='*' exec hq core --hq-root "$HQ_ROOT" generate-workers-registry "${forwarded_args[@]}"
+else
+  MSYS2_ARG_CONV_EXCL='*' exec hq core --hq-root "$HQ_ROOT" generate-workers-registry
+fi

package/assets/scaffold/core/scripts/hq-session.sh

@@ -60,7 +60,7 @@ if [ "${HQ_HQ_SESSION_NO_CLI:-}" != "1" ]; then
     case "$__hs_caps" in
       *hq-session*)
         case "$__hs_caps" in
-          *exact-company-directory-match-v1*) exec hq core hq-session "$@" ;;
+          *exact-company-directory-match-v1*) MSYS2_ARG_CONV_EXCL='*' exec hq core hq-session "$@" ;;
         esac
         ;;
     esac

package/assets/scaffold/core/scripts/lib/hq-cli-floor.sh

@@ -0,0 +1,342 @@
+#!/usr/bin/env bash
+# Shared hq-cli version-floor helpers for setup and the standalone hook doctor.
+# Keep this compatible with macOS Bash 3.2 and Linux Bash 5.
+
+HQ_CLI_FLOOR_UPGRADE_COMMAND='npm install -g @indigoai-us/hq-cli@latest'
+
+# Print the top-level requiresHqCli value from core/core.yaml without yq.
+# Return 1 when the key/file is absent and 2 when the key is duplicated.
+hq_cli_floor_required() {
+  local hq_root="$1"
+  local core_yaml="${hq_root%/}/core/core.yaml"
+  [ -r "$core_yaml" ] || return 1
+
+  awk '
+    BEGIN { found = 0; invalid = 0 }
+    /^requiresHqCli[[:space:]]*:/ {
+      if (found) { invalid = 1; next }
+      found = 1
+      value = $0
+      sub(/^requiresHqCli[[:space:]]*:[[:space:]]*/, "", value)
+      sub(/[[:space:]]+#.*$/, "", value)
+      sub(/^[[:space:]]*/, "", value)
+      sub(/[[:space:]]*$/, "", value)
+      quote = sprintf("%c", 39)
+      first = substr(value, 1, 1)
+      last = substr(value, length(value), 1)
+      if ((first == "\"" && last == "\"") || (first == quote && last == quote)) {
+        value = substr(value, 2, length(value) - 2)
+      }
+    }
+    END {
+      if (invalid) exit 2
+      if (!found) exit 1
+      print value
+    }
+  ' "$core_yaml"
+}
+
+# Resolve an executable through symlinks using portable readlink calls.
+_hq_cli_floor_resolve_executable() {
+  local executable="$1" link_dir link_target hops=0
+  case "$executable" in
+    /*) ;;
+    *) executable="$PWD/$executable" ;;
+  esac
+
+  while [ -L "$executable" ]; do
+    hops=$((hops + 1))
+    [ "$hops" -le 40 ] || return 1
+    link_dir="${executable%/*}"
+    [ -n "$link_dir" ] || link_dir="/"
+    link_dir="$(cd -P "$link_dir" 2>/dev/null && pwd)" || return 1
+    link_target="$(readlink "$executable" 2>/dev/null)" || return 1
+    case "$link_target" in
+      /*) executable="$link_target" ;;
+      *) executable="$link_dir/$link_target" ;;
+    esac
+  done
+
+  [ -f "$executable" ] || return 1
+  link_dir="${executable%/*}"
+  [ -n "$link_dir" ] || link_dir="/"
+  link_dir="$(cd -P "$link_dir" 2>/dev/null && pwd)" || return 1
+  printf '%s/%s\n' "${link_dir%/}" "${executable##*/}"
+}
+
+_hq_cli_floor_package_version() {
+  local package_json="$1"
+  awk -F '"' '
+    {
+      for (i = 2; i + 2 <= NF; i += 4) {
+        key = $i
+        value = $(i + 2)
+        if (key == "name" && package_name == "") package_name = value
+        else if (key == "version" && package_version == "") package_version = value
+      }
+    }
+    END {
+      if (package_name == "@indigoai-us/hq-cli" && package_version != "") {
+        print package_version
+      }
+    }
+  ' "$package_json"
+}
+
+# Read the package version using shell builtins on the warm path. The npm
+# package's top-level version is the first version key in its package.json.
+_hq_cli_floor_package_version_builtin() {
+  local package_json="$1" line
+  while IFS= read -r line || [ -n "$line" ]; do
+    if [[ "$line" =~ \"version\"[[:space:]]*:[[:space:]]*\"([^\"]+)\" ]]; then
+      printf '%s\n' "${BASH_REMATCH[1]}"
+      return 0
+    fi
+  done < "$package_json"
+  return 1
+}
+
+# Return the installed CLI version without starting another Node process on the
+# hook path. A package's version field is the same version reported by its
+# generated hq entry point. Unrecognized or malformed installations retain the
+# historical --version probe as a fallback.
+_hq_cli_floor_installed_version() {
+  local hq_command cached_schema cached_command cached_target cached_package_json cached_version current_package_version
+  local cache_dir cache_file resolved dir package_json package_version parent raw_version parsed_version
+
+  hq_command="$(command -v hq 2>/dev/null)" || return 127
+  [ -n "$hq_command" ] || return 127
+
+  # The cache hit path is intentionally shell-only. Compare the selected hq
+  # entry point and its current target with the entry recorded on the cold
+  # lookup; -nt also catches an in-place replacement of that target.
+  cache_dir="${XDG_CACHE_HOME:-${HOME:-}/.cache}/hq-cli-floor"
+  cache_file="$cache_dir/version"
+  if [ -r "$cache_file" ]; then
+    {
+      IFS= read -r cached_schema || cached_schema=""
+      IFS= read -r cached_command || cached_command=""
+      IFS= read -r cached_target || cached_target=""
+      IFS= read -r cached_package_json || cached_package_json=""
+      IFS= read -r cached_version || cached_version=""
+    } < "$cache_file"
+    if [ "$cached_schema" = "hq-cli-floor.v2" ] &&
+      [ "$cached_command" = "$hq_command" ] && [ -n "$cached_target" ] &&
+      [ -n "$cached_package_json" ] && [ -n "$cached_version" ] &&
+      _hq_cli_floor_parse_semver "$cached_version" >/dev/null 2>&1 &&
+      [ -e "$cached_target" ] && [ -f "$cached_package_json" ] &&
+      [ "$hq_command" -ef "$cached_target" ] &&
+      ! [[ "$cached_target" -nt "$cache_file" ]] &&
+      ! [[ "$cached_package_json" -nt "$cache_file" ]] &&
+      current_package_version="$( _hq_cli_floor_package_version_builtin "$cached_package_json" )" &&
+      [ "$current_package_version" = "$cached_version" ]; then
+      printf '%s\n' "$cached_version"
+      return 0
+    fi
+  fi
+
+  resolved="$( _hq_cli_floor_resolve_executable "$hq_command" 2>/dev/null )" || resolved=""
+  if [ -n "$resolved" ]; then
+    dir="${resolved%/*}"
+    while [ -n "$dir" ] && [ "$dir" != / ]; do
+      package_json="$dir/package.json"
+      if [ -f "$package_json" ]; then
+        package_version="$( _hq_cli_floor_package_version "$package_json" 2>/dev/null )" || package_version=""
+        if [ -n "$package_version" ]; then
+          if mkdir -p "$cache_dir" 2>/dev/null; then
+            local cache_tmp="$cache_file.$$"
+            if {
+              printf 'hq-cli-floor.v2\n'
+              printf '%s\n' "$hq_command"
+              printf '%s\n' "$resolved"
+              printf '%s\n' "$package_json"
+              printf '%s\n' "$package_version"
+            } > "$cache_tmp" 2>/dev/null; then
+              mv -f "$cache_tmp" "$cache_file" 2>/dev/null || rm -f "$cache_tmp" 2>/dev/null || true
+            fi
+          fi
+          printf '%s\n' "$package_version"
+          return 0
+        fi
+      fi
+      parent="${dir%/*}"
+      [ -n "$parent" ] || parent="/"
+      [ "$parent" != "$dir" ] || break
+      dir="$parent"
+    done
+    raw_version="$("$resolved" --version 2>/dev/null)" || return 1
+  else
+    raw_version="$(hq --version 2>/dev/null)" || return 1
+  fi
+  parsed_version="$(printf '%s\n' "$raw_version" | awk '
+    match($0, /[v]?[0-9]+\.[0-9]+\.[0-9]+(-[0-9A-Za-z.-]+)?(\+[0-9A-Za-z.-]+)?/) {
+      version = substr($0, RSTART, RLENGTH)
+      sub(/^v/, "", version)
+      print version
+      exit
+    }
+  ')"
+  [ -n "$parsed_version" ] || return 1
+  printf '%s\n' "$parsed_version"
+}
+
+# Parse strict SemVer fields into private globals for the comparator.
+_hq_cli_floor_parse_semver() {
+  local version="$1" core prerelease="" build="" identifier
+  local -a identifiers=()
+
+  case "$version" in
+    *+*)
+      build="${version#*+}"
+      [[ "$build" != *+* ]] || return 1
+      version="${version%%+*}"
+      [[ "$build" =~ ^[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*$ ]] || return 1
+      ;;
+  esac
+  case "$version" in
+    *-*)
+      prerelease="${version#*-}"
+      version="${version%%-*}"
+      [[ "$prerelease" =~ ^[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*$ ]] || return 1
+      IFS=. read -r -a identifiers <<< "$prerelease"
+      for identifier in "${identifiers[@]}"; do
+        if [[ "$identifier" =~ ^[0-9]+$ ]] && [ "${#identifier}" -gt 1 ] && [[ "$identifier" == 0* ]]; then
+          return 1
+        fi
+      done
+      ;;
+  esac
+
+  core="$version"
+  [[ "$core" =~ ^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)$ ]] || return 1
+  HQ_CLI_FLOOR_MAJOR="${BASH_REMATCH[1]}"
+  HQ_CLI_FLOOR_MINOR="${BASH_REMATCH[2]}"
+  HQ_CLI_FLOOR_PATCH="${BASH_REMATCH[3]}"
+  HQ_CLI_FLOOR_PRERELEASE="$prerelease"
+}
+
+_hq_cli_floor_numeric_compare() {
+  local left="$1" right="$2"
+  if [ "${#left}" -lt "${#right}" ]; then
+    HQ_CLI_FLOOR_CMP=-1
+  elif [ "${#left}" -gt "${#right}" ]; then
+    HQ_CLI_FLOOR_CMP=1
+  elif [ "$left" = "$right" ]; then
+    HQ_CLI_FLOOR_CMP=0
+  elif [[ "$left" > "$right" ]]; then
+    HQ_CLI_FLOOR_CMP=1
+  else
+    HQ_CLI_FLOOR_CMP=-1
+  fi
+}
+
+_hq_cli_floor_prerelease_compare() {
+  local left="$1" right="$2" i left_id right_id left_num right_num
+  local -a left_parts=() right_parts=()
+  IFS=. read -r -a left_parts <<< "$left"
+  IFS=. read -r -a right_parts <<< "$right"
+
+  for ((i = 0; i < ${#left_parts[@]} && i < ${#right_parts[@]}; i++)); do
+    left_id="${left_parts[$i]}"
+    right_id="${right_parts[$i]}"
+    left_num=0
+    right_num=0
+    [[ "$left_id" =~ ^[0-9]+$ ]] && left_num=1
+    [[ "$right_id" =~ ^[0-9]+$ ]] && right_num=1
+    if [ "$left_num" -eq 1 ] && [ "$right_num" -eq 1 ]; then
+      _hq_cli_floor_numeric_compare "$left_id" "$right_id"
+    elif [ "$left_num" -eq 1 ]; then
+      HQ_CLI_FLOOR_CMP=-1
+    elif [ "$right_num" -eq 1 ]; then
+      HQ_CLI_FLOOR_CMP=1
+    elif [ "$left_id" = "$right_id" ]; then
+      HQ_CLI_FLOOR_CMP=0
+    elif [[ "$left_id" > "$right_id" ]]; then
+      HQ_CLI_FLOOR_CMP=1
+    else
+      HQ_CLI_FLOOR_CMP=-1
+    fi
+    [ "$HQ_CLI_FLOOR_CMP" -eq 0 ] || return 0
+  done
+
+  if [ "${#left_parts[@]}" -lt "${#right_parts[@]}" ]; then
+    HQ_CLI_FLOOR_CMP=-1
+  elif [ "${#left_parts[@]}" -gt "${#right_parts[@]}" ]; then
+    HQ_CLI_FLOOR_CMP=1
+  else
+    HQ_CLI_FLOOR_CMP=0
+  fi
+}
+
+# Pure-Bash SemVer comparison. Returns 0 when have >= want, 1 when older, 2 if invalid.
+hq_cli_version_ge() {
+  local LC_ALL=C field left right have_prerelease want_prerelease
+  _hq_cli_floor_parse_semver "$1" || return 2
+  local have_major="$HQ_CLI_FLOOR_MAJOR" have_minor="$HQ_CLI_FLOOR_MINOR"
+  local have_patch="$HQ_CLI_FLOOR_PATCH"
+  have_prerelease="$HQ_CLI_FLOOR_PRERELEASE"
+
+  _hq_cli_floor_parse_semver "$2" || return 2
+  want_prerelease="$HQ_CLI_FLOOR_PRERELEASE"
+
+  for field in major minor patch; do
+    case "$field" in
+      major) left="$have_major"; right="$HQ_CLI_FLOOR_MAJOR" ;;
+      minor) left="$have_minor"; right="$HQ_CLI_FLOOR_MINOR" ;;
+      patch) left="$have_patch"; right="$HQ_CLI_FLOOR_PATCH" ;;
+    esac
+    _hq_cli_floor_numeric_compare "$left" "$right"
+    if [ "$HQ_CLI_FLOOR_CMP" -gt 0 ]; then
+      return 0
+    elif [ "$HQ_CLI_FLOOR_CMP" -lt 0 ]; then
+      return 1
+    fi
+  done
+
+  if [ -z "$have_prerelease" ]; then
+    return 0
+  elif [ -z "$want_prerelease" ]; then
+    return 1
+  fi
+
+  _hq_cli_floor_prerelease_compare "$have_prerelease" "$want_prerelease"
+  [ "$HQ_CLI_FLOOR_CMP" -ge 0 ]
+}
+
+# Return 0 when hq satisfies the floor; otherwise print the required message and return 127.
+hq_cli_floor_check() {
+  local script_name="$1" required="$2" minimum have compare_status
+  if ! command -v hq >/dev/null 2>&1; then
+    printf '%s: requires the hq CLI — this script\047s implementation now ships with it.\n' "$script_name" >&2
+    printf 'Install it with: npm install -g @indigoai-us/hq-cli\n' >&2
+    return 127
+  fi
+
+  case "$required" in
+    '>='*) minimum="${required#>=}" ;;
+    *) minimum="$required" ;;
+  esac
+  if ! _hq_cli_floor_parse_semver "$minimum"; then
+    printf '%s: requiresHqCli has unsupported value %s; expected >=X.Y.Z.\n' "$script_name" "$required" >&2
+    return 64
+  fi
+
+  have="$( _hq_cli_floor_installed_version )" || have=""
+  if [ -z "$have" ]; then
+    printf '%s: could not read hq --version; required hq-cli >= %s.\n' "$script_name" "$minimum" >&2
+    return 126
+  fi
+  if hq_cli_version_ge "$have" "$minimum"; then
+    return 0
+  else
+    compare_status=$?
+  fi
+  if [ "$compare_status" -gt 1 ]; then
+    printf '%s: hq --version returned invalid SemVer %s; required hq-cli >= %s.\n' "$script_name" "$have" "$minimum" >&2
+    return 126
+  fi
+
+  printf '%s: this script needs hq-cli >= %s (found %s); upgrade with: %s\n' \
+    "$script_name" "$minimum" "$have" "$HQ_CLI_FLOOR_UPGRADE_COMMAND" >&2
+  return 127
+}

package/assets/scaffold/core/scripts/qmd-reindex-after-sync.sh

@@ -1,16 +1,133 @@
 #!/usr/bin/env bash
-# FORWARDER — the implementation of this script lives in the hq CLI.
+# FORWARDER — the implementation of this script now lives in the hq CLI.
 #
-# This shipped compatibility path must delegate rather than invoke qmd itself:
-# `hq core qmd-reindex-after-sync` participates in hq-cli's shared embed lock.
-# Arguments, stdio, exit status, and signal disposition are preserved.
+# It ships at assets/scaffold/core/scripts/qmd-reindex-after-sync.sh inside @indigoai-us/hq-cli and
+# runs as the hidden command `hq core qmd-reindex-after-sync`. This file stays behind so every
+# existing caller — skills, other scripts, CI, and muscle memory — keeps working
+# against the path it already knows.
+#
+# Why the implementation moved: it is a cold, explicitly-invoked operation where
+# process startup is immaterial, so hosting it in the CLI costs nothing and
+# keeps the scaffold to configuration rather than code.
+#
+# The ABI is preserved exactly: arguments are forwarded unchanged, stdin is never
+# read by this file, stdout and stderr are inherited untouched, and the child
+# replaces this process so its exit code and signal disposition become the
+# caller's.
 
 set -euo pipefail
 
+FORWARDER_PATH="${BASH_SOURCE[0]}"
+FORWARDER_DIR="${FORWARDER_PATH%/*}"
+[ "$FORWARDER_DIR" != "$FORWARDER_PATH" ] || FORWARDER_DIR=.
+SCRIPT_DIR="$(cd "$FORWARDER_DIR" && pwd)"
+
+# No root is injected: this script derived its root from the CALLER's cwd
+# before it moved (git top level, a cwd walk, or a positional argument), and the
+# CLI preserves that. Anything the caller already exported still applies.
+
 if ! command -v hq >/dev/null 2>&1; then
   echo "qmd-reindex-after-sync.sh: requires the hq CLI — this script's implementation now ships with it." >&2
   echo "Install it with: npm install -g @indigoai-us/hq-cli" >&2
   exit 127
 fi
 
-exec hq core qmd-reindex-after-sync "$@"
+if [ -f "$SCRIPT_DIR/lib/hq-cli-floor.sh" ]; then
+  # shellcheck source=lib/hq-cli-floor.sh
+  . "$SCRIPT_DIR/lib/hq-cli-floor.sh"
+  hq_cli_floor_check "qmd-reindex-after-sync.sh" "5.78.0"
+fi
+
+forwarded_args=("$@")
+forwarded_arg_count=$#
+PATH_OPERANDS=first-nonoption
+convert_forwarded_path() {
+  local arg_index="$1"
+  local value="${forwarded_args[$arg_index]}"
+  case "$value" in
+    /*) forwarded_args[$arg_index]="$(cygpath -m "$value")" ;;
+  esac
+}
+
+if command -v cygpath >/dev/null 2>&1; then
+  IFS=';' read -r -a path_rules <<< "$PATH_OPERANDS"
+  for path_rule in "${path_rules[@]}"; do
+    case "$path_rule" in
+      none) ;;
+      position:*)
+        index="${path_rule#position:}"
+        if (( index < forwarded_arg_count )); then convert_forwarded_path "$index"; fi
+        ;;
+      first-nonoption)
+        for ((index = 0; index < forwarded_arg_count; index++)); do
+          case "${forwarded_args[index]}" in --*) ;; *) convert_forwarded_path "$index"; break ;; esac
+        done
+        ;;
+      all-nonoptions)
+        for ((index = 0; index < forwarded_arg_count; index++)); do
+          case "${forwarded_args[index]}" in --*) ;; *) convert_forwarded_path "$index" ;; esac
+        done
+        ;;
+      options:*)
+        IFS=, read -r -a path_options <<< "${path_rule#options:}"
+        for ((index = 0; index < forwarded_arg_count; index++)); do
+          for path_option in "${path_options[@]}"; do
+            case "${forwarded_args[index]}" in
+              "$path_option")
+                index=$((index + 1))
+                if (( index < forwarded_arg_count )); then convert_forwarded_path "$index"; fi
+                break
+                ;;
+              "$path_option"=*)
+                value="${forwarded_args[index]#*=}"
+                case "$value" in /*) forwarded_args[index]="${path_option}=$(cygpath -m "$value")" ;; esac
+                break
+                ;;
+            esac
+          done
+        done
+        ;;
+      comma:*)
+        path_option="${path_rule#comma:}"
+        for ((index = 0; index < forwarded_arg_count; index++)); do
+          case "${forwarded_args[index]}" in
+            "$path_option")
+              index=$((index + 1))
+              if (( index < forwarded_arg_count )); then
+                IFS=, read -r -a path_values <<< "${forwarded_args[index]}"
+                converted_values=()
+                for path_value in "${path_values[@]}"; do
+                  case "$path_value" in /*) converted_values+=("$(cygpath -m "$path_value")") ;; *) converted_values+=("$path_value") ;; esac
+                done
+                value="$(IFS=,; printf '%s' "${converted_values[*]}")"
+                forwarded_args[index]="$value"
+              fi
+              break
+              ;;
+            "$path_option"=*)
+              value="${forwarded_args[index]#*=}"
+              case "$value" in
+                /*,*|/*)
+                  IFS=, read -r -a path_values <<< "$value"
+                  converted_values=()
+                  for path_value in "${path_values[@]}"; do
+                    case "$path_value" in /*) converted_values+=("$(cygpath -m "$path_value")") ;; *) converted_values+=("$path_value") ;; esac
+                  done
+                  value="$(IFS=,; printf '%s' "${converted_values[*]}")"
+                  forwarded_args[index]="${path_option}=$value"
+                  ;;
+              esac
+              break
+              ;;
+          esac
+        done
+        ;;
+      *) echo "unknown path_operands rule: $path_rule" >&2; exit 70 ;;
+    esac
+  done
+fi
+if [ "$forwarded_arg_count" -gt 0 ]; then
+  MSYS2_ARG_CONV_EXCL='*' exec hq core qmd-reindex-after-sync "${forwarded_args[@]}"
+else
+  MSYS2_ARG_CONV_EXCL='*' exec hq core qmd-reindex-after-sync
+fi

package/assets/scaffold/core/scripts/qmd-reindex-bg.sh

@@ -37,4 +37,24 @@ if ! command -v hq >/dev/null 2>&1; then
   exit 127
 fi
 
-exec hq index background --hq-root "$HQ_ROOT" "$@"
+if command -v cygpath >/dev/null 2>&1; then
+  HQ_ROOT="$(cygpath -m "$HQ_ROOT")"
+fi
+if command -v cygpath >/dev/null 2>&1; then
+  HQ_ROOT="$(cygpath -m "$HQ_ROOT")"
+fi
+forwarded_args=("$@")
+forwarded_arg_count=$#
+if command -v cygpath >/dev/null 2>&1; then
+  for ((index = 0; index < forwarded_arg_count; index++)); do
+    case "${forwarded_args[index]}" in
+      --log) index=$((index + 1)); if ((index < forwarded_arg_count)); then forwarded_args[index]="$(cygpath -m "${forwarded_args[index]}")"; fi ;;
+      --log=*) forwarded_args[index]="--log=$(cygpath -m "${forwarded_args[index]#--log=}")" ;;
+    esac
+  done
+fi
+if [ "$forwarded_arg_count" -gt 0 ]; then
+  MSYS2_ARG_CONV_EXCL='*' exec hq index background --hq-root "$HQ_ROOT" "${forwarded_args[@]}"
+else
+  MSYS2_ARG_CONV_EXCL='*' exec hq index background --hq-root "$HQ_ROOT"
+fi

package/assets/scaffold/core/scripts/scan-packages.sh

@@ -1,12 +1,33 @@
 #!/usr/bin/env bash
-# FORWARDER — native implementation: `hq core scan-packages`.
+# FORWARDER — the implementation of this script now lives in the hq CLI.
 #
-# The original script treated $HQ_ROOT (or the caller's cwd) as authoritative.
-# Keep that root binding and exec the hidden command so the shell ABI survives.
+# It ships at assets/scaffold/core/scripts/scan-packages.sh inside @indigoai-us/hq-cli and
+# runs as the hidden command `hq core scan-packages`. This file stays behind so every
+# existing caller — skills, other scripts, CI, and muscle memory — keeps working
+# against the path it already knows.
+#
+# Why the implementation moved: the pack contribution mapping it encoded is single-sourced in the CLI
+# (src/utils/pack-contributions.ts); keeping a second copy here invited drift.
+#
+# Equivalence is not assumed. The CLI's native implementation is pinned against a
+# byte-frozen copy of this script's pre-migration source by a differential suite
+# (hq-cli e2e/registry-scan-differential.test.ts), which compares exit status,
+# stdout, stderr and a sha256 manifest of every file touched, across repeated runs.
+#
+# The ABI is preserved exactly: arguments are forwarded unchanged, stdin is never
+# read by this file, stdout and stderr are inherited untouched, and the child
+# replaces this process so its exit code and signal disposition become the
+# caller's.
 
 set -euo pipefail
 
-HQ_ROOT="${HQ_ROOT:-$PWD}"
+FORWARDER_PATH="${BASH_SOURCE[0]}"
+FORWARDER_DIR="${FORWARDER_PATH%/*}"
+[ "$FORWARDER_DIR" != "$FORWARDER_PATH" ] || FORWARDER_DIR=.
+SCRIPT_DIR="$(cd "$FORWARDER_DIR" && pwd)"
+
+# This forwarder sits in the tree it targets, so its own location IS the root.
+HQ_ROOT="${HQ_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
 
 if ! command -v hq >/dev/null 2>&1; then
   echo "scan-packages.sh: requires the hq CLI — this script's implementation now ships with it." >&2
@@ -14,4 +35,108 @@ if ! command -v hq >/dev/null 2>&1; then
   exit 127
 fi
 
-exec hq core --hq-root "$HQ_ROOT" scan-packages "$@"
+if [ -f "$SCRIPT_DIR/lib/hq-cli-floor.sh" ]; then
+  # shellcheck source=lib/hq-cli-floor.sh
+  . "$SCRIPT_DIR/lib/hq-cli-floor.sh"
+  hq_cli_floor_check "scan-packages.sh" "5.78.0"
+fi
+
+# MSYS path conversion is disabled for the hq process so slash commands arrive unchanged.
+# Convert only this generated root path to Windows form for the native CLI.
+if command -v cygpath >/dev/null 2>&1; then
+  HQ_ROOT="$(cygpath -m "$HQ_ROOT")"
+fi
+
+forwarded_args=("$@")
+forwarded_arg_count=$#
+PATH_OPERANDS=none
+convert_forwarded_path() {
+  local arg_index="$1"
+  local value="${forwarded_args[$arg_index]}"
+  case "$value" in
+    /*) forwarded_args[$arg_index]="$(cygpath -m "$value")" ;;
+  esac
+}
+
+if command -v cygpath >/dev/null 2>&1; then
+  IFS=';' read -r -a path_rules <<< "$PATH_OPERANDS"
+  for path_rule in "${path_rules[@]}"; do
+    case "$path_rule" in
+      none) ;;
+      position:*)
+        index="${path_rule#position:}"
+        if (( index < forwarded_arg_count )); then convert_forwarded_path "$index"; fi
+        ;;
+      first-nonoption)
+        for ((index = 0; index < forwarded_arg_count; index++)); do
+          case "${forwarded_args[index]}" in --*) ;; *) convert_forwarded_path "$index"; break ;; esac
+        done
+        ;;
+      all-nonoptions)
+        for ((index = 0; index < forwarded_arg_count; index++)); do
+          case "${forwarded_args[index]}" in --*) ;; *) convert_forwarded_path "$index" ;; esac
+        done
+        ;;
+      options:*)
+        IFS=, read -r -a path_options <<< "${path_rule#options:}"
+        for ((index = 0; index < forwarded_arg_count; index++)); do
+          for path_option in "${path_options[@]}"; do
+            case "${forwarded_args[index]}" in
+              "$path_option")
+                index=$((index + 1))
+                if (( index < forwarded_arg_count )); then convert_forwarded_path "$index"; fi
+                break
+                ;;
+              "$path_option"=*)
+                value="${forwarded_args[index]#*=}"
+                case "$value" in /*) forwarded_args[index]="${path_option}=$(cygpath -m "$value")" ;; esac
+                break
+                ;;
+            esac
+          done
+        done
+        ;;
+      comma:*)
+        path_option="${path_rule#comma:}"
+        for ((index = 0; index < forwarded_arg_count; index++)); do
+          case "${forwarded_args[index]}" in
+            "$path_option")
+              index=$((index + 1))
+              if (( index < forwarded_arg_count )); then
+                IFS=, read -r -a path_values <<< "${forwarded_args[index]}"
+                converted_values=()
+                for path_value in "${path_values[@]}"; do
+                  case "$path_value" in /*) converted_values+=("$(cygpath -m "$path_value")") ;; *) converted_values+=("$path_value") ;; esac
+                done
+                value="$(IFS=,; printf '%s' "${converted_values[*]}")"
+                forwarded_args[index]="$value"
+              fi
+              break
+              ;;
+            "$path_option"=*)
+              value="${forwarded_args[index]#*=}"
+              case "$value" in
+                /*,*|/*)
+                  IFS=, read -r -a path_values <<< "$value"
+                  converted_values=()
+                  for path_value in "${path_values[@]}"; do
+                    case "$path_value" in /*) converted_values+=("$(cygpath -m "$path_value")") ;; *) converted_values+=("$path_value") ;; esac
+                  done
+                  value="$(IFS=,; printf '%s' "${converted_values[*]}")"
+                  forwarded_args[index]="${path_option}=$value"
+                  ;;
+              esac
+              break
+              ;;
+          esac
+        done
+        ;;
+      *) echo "unknown path_operands rule: $path_rule" >&2; exit 70 ;;
+    esac
+  done
+fi
+if [ "$forwarded_arg_count" -gt 0 ]; then
+  MSYS2_ARG_CONV_EXCL='*' exec hq core --hq-root "$HQ_ROOT" scan-packages "${forwarded_args[@]}"
+else
+  MSYS2_ARG_CONV_EXCL='*' exec hq core --hq-root "$HQ_ROOT" scan-packages
+fi

package/dist/commands/core.js

@@ -252,6 +252,7 @@ export const SCAFFOLD_ONLY_ASSETS = [
     { asset: "core/scripts/hook-lib.sh", root: "live", summary: "Shared shell primitives sourced by the checkpoint gate" },
     { asset: "core/scripts/lib/session-scope-capability.sh", root: "live", summary: "Session scope-capability lib sourced by hq-session" },
     { asset: "core/scripts/lib/session-id.sh", root: "live", summary: "Session-id resolver lib sourced by hq-session" },
+    { asset: "core/scripts/lib/hq-cli-floor.sh", root: "live", summary: "Shared CLI version-floor helper sourced by generated forwarders" },
     { asset: "core/scripts/lib/work-mesh-enqueue.sh", root: "live", summary: "Work Mesh Live spool enqueue lib sourced by hooks" },
     { asset: "core/scripts/lib/work-mesh-live-hook.sh", root: "live", summary: "Work Mesh Live hook helpers sourced by rebind" },
     { asset: "core/scripts/lib/work-mesh-live-rebind.sh", root: "live", summary: "Work Mesh Live session rebind library sourced by hooks and the native rollback command" },

package/dist/commands/lanes-message.js

@@ -518,7 +518,7 @@ export function createLaneMessageHandlers(deps) {
                     automaticAccountSelection = undefined;
                 }
             }
-            const profileRefreshAccount = refreshProfileSettings && resumeProfile !== undefined &&
+            const profileRefreshAccount = opts.account === undefined && refreshProfileSettings && resumeProfile !== undefined &&
                 lane.account_source !== undefined && lane.account_source !== "cli" &&
                 resumeProfile.profile.meta.provider === lane.provider
                 ? resumeProfile.profile.meta.account ?? (resumeProfile.profile.meta.accounts !== undefined &&
@@ -665,9 +665,10 @@ export function createLaneMessageHandlers(deps) {
                 // lane (the dropbox mechanism) is refused inside prepareAccountMove.
                 move = await prepareAccountMove(ctx, lane, {
                     account: opts.account,
+                    accountSource: "cli",
                     cliModel: opts.model?.trim() || undefined,
                     ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
-                    ...(refreshProfileSettings ? { refreshProfileSettings: true, accountSource: "cli" } : {}),
+                    ...(refreshProfileSettings ? { refreshProfileSettings: true } : {}),
                     ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
                     ...(hireGrantContext !== undefined ? { grantContext: hireGrantContext } : {}),
                     pending: {
@@ -694,6 +695,7 @@ export function createLaneMessageHandlers(deps) {
                             account: selection.account,
                             cliModel: undefined,
                             ...(automatic.historyReason !== undefined ? { accountHistoryReason: automatic.historyReason } : {}),
+                            ...(automatic.preservedModel !== undefined ? { preservedModel: automatic.preservedModel } : {}),
                             ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
                             ...(refreshProfileSettings ? { refreshProfileSettings: true, accountSource: "balanced" } : {}),
                             ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
@@ -746,8 +748,9 @@ export function createLaneMessageHandlers(deps) {
             if (resumeProfile !== undefined && !refreshProfileSettings && (opts.account === undefined || keepCurrentAccount)) {
                 validateResumeProfileModel(ctx, lane, resumeProfile.profile);
             }
-            if (move === null && (resumeProfile !== undefined || resumeEffort !== undefined || (keepCurrentAccount && opts.model !== undefined))) {
+            if (move === null && (resumeProfile !== undefined || resumeEffort !== undefined || keepCurrentAccount)) {
                 lane = recordResumeSetup(ctx, lane, {
+                    ...(keepCurrentAccount ? { accountSource: "cli" } : {}),
                     ...(resumeProfile !== undefined ? { profile: resumeProfile } : {}),
                     ...(refreshProfileSettings ? { refreshProfileSettings: true } : {}),
                     ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),

package/dist/commands/lanes-resume.js

@@ -279,7 +279,7 @@ export function createLaneResumeHandlers(deps) {
                 ...(refreshProfileSettings ? { refreshProfileSettings: true } : {}),
             })
             : undefined;
-        const profileRefreshAccount = refreshProfileSettings && resumeProfile !== undefined &&
+        const profileRefreshAccount = opts.account === undefined && refreshProfileSettings && resumeProfile !== undefined &&
             lane.account_source !== undefined && lane.account_source !== "cli" &&
             resumeProfile.profile.meta.provider === lane.provider
             ? resumeProfile.profile.meta.account ?? (resumeProfile.profile.meta.accounts !== undefined &&
@@ -346,9 +346,10 @@ export function createLaneResumeHandlers(deps) {
             if (opts.account !== undefined && !keepCurrentAccount) {
                 move = await prepareAccountMove(ctx, lane, {
                     account: opts.account,
+                    accountSource: "cli",
                     cliModel: opts.model?.trim() || undefined,
                     ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
-                    ...(refreshProfileSettings ? { refreshProfileSettings: true, accountSource: "cli" } : {}),
+                    ...(refreshProfileSettings ? { refreshProfileSettings: true } : {}),
                     ...(profileRepin !== undefined ? { profileRepin } : {}),
                     ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
                     ...(hireGrantContext !== undefined ? { grantContext: hireGrantContext } : {}),
@@ -432,6 +433,7 @@ export function createLaneResumeHandlers(deps) {
                 ...(move === null && profileRepin !== undefined ? { profileRepin } : {}),
                 ...(move === null && resumeEffort !== undefined ? { effort: resumeEffort } : {}),
                 ...(keepAlive !== undefined ? { keepAlive } : {}),
+                ...(move === null && keepCurrentAccount ? { accountSource: "cli" } : {}),
                 ...(move === null && keepCurrentAccount && opts.model !== undefined ? { cliModel: opts.model } : {}),
                 ...(requestedMeshCompany !== undefined
                     ? { meshCompany: requestedMeshCompany, threadId: meshThreadId }

package/dist/commands/lanes.js

@@ -6488,6 +6488,7 @@ function recordResumeSetup(ctx, lane, input) {
         input.effort === undefined &&
         input.keepAlive === undefined &&
         input.cliModel === undefined &&
+        input.accountSource === undefined &&
         input.meshCompany === undefined &&
         input.clearWorkerProfileChangedQueue !== true &&
         input.refreshProfileSettings !== true &&
@@ -6516,7 +6517,11 @@ function recordResumeSetup(ctx, lane, input) {
         // recorded, so keep-alive may continue it again after this turn.
         if (next.keep_alive_blocked_reason === "terminal_state")
             next.keep_alive_blocked_reason = undefined;
+        if (input.accountSource !== undefined)
+            next.account_source = input.accountSource;
         applyResumeProfileAndEffort(current, next, { ...input, at: ctx.now().toISOString() });
+        if (input.accountSource !== undefined)
+            next.account_source = input.accountSource;
         if (input.clearWorkerProfileChangedQueue === true) {
             next.queued_reason = undefined;
             next.queued_details = undefined;
@@ -6628,19 +6633,14 @@ async function prepareAccountMove(ctx, lane, input) {
     }
     // The model the moved run would use, resolved the way spawn resolves it:
     // the operator's --model, else the lane's own, else the target account's
-    // default, else the provider's. The quota and validation checks use this
-    // effective model so a per-model hold on the target's default is seen
-    // here, before anything is copied. A target that pins a different model
-    // refuses the lane's model unless the operator names one for the move.
+    // default, else the provider's. The target account model is a default, not
+    // a restriction; quota and provider validation use this effective model.
     const model = resolveLaneModel({
         cliModel: input.cliModel ?? pinnedModel,
         profileModel,
         accountModel: targetCfg.model,
         providerModel: providerCfg.model,
     });
-    if (input.cliModel === undefined && lane.model !== undefined && targetCfg.model !== undefined && model !== targetCfg.model) {
-        throw new LanesError("model_unsupported", `Account ${target} pins model ${targetCfg.model}; lane ${laneId} resolves to ${model ?? lane.model}. Pass --model ${targetCfg.model} to move it onto that model`, { provider: lane.provider, account: target, model: model ?? lane.model, account_model: targetCfg.model, lane_id: laneId });
-    }
     const block = quotaBlockFor(loadQuotaState(hqRoot), lane.provider, target, model, now);
     if (block.blocked) {
         throw new LanesError("account_quota_held", `Account ${target} for ${lane.provider} is held${block.quota_reset_at ? ` until ${block.quota_reset_at}` : ""}${block.marker ? ` (${block.marker})` : ""}`, { provider: lane.provider, account: target, quota_reset_at: block.quota_reset_at ?? null, marker: block.marker ?? null, model: model ?? null });
@@ -6785,26 +6785,26 @@ async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile, opti
         : lane.model_source === undefined || lane.model_source === "cli" || lane.model_source === "preserved"
             ? lane.model
             : undefined;
-    const recordedModelAccount = lane.account !== undefined &&
-        (lane.model_source === "cli" || lane.model_source === "preserved")
-        ? lane.account
-        : undefined;
+    const profileModel = profileDefaultsApply ? profile?.meta.model : undefined;
     const quotaModel = resolveLaneModel({
-        cliModel: pinnedModel ?? (lane.model_source === "account" ? lane.model : undefined),
-        profileModel: profileDefaultsApply ? profile?.meta.model : undefined,
-        accountModel: lane.account === undefined ? undefined : config.providers.claude.accounts[lane.account]?.model,
+        cliModel: pinnedModel,
+        profileModel,
+        accountModel: currentConfig?.model,
         providerModel: config.providers.claude.model,
     });
     const recordedAccountQuotaHeld = lane.account !== undefined &&
         quotaBlockFor(loadQuotaState(hqRoot), "claude", lane.account, quotaModel, ctx.now()).blocked;
     const accountNeedsRepair = recordedAccountUnavailable || recordedAccountQuotaHeld;
     const repairUnavailableAccount = options.repairUnavailableAccount === true && accountNeedsRepair;
-    const preservedModel = repairUnavailableAccount && lane.model_source === "account"
+    const preservedModel = repairUnavailableAccount && recordedAccountUnavailable && lane.model_source === "account"
         ? lane.model ?? currentConfig?.model
         : undefined;
+    // Repair keeps an account-derived model pinned through the move; plain
+    // automatic rebalancing resolves each candidate's account default itself.
+    const selectionModel = preservedModel ?? pinnedModel ?? profileModel;
     const model = resolveLaneModel({
-        cliModel: preservedModel ?? pinnedModel,
-        profileModel: profileDefaultsApply ? profile?.meta.model : undefined,
+        cliModel: pinnedModel,
+        profileModel,
         accountModel: lane.account === undefined ? undefined : config.providers.claude.accounts[lane.account]?.model,
         providerModel: config.providers.claude.model,
     });
@@ -6824,9 +6824,7 @@ async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile, opti
         allowedAccounts?.includes(lane.account) &&
         currentConfig?.enabled === true &&
         currentTargetAccount?.enabled === true &&
-        currentTargetAccount.logged_in === true &&
-        (model === undefined || currentConfig.model === undefined || currentConfig.model === model ||
-            lane.account === recordedModelAccount))
+        currentTargetAccount.logged_in === true)
         return undefined;
     const selectionInput = {
         hosts: balanceHosts.snapshots,
@@ -6835,8 +6833,7 @@ async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile, opti
         quotaState: loadQuotaState(hqRoot),
         recentUsageEnabled: await readClaudeAccountBalanceSignalsEnabled(ctx, lane.company ?? undefined),
         now: ctx.now(),
-        ...(model !== undefined ? { model } : {}),
-        ...(recordedModelAccount !== undefined ? { recordedModelAccount } : {}),
+        ...(selectionModel !== undefined ? { model: selectionModel } : {}),
         unavailableHosts: balanceHosts.unavailableHosts,
     };
     let selected;
@@ -6853,7 +6850,7 @@ async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile, opti
             Array.isArray(err.details.account_reasons)
             ? err.details.account_reasons.filter((reason) => reason !== null && typeof reason === "object" && !Array.isArray(reason))
             : [];
-        const unavailablePinReasons = new Set(["disabled", "home_missing", "not_logged_in", "model_mismatch", "quota_held"]);
+        const unavailablePinReasons = new Set(["disabled", "home_missing", "not_logged_in", "quota_held"]);
         const everyProfileAccountUnavailable = profilePin !== undefined && profilePin.length > 0 &&
             profilePin.every((account) => accountReasons.some((reason) => reason.account === account && typeof reason.reason === "string" && unavailablePinReasons.has(reason.reason)));
         if (!everyProfileAccountUnavailable || lane.account === undefined ||

package/dist/lib/core-utils/sentry-report.d.ts

@@ -26,7 +26,7 @@ export declare const MAX_SENTRY_REPORT_METADATA_VALUE_BYTES = 256;
  * is owner-approved telemetry for the exact hook script and may include a
  * company directory; it is never a substitute for hook input or a transcript.
  */
-export declare const ALLOWED_SENTRY_REPORT_METADATA_KEYS: readonly ["hook_name", "hook_path", "hook_event", "hook_script", "tool_name", "session_id", "declared_timeout_ms", "elapsed_ms", "remaining_ms", "watchdog_timeout_ms", "hook_timeout_ms", "hq_version", "platform", "load_average", "spawn_ms", "slow_child", "slow_child_ms", "slow_phase", "exit_code", "final_elapsed_ms", "bash_env_set", "cwd_kind", "shell", "nproc", "hook_sequence", "hook_timeout_debug_context"];
+export declare const ALLOWED_SENTRY_REPORT_METADATA_KEYS: readonly ["hook_name", "hook_path", "hook_event", "hook_script", "tool_name", "session_id", "declared_timeout_ms", "elapsed_ms", "remaining_ms", "watchdog_timeout_ms", "hook_timeout_ms", "hq_version", "platform", "load_average", "spawn_ms", "slow_child", "slow_child_ms", "slow_phase", "exit_code", "final_elapsed_ms", "bash_env_set", "cwd_kind", "root_storage_class", "shell", "nproc", "hook_sequence", "hook_timeout_debug_context"];
 export declare const MAX_SENTRY_REPORT_METADATA_KEYS: number;
 export type HookSequenceEntry = {
     script: string;
@@ -47,7 +47,7 @@ type HookTimeoutDebugContext = {
     wait_point: string;
     waiting_child_basename: string;
     waiting_child_elapsed_ms: number;
-    load_average?: number | "unavailable";
+    load_average?: number | "unavailable" | "unsupported_platform";
     spawn_ms?: number | "unavailable";
     process_count?: number | "unavailable";
 };

package/dist/lib/core-utils/sentry-report.js

@@ -177,6 +177,7 @@ export const ALLOWED_SENTRY_REPORT_METADATA_KEYS = [
     "final_elapsed_ms",
     "bash_env_set",
     "cwd_kind",
+    "root_storage_class",
     "shell",
     "nproc",
     "hook_sequence",
@@ -290,6 +291,11 @@ function boundedDebugProbe(value) {
         return value;
     return boundedDebugMilliseconds(value) ?? undefined;
 }
+function boundedDebugLoadAverage(value) {
+    if (value === "unsupported_platform")
+        return value;
+    return boundedDebugProbe(value);
+}
 function boundedDebugPhaseTimings(value) {
     if (!Array.isArray(value) || value.length > MAX_HOOK_TIMEOUT_DEBUG_PHASES)
         return null;
@@ -324,7 +330,7 @@ function boundedHookTimeoutDebugContext(value) {
         phaseTimings === null) {
         return null;
     }
-    const loadAverage = boundedDebugProbe(value.load_average);
+    const loadAverage = boundedDebugLoadAverage(value.load_average);
     const spawnMs = boundedDebugProbe(value.spawn_ms);
     const processCount = boundedDebugProbe(value.process_count);
     const hasLoadAverage = typeof loadAverage === "number";
@@ -439,7 +445,11 @@ function parseSentryReportEvent(stdin) {
             ? boundedHookSequence(rawMetadata[key])
             : key === "hook_timeout_debug_context"
                 ? boundedHookTimeoutDebugContext(rawMetadata[key])
-                : rawMetadata[key];
+                : key === "cwd_kind"
+                    ? closedMetadataValue(rawMetadata[key], SAFE_CWD_KINDS, "unknown")
+                    : key === "root_storage_class"
+                        ? closedMetadataValue(rawMetadata[key], SAFE_ROOT_STORAGE_CLASSES, "unavailable")
+                        : rawMetadata[key];
     }
     if (typeof metadata.slow_child === "string") {
         metadata.slow_child = safeSlowChild(metadata);
@@ -484,6 +494,21 @@ const SAFE_HOOK_EVENT = /^[A-Za-z][A-Za-z0-9_.:-]{0,63}$/;
 const SAFE_HOOK_SCRIPT = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 const SAFE_EXIT_CODE = /^(?:-?[0-9]+|running)$/;
 const SAFE_NPROC = /^[0-9]+$/;
+const SAFE_CWD_KINDS = new Set([
+    "hq-root",
+    "repo",
+    "worktree",
+    "hq_subdir",
+    "root_unset",
+    "root_not_directory",
+    "cwd_unset",
+    "cwd_outside_root",
+]);
+const SAFE_ROOT_STORAGE_CLASSES = new Set([
+    "system_drive",
+    "non_system_fixed_drive",
+    "network_or_mapped_drive",
+]);
 function safeTagValue(value, pattern = SAFE_TAG_TEXT) {
     return pattern.test(value) ? value : "unknown";
 }
@@ -546,14 +571,27 @@ function parsedLoadAverage(metadata) {
         return value;
     if (typeof value !== "string")
         return undefined;
-    if (value === "unavailable")
-        return "unavailable";
+    if (value === "unavailable" || value === "unsupported_platform")
+        return value;
     const match = /^\s*\{?\s*([0-9]+(?:\.[0-9]+)?)/.exec(value);
     if (!match)
         return undefined;
     const parsed = Number(match[1]);
     return Number.isFinite(parsed) ? parsed : undefined;
 }
+function cwdKindTag(metadata) {
+    const value = metadata.cwd_kind;
+    return typeof value === "string" && SAFE_CWD_KINDS.has(value) ? value : "unknown";
+}
+function rootStorageClassTag(metadata) {
+    const value = metadata.root_storage_class;
+    return typeof value === "string" && SAFE_ROOT_STORAGE_CLASSES.has(value)
+        ? value
+        : "unavailable";
+}
+function closedMetadataValue(value, allowed, fallback) {
+    return typeof value === "string" && allowed.has(value) ? value : fallback;
+}
 function operatingSystemName(metadata) {
     const platform = stringMetadata(metadata, "platform", "").toLowerCase();
     if (/windows|win32|mingw|msys|cygwin/.test(platform))
@@ -608,8 +646,8 @@ function hookTimeoutDebugContextTags(context) {
         timeout_debug_wait_point: context.wait_point,
         timeout_debug_waiting_child: context.waiting_child_basename,
         timeout_debug_waiting_child_elapsed_bucket: elapsedBucket(context.waiting_child_elapsed_ms),
-        timeout_debug_load_bucket: context.load_average === "unavailable"
-            ? "unavailable"
+        timeout_debug_load_bucket: typeof context.load_average === "string"
+            ? context.load_average
             : loadBucket(context.load_average),
         timeout_debug_spawn_ms_bucket: debugSpawnMsBucket(context.spawn_ms),
         timeout_debug_process_count_bucket: processCountBucket(context.process_count),
@@ -695,9 +733,10 @@ function hookTimeoutTags(event) {
         hq_core_version: safeMetadataTag(metadata, "hq_version"),
         shell: safeTagValue(shell),
         bash_env: bashEnvTag(metadata),
-        cwd_kind: safeMetadataTag(metadata, "cwd_kind"),
+        cwd_kind: cwdKindTag(metadata),
         os_name: operatingSystemName(metadata),
-        load_bucket: loadAverage === "unavailable" ? "unavailable" : loadBucket(loadAverage),
+        load_bucket: typeof loadAverage === "string" ? loadAverage : loadBucket(loadAverage),
+        root_storage_class: rootStorageClassTag(metadata),
         spawn_ms_bucket: spawnMsBucket(metadata),
         slow_child: safeSlowChild(metadata),
         slow_phase: safeSlowPhase(metadata.slow_phase),

package/dist/lib/lanes/claude-balance.d.ts

@@ -76,8 +76,6 @@ export declare function selectClaudeAccount(input: {
     config: LanesConfig;
     allowedAccounts?: readonly string[];
     model?: string;
-    /** Keep the recorded account eligible for its already-running CLI model. */
-    recordedModelAccount?: string;
     quotaState?: QuotaState;
     /** Recent completed-run tiebreak; callers pass the default-off hq-flags result. */
     recentUsageEnabled?: boolean;

package/dist/lib/lanes/claude-balance.js

@@ -131,12 +131,7 @@ function buildLoads(input) {
         const quotaBlock = input.quotaState === undefined
             ? undefined
             : quotaBlockFor(input.quotaState, "claude", account, quotaModel, input.now);
-        const ineligible = targetIneligibilityReason(account, configAccounts[account]?.enabled === true, input.allowedAccounts, targetLoad) ?? (account !== input.recordedModelAccount &&
-            input.model !== undefined && configuredModel !== undefined && configuredModel !== input.model
-            ? "model_mismatch"
-            : quotaBlock?.blocked === true
-                ? "quota_held"
-                : undefined);
+        const ineligible = targetIneligibilityReason(account, configAccounts[account]?.enabled === true, input.allowedAccounts, targetLoad) ?? (quotaBlock?.blocked === true ? "quota_held" : undefined);
         if (ineligible !== undefined)
             skipped.push({ account, host: targetHost, reason: ineligible });
         const knownCounts = hosts.flatMap((host) => host.live_lanes === null ? [] : [host.live_lanes]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.345.15",
+  "version": "5.345.17",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {