gitbasher 5.1.0 → 5.2.1

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 All notable changes to gitbasher are generated automatically by [semantic-release](https://github.com/semantic-release/semantic-release) from [Conventional Commits](https://www.conventionalcommits.org/) on `main`. The project follows [Semantic Versioning](https://semver.org/).
 
+## [5.2.1](https://github.com/maxbolgarin/gitbasher/compare/v5.2.0...v5.2.1) (2026-07-11)
+
+### 🐛 Bug Fixes
+
+* **commit:** gate AI split by scope count and stop discarding near-complete groupings ([90becec](https://github.com/maxbolgarin/gitbasher/commit/90becec0f49a7a3e57e57e11a71b6909884ab337))
+
+## [5.2.0](https://github.com/maxbolgarin/gitbasher/compare/v5.1.0...v5.2.0) (2026-07-07)
+
+### 🚀 Features
+
+* **ai:** one model per provider with live pickers, reasoning control, and setup safety checks ([a9c6935](https://github.com/maxbolgarin/gitbasher/commit/a9c6935297e84b777c8428203dae7003ef93aa38))
+
+### 🐛 Bug Fixes
+
+* **ai:** extract bare scope from full type(scope) prefixes ([18da7e4](https://github.com/maxbolgarin/gitbasher/commit/18da7e4648a0dda2aec2453305bcdf95110feea7))
+* **config:** move values to global scope instead of shadowing them locally ([648ef37](https://github.com/maxbolgarin/gitbasher/commit/648ef3735dfd6c1aa248369d51bdb57ad42c3353))
+
+### 📚 Documentation
+
+* describe per-provider AI models, live model menus, and reasoning behavior ([dab3cef](https://github.com/maxbolgarin/gitbasher/commit/dab3cef479d619e59e69b6d4f3a75514e7b6d00d))
+
+### 🚨 Tests
+
+* keep [@test](https://github.com/test) descriptions ASCII for bats under bash 3.2 ([1e3fb50](https://github.com/maxbolgarin/gitbasher/commit/1e3fb50071d927b8475178ffdae68afcf7ebc19a))
+
 ## [5.1.0](https://github.com/maxbolgarin/gitbasher/compare/v5.0.1...v5.1.0) (2026-07-03)
 
 ### 🚀 Features

package/README.md

@@ -111,7 +111,7 @@ Every command has a short alias (`gitb c`, `gitb p`, `gitb pu`, `gitb b`, `gitb
 - **AI commit messages** — `gitb c ai` writes the message from your diff. OpenRouter (Gemini/Claude/GPT/…), OpenAI direct, or **fully local via Ollama** — no key, no network, no data leaves your machine.
 - **Safer git** — push/pull detect conflicts up front, `undo` rolls back commit/amend/merge/rebase/stash, `reset` is interactive with a preview.
 - **Whole workflows, not just commands** — `sync`, `wip`, `branch newd`, `merge to-main`, `squash` chain the steps you'd otherwise do by hand.
-- **One file, no deps** — pure bash for every git operation; only the AI features need `jq` and `curl`. Drop the binary anywhere on `PATH` and go. **900+ BATS tests** cover sanitization, git ops, and branch logic.
+- **One file, no deps** — pure bash for every git operation; only the AI features need `jq` and `curl`. Drop the binary anywhere on `PATH` and go. **940+ BATS tests** cover sanitization, git ops, and branch logic.
 
 <p align="center">
   <img src=".github/push.gif" width="640" alt="gitb push demo" />
@@ -253,50 +253,26 @@ export GITB_AI_API_KEY='sk-...'
 <details>
 <summary><b>Default models per provider</b> (click to expand)</summary>
 
-Each task uses a model tuned for speed/cost/quality, picked per provider. Defaults (May 2026):
+One model per provider, used for every task (message generation, subjects, feature grouping). Defaults (July 2026), picked speed-first:
 
-**OpenRouter** (default provider)
+| Provider | Default model | Why |
+|----------|---------------|-----|
+| `openrouter` | `google/gemini-3.5-flash` | Current flash generation, ~0.8s median on a commit-sized prompt, good prose |
+| `openai` | `gpt-5.4-mini` | As fast as nano (~0.8s) with strictly better quality, ~$0.75 / $4.50 per M |
+| `ollama` | `qwen3:8b` | Best small instruction-follower; most stable structured output; ~5 GB on disk |
+| `claude` | `haiku` | CLI startup dominates latency, so the fastest model wins; alias tracks the current generation |
 
-| Task | Default model | Why |
-|------|---------------|-----|
-| `simple` (one-line message) | `google/gemini-3.1-flash-lite` | Fastest model measured (~0.6s), cheapest |
-| `subject` (after manual type/scope) | `google/gemini-3.1-flash-lite` | Short structured output, instant |
-| `full` (header + body) | `google/gemini-3.5-flash` | Same speed class, better prose |
-| `grouping` (atomic-split mapping) | `google/gemini-3.5-flash` | Fast + strict structured output |
+Other good picks: `gpt-5.4-nano` (budget, high volume), `llama3.3:8b` / `qwen2.5-coder:7b` (local), `sonnet` (better prose on the claude provider, noticeably slower).
 
-**OpenAI** — GPT-5.4 family (released March 2026)
+The cloud defaults are hybrid reasoning models that think at "medium" effort out of the box — pure latency for a one-line commit message. gitbasher controls this per request: message generation runs at the provider's reasoning floor (`minimal` on OpenRouter, `none` on OpenAI — measured ~2× faster with identical output), while feature grouping and squash planning run at `low` effort, where a bit of real thinking helps multi-file structure decisions. No configuration needed.
 
-| Task | Default model | Why |
-|------|---------------|-----|
-| All tasks | `gpt-5.4-mini` | Measured as fast as nano (~0.8s) with strictly better quality, ~$0.75 / $4.50 per M |
+`gitb cfg model` shows a **live menu**: the week's most-used and newest text models on OpenRouter (public API, server-side ranking), or the newest chat models visible to your OpenAI key. A typed id is validated against the live catalog (typos die at config time, with an override for brand-new models), and the chosen model is test-driven with one live request before the step completes — a model that can't complete a request never reaches your commits.
 
-`gpt-5.4-nano` (~$0.20 / $1.25 per M) remains a good budget override for high-volume use.
+The model is remembered **per provider** — switching providers never carries a model across (an OpenRouter slug means nothing to the claude CLI), and switching back restores your previous choice, same as API keys:
 
-**Ollama** — fully local
-
-| Task | Default model | Why |
-|------|---------------|-----|
-| All tasks | `qwen3:8b` | Best small instruction-follower among 7/8B models; most stable structured output (rarely drops fields in TSV); ~5 GB on disk, ~25 tok/s on a consumer laptop with GPU |
-
-Other strong local picks: `llama3.3:8b` (general-purpose), `qwen2.5-coder:7b` (code-heavy diffs).
-
-**Claude Code CLI** — local `claude -p`
-
-| Task | Default model | Why |
-|------|---------------|-----|
-| `simple` / `subject` | `haiku` | Fastest and cheapest for one-line output |
-| `full` / `grouping` | `sonnet` | Better prose and strict structured output |
-
-The alias slugs (`haiku`, `sonnet`, `opus`) always resolve to the current model generation; full ids like `claude-haiku-4-5` work too.
-
-Override per task or globally:
 ```bash
-gitb cfg model                                          # interactive
-git config gitbasher.ai-model            <model_id>     # global
-git config gitbasher.ai-model-simple     <model_id>     # per-task
-git config gitbasher.ai-model-subject    <model_id>
-git config gitbasher.ai-model-full       <model_id>
-git config gitbasher.ai-model-grouping   <model_id>
+gitb cfg model                                    # interactive, stores for the active provider
+git config gitbasher.ai-model-<provider> <model_id>   # direct, e.g. gitbasher.ai-model-claude sonnet
 ```
 
 </details>
@@ -905,7 +881,7 @@ Overview-first diffs built for the gitbasher workflow — no flag memorization.
 | `gitbasher.ai-api-key-<provider>` | `gitb cfg ai` | Per-provider AI API key (or `GITB_AI_API_KEY_<PROVIDER>` env); legacy `gitbasher.ai-api-key` is read as a fallback |
 | `gitbasher.ai-provider` | `gitb cfg provider` | `openrouter` (default), `openai`, `ollama`, or `claude` |
 | `gitbasher.ai-base-url` | `git config` | Custom OpenAI-compatible endpoint (LiteLLM, vLLM, remote Ollama) |
-| `gitbasher.ai-model[-task]` | `gitb cfg model` | AI model overrides (per provider) |
+| `gitbasher.ai-model-<provider>` | `gitb cfg model` | Model for that provider (one model for all tasks); legacy `gitbasher.ai-model` is read as a fallback |
 | `gitbasher.ai-proxy` | `gitb cfg proxy` | HTTP proxy for AI calls |
 | `gitbasher.ai-ollama-host` | `git config gitbasher.ai-ollama-host <url>` | Ollama server URL (default `http://localhost:11434`) |
 | `gitbasher.ai-timeout` | `git config gitbasher.ai-timeout <seconds>` | AI request timeout in seconds (default `60`, `300` for ollama/claude) |
@@ -1095,7 +1071,7 @@ PRs welcome. See [CONTRIBUTING.md](./CONTRIBUTING.md) for the dev setup, BATS te
 
 ```bash
 make build               # rebuild dist/gitb
-make test                # run all 900+ tests
+make test                # run all 940+ tests
 make test-file FILE=test_sanitization.bats
 ```
 

package/dist/gitb

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 set -o pipefail
-GITBASHER_VERSION="5.1.0"
+GITBASHER_VERSION="5.2.1"
 if [ "$1" == "init" ] || [ "$1" == "i" ]; then
     git init
 fi
@@ -875,11 +875,22 @@ function print_ai_configuration {
     fi
     local ai_model=$(get_ai_model)
     if [ -n "$ai_model" ]; then
-        echo -e "\tAI model:\t${GREEN}$ai_model${ENDCOLOR} ${GRAY}(all tasks)${ENDCOLOR} $(config_source_tag gitbasher.ai-model)"
+        local model_key="gitbasher.ai-model-${ai_provider}"
+        if [ "$(config_source "$model_key")" = "default" ]; then
+            model_key="gitbasher.ai-model"
+        fi
+        echo -e "\tAI model:\t${GREEN}$ai_model${ENDCOLOR} $(config_source_tag "$model_key")"
     else
-        echo -e "\tAI models:\t${GREEN}$(get_ai_model_for simple)${ENDCOLOR} ${GRAY}(simple/subject)${ENDCOLOR} $(config_source_tag gitbasher.ai-model-simple)"
-        echo -e "\t\t\t${GREEN}$(get_ai_model_for full)${ENDCOLOR} ${GRAY}(full)${ENDCOLOR} $(config_source_tag gitbasher.ai-model-full)"
-        echo -e "\t\t\t${GREEN}$(get_ai_model_for grouping)${ENDCOLOR} ${GRAY}(grouping)${ENDCOLOR} $(config_source_tag gitbasher.ai-model-grouping)"
+        echo -e "\tAI model:\t${GREEN}$(get_ai_default_model)${ENDCOLOR} ${GRAY}(default)${ENDCOLOR}"
+    fi
+    local other_models=""
+    while IFS= read -r prov; do
+        [ -z "$prov" ] && continue
+        [ "$prov" = "$ai_provider" ] && continue
+        other_models="${other_models:+${other_models}, }${prov}"
+    done < <(list_providers_with_model)
+    if [ -n "$other_models" ]; then
+        echo -e "\t\t\t${GRAY}also set for: ${other_models}${ENDCOLOR}"
     fi
 }
 function print_configuration {
@@ -1551,6 +1562,9 @@ function set_config_value {
         git config --local "$1" "$2"
     else
         git config --global "$1" "$2"
+        if [ "$GITBASHER_NO_REPO" != "true" ]; then
+            git config --local --unset "$1" 2>/dev/null || true
+        fi
     fi
     printf '%s\n' "$2"
 }
@@ -1696,9 +1710,9 @@ readonly OPENAI_API_URL="https://api.openai.com/v1/chat/completions"
 readonly AI_DEFAULT_OLLAMA_HOST="http://localhost:11434"
 readonly AI_DEFAULT_PROVIDER="openrouter"
 readonly AI_TEMPERATURE="0.3"
-readonly AI_MAX_TOKENS_SUBJECT=256
-readonly AI_MAX_TOKENS_SIMPLE=512
-readonly AI_MAX_TOKENS_FULL=1024
+readonly AI_MAX_TOKENS_SUBJECT=512
+readonly AI_MAX_TOKENS_SIMPLE=1024
+readonly AI_MAX_TOKENS_FULL=2048
 function get_ai_api_key {
     local provider=$(get_ai_provider)
     local provider_upper
@@ -1834,82 +1848,69 @@ function ai_provider_requires_api_key {
     esac
 }
 function get_ai_model {
+    local provider=$(get_ai_provider)
+    local provider_model
+    provider_model=$(get_config_value "gitbasher.ai-model-${provider}" "")
+    if [ -n "$provider_model" ]; then
+        echo "$provider_model"
+        return
+    fi
     get_config_value gitbasher.ai-model ""
 }
 function set_ai_model {
-    set_config_value gitbasher.ai-model "$1"
-}
-readonly AI_DEFAULT_MODEL_SIMPLE="google/gemini-3.1-flash-lite"
-readonly AI_DEFAULT_MODEL_SUBJECT="google/gemini-3.1-flash-lite"
-readonly AI_DEFAULT_MODEL_FULL="google/gemini-3.5-flash"
-readonly AI_DEFAULT_MODEL_GROUPING="google/gemini-3.5-flash"
-readonly AI_DEFAULT_MODEL_SIMPLE_OPENAI="gpt-5.4-mini"
-readonly AI_DEFAULT_MODEL_SUBJECT_OPENAI="gpt-5.4-mini"
-readonly AI_DEFAULT_MODEL_FULL_OPENAI="gpt-5.4-mini"
-readonly AI_DEFAULT_MODEL_GROUPING_OPENAI="gpt-5.4-mini"
-readonly AI_DEFAULT_MODEL_SIMPLE_OLLAMA="qwen3:8b"
-readonly AI_DEFAULT_MODEL_SUBJECT_OLLAMA="qwen3:8b"
-readonly AI_DEFAULT_MODEL_FULL_OLLAMA="qwen3:8b"
-readonly AI_DEFAULT_MODEL_GROUPING_OLLAMA="qwen3:8b"
-readonly AI_DEFAULT_MODEL_SIMPLE_CLAUDE="haiku"
-readonly AI_DEFAULT_MODEL_SUBJECT_CLAUDE="haiku"
-readonly AI_DEFAULT_MODEL_FULL_CLAUDE="sonnet"
-readonly AI_DEFAULT_MODEL_GROUPING_CLAUDE="sonnet"
-function get_ai_model_for {
-    local task="$1"
-    local task_model
-    task_model=$(get_config_value "gitbasher.ai-model-$task" "")
-    if [ -n "$task_model" ]; then
-        echo "$task_model"
-        return
+    local provider=$(get_ai_provider)
+    set_config_value "gitbasher.ai-model-${provider}" "$1" "$2"
+}
+function migrate_legacy_ai_model_to {
+    local target_provider="$1"
+    local migrated=""
+    local local_legacy=$(git config --local --get gitbasher.ai-model 2>/dev/null)
+    if [ -n "$local_legacy" ]; then
+        if ! git config --local --get "gitbasher.ai-model-${target_provider}" >/dev/null 2>&1; then
+            git config --local "gitbasher.ai-model-${target_provider}" "$local_legacy"
+            migrated="local"
+        fi
+        git config --local --unset gitbasher.ai-model 2>/dev/null || true
     fi
-    local global_model
-    global_model=$(get_ai_model)
-    if [ -n "$global_model" ]; then
-        echo "$global_model"
-        return
+    local global_legacy=$(git config --global --get gitbasher.ai-model 2>/dev/null)
+    if [ -n "$global_legacy" ]; then
+        if ! git config --global --get "gitbasher.ai-model-${target_provider}" >/dev/null 2>&1; then
+            git config --global "gitbasher.ai-model-${target_provider}" "$global_legacy"
+            migrated="${migrated:+$migrated, }global"
+        fi
+        git config --global --unset gitbasher.ai-model 2>/dev/null || true
     fi
+    if [ -n "$migrated" ]; then
+        echo -e "${GRAY}↻ Kept model for provider '${target_provider}' (${migrated})${ENDCOLOR}" >&2
+    fi
+}
+function list_providers_with_model {
+    {
+        git config --local --get-regexp '^gitbasher\.ai-model-' 2>/dev/null
+        git config --global --get-regexp '^gitbasher\.ai-model-' 2>/dev/null
+    } | awk '{print $1}' | sed 's/^gitbasher\.ai-model-//' \
+      | grep -E '^(openrouter|openai|ollama|claude)$' | sort -u
+}
+readonly AI_DEFAULT_MODEL_OPENROUTER="google/gemini-3.5-flash"
+readonly AI_DEFAULT_MODEL_OPENAI="gpt-5.4-mini"
+readonly AI_DEFAULT_MODEL_OLLAMA="qwen3:8b"
+readonly AI_DEFAULT_MODEL_CLAUDE="haiku"
+function get_ai_default_model {
     case "$(get_ai_provider)" in
-        openai)
-            case "$task" in
-                simple)   echo "$AI_DEFAULT_MODEL_SIMPLE_OPENAI" ;;
-                subject)  echo "$AI_DEFAULT_MODEL_SUBJECT_OPENAI" ;;
-                full)     echo "$AI_DEFAULT_MODEL_FULL_OPENAI" ;;
-                grouping) echo "$AI_DEFAULT_MODEL_GROUPING_OPENAI" ;;
-                *)        echo "$AI_DEFAULT_MODEL_SIMPLE_OPENAI" ;;
-            esac
-            ;;
-        ollama)
-            case "$task" in
-                simple)   echo "$AI_DEFAULT_MODEL_SIMPLE_OLLAMA" ;;
-                subject)  echo "$AI_DEFAULT_MODEL_SUBJECT_OLLAMA" ;;
-                full)     echo "$AI_DEFAULT_MODEL_FULL_OLLAMA" ;;
-                grouping) echo "$AI_DEFAULT_MODEL_GROUPING_OLLAMA" ;;
-                *)        echo "$AI_DEFAULT_MODEL_SIMPLE_OLLAMA" ;;
-            esac
-            ;;
-        claude)
-            case "$task" in
-                simple)   echo "$AI_DEFAULT_MODEL_SIMPLE_CLAUDE" ;;
-                subject)  echo "$AI_DEFAULT_MODEL_SUBJECT_CLAUDE" ;;
-                full)     echo "$AI_DEFAULT_MODEL_FULL_CLAUDE" ;;
-                grouping) echo "$AI_DEFAULT_MODEL_GROUPING_CLAUDE" ;;
-                *)        echo "$AI_DEFAULT_MODEL_SIMPLE_CLAUDE" ;;
-            esac
-            ;;
-        *)
-            case "$task" in
-                simple)   echo "$AI_DEFAULT_MODEL_SIMPLE" ;;
-                subject)  echo "$AI_DEFAULT_MODEL_SUBJECT" ;;
-                full)     echo "$AI_DEFAULT_MODEL_FULL" ;;
-                grouping) echo "$AI_DEFAULT_MODEL_GROUPING" ;;
-                *)        echo "$AI_DEFAULT_MODEL_SIMPLE" ;;
-            esac
-            ;;
+        openai) echo "$AI_DEFAULT_MODEL_OPENAI" ;;
+        ollama) echo "$AI_DEFAULT_MODEL_OLLAMA" ;;
+        claude) echo "$AI_DEFAULT_MODEL_CLAUDE" ;;
+        *)      echo "$AI_DEFAULT_MODEL_OPENROUTER" ;;
     esac
 }
-function set_ai_model_for {
-    set_config_value "gitbasher.ai-model-$1" "$2"
+function resolve_ai_model {
+    local model
+    model=$(get_ai_model)
+    if [ -n "$model" ]; then
+        echo "$model"
+        return
+    fi
+    get_ai_default_model
 }
 function get_ai_proxy {
     get_config_value gitbasher.ai-proxy ""
@@ -2164,11 +2165,89 @@ function ollama_list_models {
     local base resp names
     base=$(ollama_api_base)
     resp=$(curl -s --max-time 5 "${base}/api/tags" 2>/dev/null)
-    [ -z "$resp" ] && return 1
     names=$(printf '%s' "$resp" | _parse_ollama_model_names)
+    if [ -z "$names" ] && command -v ollama >/dev/null 2>&1; then
+        names=$(OLLAMA_HOST="$base" ollama list 2>/dev/null \
+            | LC_ALL=C awk 'NR>1 && $1 != "" {print $1}')
+    fi
     [ -z "$names" ] && return 1
     printf '%s\n' "$names"
 }
+function secure_curl_get {
+    local proxy_url="$1"
+    local api_key="$2"
+    local url="$3"
+    (
+        { set +x; } 2>/dev/null
+        unset HISTFILE
+        local curl_cmd=(
+            curl -s
+            --connect-timeout 10
+            --max-time 20
+        )
+        [ -n "$proxy_url" ] && curl_cmd+=(--proxy "$proxy_url")
+        curl_cmd+=("$url")
+        if [ -n "$api_key" ]; then
+            local escaped_key="${api_key//\\/\\\\}"
+            escaped_key="${escaped_key//\"/\\\"}"
+            "${curl_cmd[@]}" --config - <<EOF 2>/dev/null
+header = "Authorization: Bearer ${escaped_key}"
+EOF
+        else
+            "${curl_cmd[@]}" 2>/dev/null
+        fi
+    )
+}
+function _parse_model_ids_json {
+    if command -v jq &>/dev/null; then
+        jq -r '.data[]?.id // empty' 2>/dev/null
+    else
+        LC_ALL=C grep -o '"id"[[:space:]]*:[[:space:]]*"[^"]*"' \
+            | LC_ALL=C sed 's/.*"\([^"]*\)"$/\1/'
+    fi
+}
+function openrouter_list_models {
+    local sort_key="${1:-top-weekly}"
+    local models_url resp ids
+    models_url="${OPENROUTER_API_URL/chat\/completions/models}?sort=${sort_key}"
+    resp=$(secure_curl_get "$(get_ai_proxy)" "" "$models_url")
+    [ -z "$resp" ] && return 1
+    ids=$(printf '%s' "$resp" | _parse_model_ids_json)
+    [ -z "$ids" ] && return 1
+    printf '%s\n' "$ids"
+}
+function openai_list_models {
+    local api_key resp ids
+    api_key=$(get_ai_api_key)
+    [ -z "$api_key" ] && return 1
+    local models_url="${OPENAI_API_URL/chat\/completions/models}"
+    resp=$(secure_curl_get "$(get_ai_proxy)" "$api_key" "$models_url")
+    [ -z "$resp" ] && return 1
+    if command -v jq &>/dev/null; then
+        ids=$(printf '%s' "$resp" | jq -r '.data // [] | sort_by(-(.created // 0)) | .[].id // empty' 2>/dev/null)
+    else
+        ids=$(printf '%s' "$resp" | _parse_model_ids_json)
+    fi
+    ids=$(printf '%s\n' "$ids" \
+        | LC_ALL=C grep -E '^(gpt-|o[0-9]|chatgpt-)' \
+        | LC_ALL=C grep -vE 'embedding|tts|whisper|audio|realtime|dall-e|image|moderation|transcribe|search|instruct')
+    [ -z "$ids" ] && return 1
+    printf '%s\n' "$ids"
+}
+function ai_model_smoke_check {
+    local model out rc
+    model=$(resolve_ai_model)
+    echo -e "${YELLOW}Testing model '${model}' with a live request...${ENDCOLOR}"
+    out=$(call_ai_api "Reply with exactly: OK" "ping" 64 "$model" 2>&1)
+    rc=$?
+    if [ "$rc" -eq 0 ] && [ -n "$out" ]; then
+        echo -e "${GREEN}✓ Model '${model}' responded${ENDCOLOR}"
+        return 0
+    fi
+    echo -e "${RED}✗ Model '${model}' did not respond${ENDCOLOR}" >&2
+    [ -n "$out" ] && printf '%s\n' "$out" | head -4 >&2
+    return 1
+}
 function ai_smoke_check {
     local provider
     provider=$(get_ai_provider)
@@ -2268,14 +2347,17 @@ function _call_claude_cli {
     local model="$3"
     local timeout_s output rc
     timeout_s=$(get_ai_timeout)
+    local -a claude_args=(-p --model "$model" --output-format text
+        --strict-mcp-config --mcp-config '{"mcpServers":{}}'
+        --setting-sources "")
     if command -v perl >/dev/null 2>&1; then
         output=$(printf '%s\n\n%s' "$system_prompt" "$user_prompt" \
-            | perl -e 'alarm shift; exec @ARGV' "$timeout_s" \
-                claude -p --model "$model" --output-format text 2>/dev/null)
+            | MAX_THINKING_TOKENS=0 perl -e 'alarm shift; exec @ARGV' "$timeout_s" \
+                claude "${claude_args[@]}" 2>/dev/null)
         rc=$?
     else
         output=$(printf '%s\n\n%s' "$system_prompt" "$user_prompt" \
-            | claude -p --model "$model" --output-format text 2>/dev/null)
+            | MAX_THINKING_TOKENS=0 claude "${claude_args[@]}" 2>/dev/null)
         rc=$?
     fi
     if [ "$rc" -eq 142 ]; then
@@ -2294,8 +2376,9 @@ function call_ai_api {
     local system_prompt="$1"
     local user_prompt="$2"
     local max_tokens="${3:-$AI_MAX_TOKENS_FULL}"
-    local model="${4:-$(get_ai_model_for simple)}"
+    local model="${4:-$(resolve_ai_model)}"
     local response_format="${5:-}"
+    local reasoning_effort="${6:-}"
     local provider=$(get_ai_provider)
     local api_url=$(get_ai_api_url)
     local api_key=$(get_ai_api_key)
@@ -2328,6 +2411,21 @@ function call_ai_api {
             gpt-5*|o[0-9]*) include_temperature="" ;;
         esac
     fi
+    case "$reasoning_effort" in
+        low|medium|high|"") : ;;
+        *) reasoning_effort="" ;;   # unknown value → provider floor
+    esac
+    local or_reasoning="" oa_reasoning=""
+    if [ -n "$(get_ai_base_url)" ]; then
+        : # custom endpoint — send nothing
+    elif [ "$provider" = "openrouter" ]; then
+        or_reasoning="${reasoning_effort:-minimal}"
+    elif [ "$provider" = "openai" ]; then
+        case "$model" in
+            gpt-5*chat*|chatgpt-*) : ;;
+            gpt-5*|o[0-9]*) oa_reasoning="${reasoning_effort:-none}" ;;
+        esac
+    fi
     local json_payload
     if command -v jq &>/dev/null; then
         json_payload=$(jq -nc \
@@ -2349,6 +2447,17 @@ function call_ai_api {
                 --argjson rf "$response_format" \
                 '$base + {response_format: $rf}')
         fi
+        if [ -n "$or_reasoning" ]; then
+            json_payload=$(jq -nc \
+                --argjson base "$json_payload" \
+                --arg effort "$or_reasoning" \
+                '$base + {reasoning: {effort: $effort}}')
+        elif [ -n "$oa_reasoning" ]; then
+            json_payload=$(jq -nc \
+                --argjson base "$json_payload" \
+                --arg effort "$oa_reasoning" \
+                '$base + {reasoning_effort: $effort}')
+        fi
     else
         local system_escaped=$(_json_escape_for_payload "$system_prompt")
         local user_escaped=$(_json_escape_for_payload "$user_prompt")
@@ -2361,7 +2470,13 @@ function call_ai_api {
         if [ -n "$include_temperature" ]; then
             temp_field=",\"temperature\":$AI_TEMPERATURE"
         fi
-        json_payload="{\"model\":\"$model_escaped\",\"messages\":[{\"role\":\"system\",\"content\":\"$system_escaped\"},{\"role\":\"user\",\"content\":\"$user_escaped\"}]${temp_field},\"${tokens_field}\":$max_tokens${rf_field}}"
+        local reasoning_field=""
+        if [ -n "$or_reasoning" ]; then
+            reasoning_field=",\"reasoning\":{\"effort\":\"$or_reasoning\"}"
+        elif [ -n "$oa_reasoning" ]; then
+            reasoning_field=",\"reasoning_effort\":\"$oa_reasoning\""
+        fi
+        json_payload="{\"model\":\"$model_escaped\",\"messages\":[{\"role\":\"system\",\"content\":\"$system_escaped\"},{\"role\":\"user\",\"content\":\"$user_escaped\"}]${temp_field},\"${tokens_field}\":$max_tokens${rf_field}${reasoning_field}}"
     fi
     local proxy_url=$(get_ai_proxy)
     local safe_proxy_url=""
@@ -2557,6 +2672,20 @@ function call_ai_api {
         clear_sensitive_vars
         return 1
     fi
+    local finish_reason=""
+    if command -v jq &>/dev/null; then
+        finish_reason=$(echo "$response" | jq -r '.choices[0].finish_reason // empty' 2>/dev/null)
+    else
+        case "$response" in
+            *'"finish_reason":"length"'*|*'"finish_reason": "length"'*) finish_reason="length" ;;
+        esac
+    fi
+    if [ "$finish_reason" = "length" ]; then
+        echo -e "${RED}✗ AI response was cut off by the output-token limit.${ENDCOLOR}" >&2
+        echo -e "${CYAN}💡 The model likely spent the budget on internal reasoning — pick a faster model with ${GREEN}gitb cfg model${ENDCOLOR}${CYAN}, or retry.${ENDCOLOR}" >&2
+        clear_sensitive_vars
+        return 1
+    fi
     clear_sensitive_vars
     echo "$ai_response"
 }
@@ -2766,13 +2895,13 @@ function generate_ai_commit_message {
     local system_prompt user_prompt
     system_prompt=$(build_ai_commit_system_prompt "$mode" "$commit_prefix")
     user_prompt=$(build_ai_commit_user_prompt "$mode" "$detected_scopes" "$provided_scopes" "$rejected_messages")
-    local max_tokens model
+    local max_tokens
     case "$mode" in
-        subject) max_tokens="$AI_MAX_TOKENS_SUBJECT"; model=$(get_ai_model_for subject) ;;
-        full)    max_tokens="$AI_MAX_TOKENS_FULL";    model=$(get_ai_model_for full) ;;
-        *)       max_tokens="$AI_MAX_TOKENS_SIMPLE";  model=$(get_ai_model_for simple) ;;
+        subject) max_tokens="$AI_MAX_TOKENS_SUBJECT" ;;
+        full)    max_tokens="$AI_MAX_TOKENS_FULL" ;;
+        *)       max_tokens="$AI_MAX_TOKENS_SIMPLE" ;;
     esac
-    call_ai_api "$system_prompt" "$user_prompt" "$max_tokens" "$model"
+    call_ai_api "$system_prompt" "$user_prompt" "$max_tokens"
 }
 function clear_sensitive_vars {
     api_key=""
@@ -3053,10 +3182,10 @@ function configure_ai_provider {
     fi
     echo
     echo -e "Options:"
-    echo -e "  1. ${BLUE}openrouter${ENDCOLOR}  Aggregator with hundreds of models — needs an API key"
-    echo -e "  2. ${BLUE}openai${ENDCOLOR}      OpenAI direct (GPT-5 family) — needs an API key"
-    echo -e "  3. ${BLUE}ollama${ENDCOLOR}      Local or remote models (you'll set the host) — no API key required"
-    echo -e "  4. ${BLUE}claude${ENDCOLOR}      Local Claude Code CLI (claude -p) — uses your Claude account, no API key"
+    echo -e "  1. ${BOLD}openrouter${ENDCOLOR}  Aggregator with hundreds of models — needs an API key"
+    echo -e "  2. ${BOLD}openai${ENDCOLOR}      OpenAI direct (GPT-5 family) — needs an API key"
+    echo -e "  3. ${BOLD}ollama${ENDCOLOR}      Local or remote models (you'll set the host) — no API key required"
+    echo -e "  4. ${BOLD}claude${ENDCOLOR}      Local Claude Code CLI (claude -p) — uses your Claude account, no API key"
     echo
     echo -e "Press Enter to keep the current provider, or enter 0 to reset to default (${AI_DEFAULT_PROVIDER})"
     if ! read_editable_input choice "Choice (1-4): "; then
@@ -3089,8 +3218,12 @@ function configure_ai_provider {
             ;;
     esac
     migrate_legacy_ai_api_key_to "$current_provider"
+    migrate_legacy_ai_model_to "$current_provider"
+    local prev_local_provider
+    prev_local_provider=$(git config --local --get gitbasher.ai-provider 2>/dev/null)
     set_ai_provider "$new_provider"
     echo -e "${GREEN}✓ Set AI provider to '${new_provider}' for '${project_name}'${ENDCOLOR}"
+    local local_smoke_failed=""
     case "$new_provider" in
         ollama)
             local current_host
@@ -3115,19 +3248,24 @@ function configure_ai_provider {
             fi
             echo
             echo -e "${CYAN}💡 Make sure the Ollama daemon is running (${BLUE}ollama serve${CYAN}) and a model is pulled (${BLUE}ollama pull qwen3:8b${CYAN}).${ENDCOLOR}"
-            echo -e "${CYAN}💡 Pick a model with ${GREEN}gitb cfg model${CYAN}.${ENDCOLOR}"
+            if [ -z "$_chained" ]; then
+                echo -e "${CYAN}💡 Pick a model with ${GREEN}gitb cfg model${CYAN}.${ENDCOLOR}"
+            fi
             echo
-            ai_smoke_check || true
+            ai_smoke_check || local_smoke_failed="true"
             ;;
         claude)
             echo
             if command -v claude >/dev/null 2>&1; then
-                ai_smoke_check || true
+                ai_smoke_check || local_smoke_failed="true"
             else
                 echo -e "${RED}✗ claude CLI not found on PATH.${ENDCOLOR}"
                 echo -e "${CYAN}💡 Install it with ${BLUE}npm install -g @anthropic-ai/claude-code${CYAN}, then sign in once.${ENDCOLOR}"
+                local_smoke_failed="true"
+            fi
+            if [ -z "$_chained" ]; then
+                echo -e "${CYAN}💡 Pick a model with ${GREEN}gitb cfg model${CYAN} (haiku, sonnet, opus).${ENDCOLOR}"
             fi
-            echo -e "${CYAN}💡 Pick a model with ${GREEN}gitb cfg model${CYAN} (haiku, sonnet, opus).${ENDCOLOR}"
             ;;
         *)
             if [ -n "$(get_ai_api_key)" ]; then
@@ -3137,6 +3275,25 @@ function configure_ai_provider {
             ;;
     esac
     echo
+    if [ -n "$local_smoke_failed" ]; then
+        echo -e "Keep '${new_provider}' as the AI provider anyway (y/N)?"
+        local _keep_rc=0
+        confirm_destructive || _keep_rc=$?
+        if [ "$_keep_rc" -ne 0 ]; then
+            if [ -n "$prev_local_provider" ]; then
+                git config --local gitbasher.ai-provider "$prev_local_provider"
+            else
+                git config --local --unset gitbasher.ai-provider 2>/dev/null || true
+            fi
+            echo -e "${YELLOW}Provider unchanged — still '$(get_ai_provider)'.${ENDCOLOR}"
+            if [ -n "$_chained" ]; then
+                if [ "$_keep_rc" -eq 2 ]; then return 130; fi
+                return 3
+            fi
+            exit 1
+        fi
+        echo
+    fi
     if [ "$GITBASHER_NO_REPO" != "true" ]; then
         echo -e "Do you want to set this provider ${YELLOW}globally${ENDCOLOR} for all projects (Y/n)?"
         local _prov_key=""
@@ -3164,6 +3321,15 @@ function configure_ai_provider {
         fi
     fi
 }
+function _print_model_menu_entry {
+    local _desc=""
+    [ -n "$4" ] && _desc=" ${GRAY}- ${4}${ENDCOLOR}"
+    if [ "$1" = "$3" ]; then
+        echo -e "  ${GREEN}${2}. ${1}${ENDCOLOR}  (current)${_desc}"
+    else
+        echo -e "  ${2}. ${BOLD}${1}${ENDCOLOR}${_desc}"
+    fi
+}
 function configure_ai_model {
     local _chained=""
     [ "$1" = "--chained" ] && _chained="true"
@@ -3171,72 +3337,113 @@ function configure_ai_model {
     echo
     current_model=$(get_ai_model)
     if [ -n "$current_model" ]; then
-        echo -e "Current global override: ${GREEN}$current_model${ENDCOLOR}"
+        echo -e "Current model for provider '${GREEN}$(get_ai_provider)${ENDCOLOR}': ${GREEN}$current_model${ENDCOLOR}"
     else
-        echo -e "No global override set — each task uses its per-task default:"
-        echo -e "  • simple   → ${GREEN}$(get_ai_model_for simple)${ENDCOLOR}"
-        echo -e "  • subject  → ${GREEN}$(get_ai_model_for subject)${ENDCOLOR}"
-        echo -e "  • full     → ${GREEN}$(get_ai_model_for full)${ENDCOLOR}"
-        echo -e "  • grouping → ${GREEN}$(get_ai_model_for grouping)${ENDCOLOR}"
+        echo -e "Provider '${GREEN}$(get_ai_provider)${ENDCOLOR}' uses its default model: ${GREEN}$(get_ai_default_model)${ENDCOLOR}"
     fi
     echo
-    echo -e "Set a single model for all tasks (a global override), or leave empty to keep using the per-task defaults."
-    echo -e "Per-task overrides can be set directly with git config:"
-    echo -e "  ${BLUE}git config gitbasher.ai-model-simple <model_id>${ENDCOLOR}    (and -subject / -full / -grouping)"
-    echo
-    echo -e "Popular models for provider '${GREEN}$(get_ai_provider)${ENDCOLOR}':"
+    local -a model_menu=()
+    local model_catalog=""
+    local _m _i
+    local _resolved_model
+    _resolved_model=$(resolve_ai_model)
     case "$(get_ai_provider)" in
-        openai)
-            echo -e "  • ${BLUE}gpt-5.4-mini${ENDCOLOR} - Default: as fast as nano with better quality (~\$0.75/\$4.50 per M)"
-            echo -e "  • ${BLUE}gpt-5.4-nano${ENDCOLOR} - Budget option for high volume (~\$0.20/\$1.25 per M)"
-            echo -e "  • ${BLUE}gpt-5.5${ENDCOLOR} - Flagship, only worth it for the hardest grouping cases"
-            ;;
         ollama)
-            echo -e "  • ${BLUE}qwen3:8b${ENDCOLOR} - Best small instruction-follower; most stable structured output"
-            echo -e "  • ${BLUE}llama3.3:8b${ENDCOLOR} - Solid general-purpose alternative"
-            echo -e "  • ${BLUE}qwen2.5-coder:7b${ENDCOLOR} - Code-focused; good when most diffs are code"
-            echo -e "  Run ${BLUE}ollama list${ENDCOLOR} to see what you have pulled locally."
+            while IFS= read -r _m; do
+                [ -n "$_m" ] && model_menu+=("$_m")
+            done < <(ollama_list_models)
+            if [ ${#model_menu[@]} -gt 0 ]; then
+                echo -e "Installed models on ${BLUE}$(ollama_api_base)${ENDCOLOR}:"
+                _i=1
+                for _m in "${model_menu[@]}"; do
+                    _print_model_menu_entry "$_m" "$_i" "$_resolved_model"
+                    _i=$((_i + 1))
+                done
+            else
+                echo -e "${YELLOW}No models found on $(ollama_api_base) — is the daemon running?${ENDCOLOR}"
+            fi
             ;;
-        claude)
-            echo -e "  • ${BLUE}haiku${ENDCOLOR} - Fastest and cheapest; ideal for one-line messages"
-            echo -e "  • ${BLUE}sonnet${ENDCOLOR} - Best balance for full-body prose and grouping"
-            echo -e "  • ${BLUE}opus${ENDCOLOR} - Strongest, for the hardest cases"
-            echo -e "  Aliases resolve to the current model generation; full ids (${BLUE}claude-haiku-4-5${ENDCOLOR}) also work."
+        openrouter)
+            model_catalog=$(openrouter_list_models top-weekly 2>/dev/null)
+            if [ -n "$model_catalog" ]; then
+                _i=1
+                echo -e "Most used on OpenRouter this week:"
+                while IFS= read -r _m; do
+                    model_menu+=("$_m")
+                    _print_model_menu_entry "$_m" "$_i" "$_resolved_model"
+                    _i=$((_i + 1))
+                done < <(printf '%s\n' "$model_catalog" | head -8)
+                local _newest
+                _newest=$(openrouter_list_models newest 2>/dev/null | head -5)
+                if [ -n "$_newest" ]; then
+                    echo -e "Newest:"
+                    while IFS= read -r _m; do
+                        [ -z "$_m" ] && continue
+                        case " ${model_menu[*]} " in *" $_m "*) continue ;; esac
+                        model_menu+=("$_m")
+                        _print_model_menu_entry "$_m" "$_i" "$_resolved_model"
+                        _i=$((_i + 1))
+                    done <<< "$_newest"
+                fi
+            fi
             ;;
-        *)
-            echo -e "  • ${BLUE}openrouter/auto${ENDCOLOR} - Auto-select best available model"
-            echo -e "  • ${BLUE}google/gemini-3.1-flash-lite${ENDCOLOR} - Fastest, cheapest (~\$0.25/\$1.50 per M)"
-            echo -e "  • ${BLUE}google/gemini-3.5-flash${ENDCOLOR} - Current flash generation, better body prose"
-            echo -e "  • ${BLUE}anthropic/claude-haiku-4.5${ENDCOLOR} - Strict instruction following"
-            echo -e "  • ${BLUE}anthropic/claude-sonnet-5${ENDCOLOR} - Premium quality for the hardest cases"
+        openai)
+            model_catalog=$(openai_list_models 2>/dev/null)
+            if [ -n "$model_catalog" ]; then
+                echo -e "Newest chat models on your OpenAI account:"
+                _i=1
+                while IFS= read -r _m; do
+                    model_menu+=("$_m")
+                    _print_model_menu_entry "$_m" "$_i" "$_resolved_model"
+                    _i=$((_i + 1))
+                done < <(printf '%s\n' "$model_catalog" \
+                    | LC_ALL=C grep -vE -- '-[0-9]{4}-[0-9]{2}-[0-9]{2}$' | head -12)
+            fi
             ;;
     esac
-    echo
-    local -a ollama_model_list=()
-    if [ "$(get_ai_provider)" = "ollama" ]; then
-        local _m _i
-        while IFS= read -r _m; do
-            [ -n "$_m" ] && ollama_model_list+=("$_m")
-        done < <(ollama_list_models)
-        if [ ${#ollama_model_list[@]} -gt 0 ]; then
-            echo -e "Installed models on ${BLUE}$(ollama_api_base)${ENDCOLOR}:"
-            _i=1
-            for _m in "${ollama_model_list[@]}"; do
-                if [ "$_m" = "$current_model" ]; then
-                    echo -e "  ${GREEN}${_i}. ${_m}${ENDCOLOR}  (current)"
-                else
-                    echo -e "  ${BLUE}${_i}.${ENDCOLOR} ${_m}"
-                fi
-                _i=$((_i + 1))
-            done
-            echo -e "Enter a number to select, or type a model id."
-        else
-            echo -e "${YELLOW}No models found on $(ollama_api_base) — is the daemon running?${ENDCOLOR}"
-            echo -e "Pull one with ${BLUE}ollama pull qwen3:8b${ENDCOLOR}, or type a model id below."
-        fi
-        echo
+    if [ ${#model_menu[@]} -eq 0 ]; then
+        local -a _menu_desc=()
+        case "$(get_ai_provider)" in
+            openai)
+                echo -e "Popular OpenAI models:"
+                model_menu=("gpt-5.4-mini" "gpt-5.4-nano" "gpt-5.5")
+                _menu_desc=("Default: as fast as nano with better quality (~\$0.75/\$4.50 per M)"
+                            "Budget option for high volume (~\$0.20/\$1.25 per M)"
+                            "Flagship, only worth it for the hardest grouping cases")
+                ;;
+            ollama)
+                echo -e "Suggested models (pull first: ${BLUE}ollama pull <id>${ENDCOLOR}):"
+                model_menu=("qwen3:8b" "llama3.3:8b" "qwen2.5-coder:7b")
+                _menu_desc=("Default: best small instruction-follower; most stable structured output"
+                            "Solid general-purpose alternative"
+                            "Code-focused; good when most diffs are code")
+                ;;
+            claude)
+                echo -e "Model aliases (resolve to the current generation; full ids like ${BLUE}claude-haiku-4-5${ENDCOLOR} also work):"
+                model_menu=("haiku" "sonnet" "opus")
+                _menu_desc=("Default: fastest and cheapest"
+                            "Better prose, noticeably slower"
+                            "Strongest, for the hardest cases")
+                ;;
+            *)
+                echo -e "Popular OpenRouter models:"
+                model_menu=("google/gemini-3.5-flash" "google/gemini-3.1-flash-lite" "openrouter/auto" "anthropic/claude-haiku-4.5" "anthropic/claude-sonnet-5")
+                _menu_desc=("Default: current flash generation, fast with good prose"
+                            "Fastest, cheapest (~\$0.25/\$1.50 per M)"
+                            "Auto-select best available model"
+                            "Strict instruction following"
+                            "Premium quality for the hardest cases")
+                ;;
+        esac
+        _i=0
+        for _m in "${model_menu[@]}"; do
+            _print_model_menu_entry "$_m" "$((_i + 1))" "$_resolved_model" "${_menu_desc[$_i]}"
+            _i=$((_i + 1))
+        done
     fi
-    echo -e "Press Enter to exit without changes, or 0 to clear the override (use per-task defaults)"
+    echo -e "Enter a number to select, or type a model id."
+    echo
+    echo -e "Press Enter to keep the current model, or 0 to reset to the default (${GREEN}$(get_ai_default_model)${ENDCOLOR})"
     if ! read_editable_input model_input "Model ID: "; then
         if [ -n "$_chained" ]; then return 130; fi
         exit
@@ -3246,17 +3453,21 @@ function configure_ai_model {
         exit
     fi
     if [ "$model_input" == "0" ]; then
+        git config --unset "gitbasher.ai-model-$(get_ai_provider)" 2>/dev/null
+        git config --global --unset "gitbasher.ai-model-$(get_ai_provider)" 2>/dev/null
         git config --unset gitbasher.ai-model 2>/dev/null
         git config --global --unset gitbasher.ai-model 2>/dev/null
         echo
-        echo -e "${GREEN}✓ Cleared global model override — each task now uses its per-task default${ENDCOLOR}"
+        echo -e "${GREEN}✓ Cleared model override — provider '$(get_ai_provider)' now uses its default ($(get_ai_default_model))${ENDCOLOR}"
         if [ -n "$_chained" ]; then return 0; fi
         exit
     fi
     echo
-    if [ ${#ollama_model_list[@]} -gt 0 ] && [[ "$model_input" =~ ^[0-9]+$ ]]; then
-        if [ "$model_input" -ge 1 ] && [ "$model_input" -le ${#ollama_model_list[@]} ]; then
-            model_input="${ollama_model_list[$((model_input - 1))]}"
+    local picked_from_menu=""
+    if [ ${#model_menu[@]} -gt 0 ] && [[ "$model_input" =~ ^[0-9]+$ ]]; then
+        if [ "$model_input" -ge 1 ] && [ "$model_input" -le ${#model_menu[@]} ]; then
+            model_input="${model_menu[$((model_input - 1))]}"
+            picked_from_menu="true"
         else
             echo -e "${RED}✗ Invalid selection: ${model_input}${ENDCOLOR}" >&2
             if [ -n "$_chained" ]; then return 1; fi
@@ -3269,9 +3480,41 @@ function configure_ai_model {
         if [ -n "$_chained" ]; then return 1; fi
         exit 1
     fi
+    if [ -z "$picked_from_menu" ] && [ -n "$model_catalog" ]; then
+        if ! printf '%s\n' "$model_catalog" | LC_ALL=C grep -qxF "$model_input"; then
+            echo -e "${YELLOW}⚠ '$model_input' is not in $(get_ai_provider)'s current model list.${ENDCOLOR}"
+            echo -e "Save it anyway (y/N)?"
+            if ! confirm_destructive; then
+                echo -e "${YELLOW}Not saved. Pick a number from the list or re-check the id.${ENDCOLOR}"
+                if [ -n "$_chained" ]; then return 1; fi
+                exit 1
+            fi
+        fi
+    fi
+    local prev_model
+    prev_model=$(git config --local --get "gitbasher.ai-model-$(get_ai_provider)" 2>/dev/null)
     set_ai_model "$model_input"
-    echo -e "${GREEN}✓ Set AI model to '$model_input' for '${project_name}'${ENDCOLOR}"
+    echo -e "${GREEN}✓ Set AI model to '$model_input' for provider '$(get_ai_provider)' in '${project_name}'${ENDCOLOR}"
     echo
+    case "$(get_ai_provider)" in
+        openrouter|openai)
+            if ! ai_model_smoke_check; then
+                echo -e "Keep '$model_input' anyway (y/N)?"
+                if ! confirm_destructive; then
+                    if [ -n "$prev_model" ]; then
+                        git config "gitbasher.ai-model-$(get_ai_provider)" "$prev_model"
+                        echo -e "${YELLOW}Restored previous model '${prev_model}'.${ENDCOLOR}"
+                    else
+                        git config --unset "gitbasher.ai-model-$(get_ai_provider)" 2>/dev/null
+                        echo -e "${YELLOW}Removed it — provider '$(get_ai_provider)' uses its default ($(get_ai_default_model)).${ENDCOLOR}"
+                    fi
+                    if [ -n "$_chained" ]; then return 1; fi
+                    exit 1
+                fi
+            fi
+            echo
+            ;;
+    esac
     if [ "$GITBASHER_NO_REPO" = "true" ]; then
         if [ -n "$_chained" ]; then return 0; fi
         exit
@@ -3281,7 +3524,7 @@ function configure_ai_model {
     read_key _model_global || { if [ -n "$_chained" ]; then return 130; fi; _model_global="n"; }
     if is_yes "$_model_global"; then
         echo -e "${YELLOW}Set AI model globally${ENDCOLOR}"
-        set_config_value gitbasher.ai-model "$model_input" "true"
+        set_ai_model "$model_input" "true"
     fi
     return 0
 }
@@ -3292,6 +3535,11 @@ function configure_ai_wizard {
     configure_ai_provider --chained
     _rc=$?
     if [ "$_rc" -eq 130 ]; then prompt_aborted; fi
+    if [ "$_rc" -eq 3 ]; then
+        echo
+        echo -e "${YELLOW}AI setup stopped — nothing changed.${ENDCOLOR}"
+        return 0
+    fi
     echo
     echo -e "${YELLOW}Step 2/3 — API key${ENDCOLOR}"
     echo
@@ -3325,9 +3573,9 @@ function configure_ai_proxy {
     echo -e "Enter proxy URL to route AI requests through (useful for bypassing geo-restrictions)"
     echo -e ""
     echo -e "${BLUE}HTTP proxy formats:${ENDCOLOR}"
-    echo -e "  • ${BLUE}http://proxy.example.com:8080${ENDCOLOR}"
-    echo -e "  • ${BLUE}http://username:password@proxy.example.com:8080${ENDCOLOR}"
-    echo -e "  • ${BLUE}http://[2001:db8::1]:8080${ENDCOLOR} (IPv6)"
+    echo -e "  • ${BOLD}http://proxy.example.com:8080${ENDCOLOR}"
+    echo -e "  • ${BOLD}http://username:password@proxy.example.com:8080${ENDCOLOR}"
+    echo -e "  • ${BOLD}http://[2001:db8::1]:8080${ENDCOLOR} (IPv6)"
     echo -e ""
     echo -e "Press Enter to exit without changes, or 0 to remove the existing proxy"
     read_editable_input ai_proxy_input "Proxy URL: "
@@ -3582,11 +3830,11 @@ function delete_global {
     _delete_global_add "gitbasher.ai-ollama-host" "Ollama host" "$global_ollama_host" "$GREEN"
     local global_base_url=$(git config --global --get gitbasher.ai-base-url)
     _delete_global_add "gitbasher.ai-base-url" "AI base URL" "$global_base_url" "$GREEN"
-    local _task_models
-    _task_models=$(git config --global --get-regexp '^gitbasher\.ai-model-' 2>/dev/null | awk '{print $1}' | tr '\n' '+' | sed 's/+$//')
-    if [ -n "$_task_models" ]; then
-        labels+=("AI per-task models: ${GREEN}configured${ENDCOLOR}")
-        actions+=("${_task_models}|AI per-task models")
+    local _provider_models
+    _provider_models=$(git config --global --get-regexp '^gitbasher\.ai-model-' 2>/dev/null | awk '{print $1}' | tr '\n' '+' | sed 's/+$//')
+    if [ -n "$_provider_models" ]; then
+        labels+=("AI models (per provider): ${GREEN}configured${ENDCOLOR}")
+        actions+=("${_provider_models}|AI models (per provider)")
     fi
     while IFS=$'\t' read -r key_name; do
         [ -z "$key_name" ] && continue
@@ -5348,7 +5596,7 @@ Re-do the grouping. Every input hash MUST appear in EXACTLY ONE \"commits\" arra
     local max_out=$(( commit_count * 120 ))
     [ "$max_out" -lt 2048 ] && max_out=2048
     [ "$max_out" -gt 16384 ] && max_out=16384
-    call_ai_api "$system_prompt" "$user_prompt" "$max_out" "$(get_ai_model_for grouping)" '{"type":"json_object"}'
+    call_ai_api "$system_prompt" "$user_prompt" "$max_out" "" '{"type":"json_object"}' "low"
 }
 function squash_parse_ai_plan {
     local response="$1"
@@ -6724,6 +6972,18 @@ function get_max_split_groups {
     [ "$v" -gt 20 ] && v=20
     printf '%s' "$v"
 }
+function should_attempt_ai_grouping {
+    local scope_count="$1" mode="$2"
+    case "$mode" in
+        always) return 0 ;;
+        never)  return 1 ;;
+    esac
+    case "$scope_count" in
+        ''|*[!0-9]*) return 1 ;;
+    esac
+    [ "$scope_count" -ge 3 ] && return 0
+    return 1
+}
 #
 #
 #
@@ -6870,7 +7130,7 @@ A feature is defined by WHAT the change accomplishes, read from the actual code
 
 Input arrives in XML tags: a list of staged files, the actual diff, a diff summary, recent commit messages (for scope-naming conventions), and folder-derived candidate scope tokens.
 
-Task: assign EVERY staged file to exactly one feature group. Use 1 group only if all changes truly form a single feature; otherwise use 2 to ${max_groups} groups. Never exceed ${max_groups} groups — prefer a broader feature over several tiny ones. Name each group with a short lowercase conventional-commit scope describing the FEATURE, matching the style of <recent_commits>. <heuristic_candidates> are folder-derived hints — use one only if it happens to match a feature's purpose. Use \"misc\" only for unrelated incidental files with no feature (e.g., README, top-level config).
+Task: assign EVERY staged file to exactly one feature group. Use 1 group only if all changes truly form a single feature; otherwise use 2 to ${max_groups} groups. Never exceed ${max_groups} groups — prefer a broader feature over several tiny ones. Name each group with a short lowercase conventional-commit scope describing the FEATURE — the bare scope token only (e.g. \"auth\", never a full prefix like \"feat(auth)\" or a type like \"docs:\"), matching the scope-naming style of <recent_commits>. <heuristic_candidates> are folder-derived hints — use one only if it happens to match a feature's purpose. Use \"misc\" only for unrelated incidental files with no feature (e.g., README, top-level config).
 
 Output format: TSV only. One line per staged file in the form <scope><TAB><file_path>. No header, no prose, no markdown fences, no surrounding quotes. Every file from <staged_files> MUST appear exactly once. The file paths must be byte-identical to those in <staged_files>."
 
@@ -6896,8 +7156,9 @@ ${heuristic_hint}
 
 Read <diff> to decide which files implement the same feature. Output TSV (scope<TAB>file) for every staged file. No prose."
     local ai_response
-    ai_response=$(call_ai_api "$system_prompt" "$user_prompt" "$AI_MAX_TOKENS_FULL" "$(get_ai_model_for grouping)" 2>/dev/null)
+    ai_response=$(call_ai_api "$system_prompt" "$user_prompt" "$AI_MAX_TOKENS_FULL" "" "" "low" 2>/dev/null)
     if [ $? -ne 0 ] || [ -z "$ai_response" ]; then
+        ai_grouping_fail_reason="API error"
         return 1
     fi
     ai_response=$(printf '%s' "$ai_response" | LC_ALL=C sed -e 's/^```[a-zA-Z]*$//' -e 's/^```$//')
@@ -6905,6 +7166,14 @@ Read <diff> to decide which files implement the same feature. Output TSV (scope<
     while IFS= read -r f; do
         [ -n "$f" ] && gset_add staged_set "$f"
     done <<< "$staged_files"
+    gmap_clear folder_scope_of
+    local _fk _ff
+    for _fk in "${split_group_keys[@]}"; do
+        while IFS= read -r _ff; do
+            [ -n "$_ff" ] && gmap_set folder_scope_of "$_ff" "$_fk"
+        done <<< "$(gmap_get split_groups "$_fk")"
+    done
+    gmap_clear assigned_set
     gmap_clear new_groups
     local -a new_keys=()
     local line scope file tab_count
@@ -6916,11 +7185,18 @@ Read <diff> to decide which files implement the same feature. Output TSV (scope<
         [ "$tab_count" -ne 1 ] && continue
         scope="${line%%	*}"
         file="${line#*	}"
+        scope="${scope%:}"
+        local type_scope_re='^[a-zA-Z0-9._/-]+\(([a-zA-Z0-9._/-]+)\)$'
+        if [[ "$scope" =~ $type_scope_re ]]; then
+            scope="${BASH_REMATCH[1]}"
+        fi
         if ! [[ "$scope" =~ ^[a-zA-Z0-9._/-]+$ ]]; then
             continue
         fi
         scope=$(printf '%s' "$scope" | LC_ALL=C tr '[:upper:]' '[:lower:]')
         gset_has staged_set "$file" || continue
+        gset_has assigned_set "$file" && continue
+        gset_add assigned_set "$file"
         if ! gmap_has new_groups "$scope"; then
             new_keys+=("$scope")
             gmap_set new_groups "$scope" "$file"
@@ -6928,15 +7204,44 @@ Read <diff> to decide which files implement the same feature. Output TSV (scope<
             gmap_set new_groups "$scope" "$(gmap_get new_groups "$scope")"$'\n'"$file"
         fi
     done <<< "$ai_response"
-    local total_assigned=0 total_staged
+    local total_assigned=0 total_staged unmatched
     local key
     for key in "${new_keys[@]}"; do
         total_assigned=$((total_assigned + $(printf '%s\n' "$(gmap_get new_groups "$key")" | grep -c .)))
     done
     total_staged=$(printf '%s\n' "$staged_files" | grep -c .)
-    if [ "$total_assigned" -ne "$total_staged" ] || [ ${#new_keys[@]} -lt 1 ]; then
+    if [ ${#new_keys[@]} -lt 1 ] || [ "$total_assigned" -eq 0 ]; then
+        ai_grouping_fail_reason="no usable grouping returned"
+        return 1
+    fi
+    unmatched=$((total_staged - total_assigned))
+    [ "$unmatched" -lt 0 ] && unmatched=0   # dedup should prevent this; be safe
+    if [ "$unmatched" -gt 0 ] && [ $((unmatched * 5)) -gt "$total_staged" ]; then
+        ai_grouping_fail_reason="${unmatched} of ${total_staged} files unassigned"
         return 1
     fi
+    if [ "$unmatched" -gt 0 ]; then
+        local single_group=""
+        [ ${#new_keys[@]} -eq 1 ] && single_group="${new_keys[0]}"
+        local sf leftover_scope
+        while IFS= read -r sf; do
+            [ -z "$sf" ] && continue
+            gset_has assigned_set "$sf" && continue
+            if [ -n "$single_group" ]; then
+                leftover_scope="$single_group"
+            else
+                leftover_scope=$(gmap_get folder_scope_of "$sf")
+                [ -z "$leftover_scope" ] && leftover_scope="misc"
+            fi
+            if ! gmap_has new_groups "$leftover_scope"; then
+                new_keys+=("$leftover_scope")
+                gmap_set new_groups "$leftover_scope" "$sf"
+            else
+                gmap_set new_groups "$leftover_scope" "$(gmap_get new_groups "$leftover_scope")"$'\n'"$sf"
+            fi
+            gset_add assigned_set "$sf"
+        done <<< "$staged_files"
+    fi
     gmap_clear split_groups
     split_group_keys=()
     for key in "${new_keys[@]}"; do
@@ -7353,18 +7658,17 @@ function try_offer_commit_split {
     local ai_grouping
     ai_grouping=$(get_config_value gitbasher.commit-ai-grouping "auto")
     local should_use_ai="false"
-    case "$ai_grouping" in
-        never)  should_use_ai="false" ;;
-        *)      should_use_ai="true" ;;   # auto + always: attempt AI
-    esac
-    if [ -z "$llm" ]; then
-        should_use_ai="false"
+    if [ -n "$llm" ] && should_attempt_ai_grouping "${#split_group_keys[@]}" "$ai_grouping"; then
+        should_use_ai="true"
     fi
     if [ "$should_use_ai" = "true" ] && check_ai_available 2>/dev/null; then
         echo
         echo -e "${YELLOW}Grouping changes by feature with AI...${ENDCOLOR}"
+        local ai_grouping_fail_reason=""
         if ! group_files_by_feature_with_ai; then
-            echo -e "${YELLOW}AI feature grouping failed, falling back to folder-based grouping.${ENDCOLOR}"
+            local reason_suffix=""
+            [ -n "$ai_grouping_fail_reason" ] && reason_suffix=" (${ai_grouping_fail_reason})"
+            echo -e "${YELLOW}AI feature grouping failed${reason_suffix}, using folder-based grouping.${ENDCOLOR}"
         fi
         consolidate_split_groups "$(get_max_split_groups)"
     fi

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "gitbasher",
-    "version": "5.1.0",
+    "version": "5.2.1",
     "description": "Simple bash utility that makes git easy to use",
     "keywords": [
         "git",