@indigoai-us/hq-cli 5.345.16 → 5.345.18

package/CHANGELOG.md

@@ -2,10 +2,17 @@
 
 ## [Unreleased]
 
+## [5.345.18] — 2026-10-06
+- Git Bash forwarders now keep slash commands intact and convert file path arguments that hq needs on Windows.
+- Lane placement and Claude account-balance refusals now show the requested placement, actual host, balance host when different, and the model values and sources used for an unavailable-account decision.
+
 ## [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.
 
-- 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.14] — 2026-10-06

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-accounts.js

@@ -197,6 +197,7 @@ export function createLaneAccountsHandlers(deps) {
                     target_host: host.capacity.host,
                     error: isLanesError(err) ? err.error : "claude_account_balance_selection_failed",
                     message: dispatchErrorMessage(err),
+                    ...(isLanesError(err) ? { details: err.details } : {}),
                 };
             }
         });

package/dist/commands/lanes.js

@@ -3472,14 +3472,20 @@ async function runCreate(ctx, opts) {
         const targetHost = placementBalanceHostOverride ?? placementHostOverride ?? (outpostId !== undefined
             ? { kind: "outpost", id: outpostId }
             : laneHostFromCtx(ctx));
+        const actualTargetHost = placementHostOverride ?? (outpostId !== undefined
+            ? { kind: "outpost", id: outpostId }
+            : { kind: "local", id: ctx.hostname() });
         balanceTargetHost = targetHost;
         balanceHostLoad = await loadClaudeBalanceHostSnapshots(ctx, hqRoot, config);
         const selected = selectClaudeAccount({
             hosts: balanceHostLoad.snapshots,
             targetHost,
+            actualTargetHost,
+            requestedPlacement: placementToApply ?? null,
             config,
             quotaState: loadQuotaState(hqRoot),
             ...(modelToValidate !== undefined ? { model: modelToValidate } : {}),
+            requestedModelSource: cliModel !== undefined ? "flag" : profileModel !== undefined ? "profile" : "default",
             recentUsageEnabled: await readClaudeAccountBalanceSignalsEnabled(ctx, company ?? undefined),
             now: ctx.now(),
             ...(allowedAccounts !== undefined ? { allowedAccounts } : {}),
@@ -3523,12 +3529,18 @@ async function runCreate(ctx, opts) {
                 const hosts = balanceHostLoad.snapshots.map((host) => host.capacity.host.kind === localHost.kind && host.capacity.host.id === localHost.id
                     ? refreshedLocal
                     : host);
+                const actualTargetHostForPersist = placementHostOverride ?? (outpostId !== undefined
+                    ? { kind: "outpost", id: outpostId }
+                    : { kind: "local", id: ctx.hostname() });
                 const selected = selectClaudeAccount({
                     hosts,
                     targetHost: balanceTargetHost,
+                    actualTargetHost: actualTargetHostForPersist,
+                    requestedPlacement: placementToApply ?? null,
                     config,
                     quotaState: loadQuotaState(hqRoot),
                     ...(modelToValidate !== undefined ? { model: modelToValidate } : {}),
+                    requestedModelSource: cliModel !== undefined ? "flag" : profileModel !== undefined ? "profile" : "default",
                     recentUsageEnabled: await readClaudeAccountBalanceSignalsEnabled(ctx, company ?? undefined),
                     now: ctx.now(),
                     ...(allowedAccounts !== undefined ? { allowedAccounts } : {}),
@@ -6802,6 +6814,11 @@ async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile, opti
     // 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 selectionModelSource = preservedModel !== undefined || pinnedModel !== undefined
+        ? "lane"
+        : profileModel !== undefined
+            ? "profile"
+            : "default";
     const model = resolveLaneModel({
         cliModel: pinnedModel,
         profileModel,
@@ -6829,11 +6846,14 @@ async function selectAutomaticClaudeResumeAccount(ctx, lane, workerProfile, opti
     const selectionInput = {
         hosts: balanceHosts.snapshots,
         targetHost: lane.host,
+        actualTargetHost: lane.host,
+        requestedPlacement: null,
         config,
         quotaState: loadQuotaState(hqRoot),
         recentUsageEnabled: await readClaudeAccountBalanceSignalsEnabled(ctx, lane.company ?? undefined),
         now: ctx.now(),
         ...(selectionModel !== undefined ? { model: selectionModel } : {}),
+        requestedModelSource: selectionModelSource,
         unavailableHosts: balanceHosts.unavailableHosts,
     };
     let selected;

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

@@ -1,6 +1,6 @@
 import type { AuthState } from "./accounts.js";
 import type { HostCapacityAccount, HostCapacitySnapshot } from "./host-capacity.js";
-import type { LaneHost, LaneRecord, LanesConfig } from "./types.js";
+import type { LaneHost, LanePlacementPolicy, LaneRecord, LanesConfig } from "./types.js";
 import { type QuotaState } from "./quota.js";
 export declare const BALANCE_LIVE_STATES: readonly ["running", "queued", "awaiting_input"];
 export declare const BALANCE_MOVABLE_STATES: readonly ["interrupted", "done", "awaiting_input"];
@@ -81,6 +81,10 @@ export declare function selectClaudeAccount(input: {
     recentUsageEnabled?: boolean;
     now?: Date;
     explicitAccount?: string;
+    requestedModelSource?: "flag" | "profile" | "lane" | "default";
+    requestedPlacement?: LanePlacementPolicy | null;
+    /** Actual host where the lane would run; targetHost may be a distinct balance host. */
+    actualTargetHost?: LaneHost;
     unavailableHosts?: readonly BalanceHostGap[];
 }): ClaudeAccountSelection;
 export declare function accountLoadsForReport(input: {

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

@@ -119,6 +119,9 @@ function targetIneligibilityReason(accountId, globalEnabled, allowedAccounts, ta
         return "login_status_unknown";
     return undefined;
 }
+function configModelForAccount(config, accountId) {
+    return config.providers.claude.accounts[accountId]?.model;
+}
 function buildLoads(input) {
     const configAccounts = input.config.providers.claude.accounts;
     const targetHost = input.target.capacity.host;
@@ -156,10 +159,16 @@ function buildLoads(input) {
     return { loads, skipped };
 }
 export function selectClaudeAccount(input) {
+    const actualTargetHost = input.actualTargetHost ?? input.targetHost;
+    const placementDetails = {
+        requested_placement: input.requestedPlacement ?? null,
+        target_host: actualTargetHost,
+        ...(sameHost(actualTargetHost, input.targetHost) ? {} : { balance_host: input.targetHost }),
+    };
     const target = input.hosts.find((host) => sameHost(host.capacity.host, input.targetHost));
     if (!target) {
         throw new LanesError("claude_account_balance_target_host_unavailable", `Cannot verify Claude accounts on target host ${input.targetHost.kind}:${input.targetHost.id}`, {
-            target_host: input.targetHost,
+            ...placementDetails,
             unavailable_hosts: input.unavailableHosts ?? [],
         });
     }
@@ -170,8 +179,16 @@ export function selectClaudeAccount(input) {
         if (!selected || !selected.eligible) {
             throw new LanesError("claude_account_balance_account_unavailable", `Explicit Claude account ${JSON.stringify(input.explicitAccount)} is unavailable on ${input.targetHost.kind}:${input.targetHost.id}`, {
                 account: input.explicitAccount,
-                target_host: input.targetHost,
                 reason: selected?.ineligible_reason ?? "unknown_account",
+                ...placementDetails,
+                compared: {
+                    requested_model: input.model ?? configModelForAccount(input.config, input.explicitAccount) ?? input.config.providers.claude.model ?? null,
+                    requested_model_source: input.requestedModelSource ?? "default",
+                    account_model: configModelForAccount(input.config, input.explicitAccount) ?? null,
+                    account_model_source: `personal/lanes/config.json#providers.claude.accounts.${input.explicitAccount}.model`,
+                    host: input.targetHost,
+                    reason: selected?.ineligible_reason ?? "unknown_account",
+                },
                 account_reasons: skipped,
                 unavailable_hosts: input.unavailableHosts ?? [],
             });
@@ -196,7 +213,7 @@ export function selectClaudeAccount(input) {
             : "";
         throw new LanesError("claude_account_balance_no_eligible_account", `No enabled, logged-in Claude account is available on ${input.targetHost.kind}:${input.targetHost.id}${unknownLoginDetail}`, {
             provider: "claude",
-            target_host: input.targetHost,
+            ...placementDetails,
             account_reasons: loads.map((load) => ({
                 account: load.account,
                 reason: load.ineligible_reason ?? "unavailable",

package/dist/lib/lanes/spawn.js

@@ -334,11 +334,18 @@ function selectSpawnAccount(input) {
         const selection = selectClaudeAccount({
             hosts: [{ capacity, lanes, laneListAvailable: true }],
             targetHost: lane.host,
+            actualTargetHost: lane.host,
+            requestedPlacement: null,
             config,
             quotaState: loadQuotaState(hqRoot),
             ...((recordedModel ?? pinnedModel ?? profileModel) !== undefined
                 ? { model: recordedModel ?? pinnedModel ?? profileModel }
                 : {}),
+            requestedModelSource: recordedModel !== undefined || pinnedModel !== undefined
+                ? "lane"
+                : profileModel !== undefined
+                    ? "profile"
+                    : "default",
         });
         return {
             account: resolveAccount(lane.provider, selection.account, config, context),

package/package.json

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