loki-mode 8.0.3 → 8.2.0

package/README.md

@@ -15,7 +15,7 @@ _The free, source-available autonomous coding agent by [Autonomi](https://www.au
 
 [Website](https://www.autonomi.dev/) | [Documentation](wiki/Home.md) | [Installation](docs/INSTALLATION.md) | [Changelog](CHANGELOG.md) | [Purple Lab -- deprecated v7.44.0](#purple-lab)
 
-**Current release: v8.0.0**
+**Current release: v8.2.0**
 
 </div>
 
@@ -25,6 +25,37 @@ _The free, source-available autonomous coding agent by [Autonomi](https://www.au
 
 ---
 
+## Already have a codebase? Start read-only.
+
+Most agents are built to create new apps. The harder, more valuable problem is
+the ten-year-old repo that pays the bills. Loki works on both, and on an
+existing codebase it starts by **changing nothing**:
+
+```bash
+loki modernize heal ./your-repo --assess          # read-only. no writes, no commits.
+loki modernize heal ./your-repo --assess --json   # same, machine-readable
+```
+
+You get a modernization readiness report: language mix, a 4-level maturity
+rating, technical-debt signals (test coverage, TODO density, oversized files,
+dependency staleness), and a **ranked list of where to start** -- ordered by
+blast radius, so the first change is the one least likely to break something.
+
+Then, if you want it to act:
+
+```bash
+loki modernize heal ./your-repo --strict          # block ALL behavioral change without approval
+loki modernize heal ./your-repo --phase archaeology   # extract knowledge only
+loki modernize heal ./your-repo --compliance healthcare   # or fintech | government
+```
+
+The healing pipeline runs in phases -- archaeology, stabilize, isolate,
+modernize, validate -- and the validate phase checks **behavioral equivalence
+against the pre-change baseline**, not just that the tests are green. Friction
+points (the weird code that exists for a reason nobody remembers) are cataloged
+before anything touches them, because in a legacy system the strange code is
+usually load-bearing.
+
 ## The Evidence Receipt: don't trust the agent, check it
 
 Every coding agent tells you it finished. Loki hands you something you can
@@ -239,18 +270,31 @@ This needs Bun on your PATH (the SDK loop runs on the Bun runtime). `loki doctor
 
 **With a coding-agent CLI.** The classic path, and still the default: Loki drives a separate CLI (Claude Code is the recommended one) plus a couple of common tools on your PATH.
 
-**With a different model or provider.** Loki is not tied to Anthropic. Anything
-that speaks the Anthropic Messages API works: OpenRouter, Ollama, LiteLLM, vLLM,
-or your own gateway. Point `ANTHROPIC_BASE_URL` at the endpoint and name the
-model with `LOKI_MODEL_OVERRIDE`:
+**With a different model or provider.** Loki is not tied to Anthropic, but
+*how* you reach another model depends on which API the endpoint speaks. There
+are two routes, and picking the wrong one fails confusingly.
+
+*Route 1 -- OpenAI-shaped endpoints (OpenRouter, and most hosted open models).*
+Use a provider that speaks that API natively. `aider` and `cline` both do, and
+Loki now defaults them to open-weight models rather than Claude:
 
 ```bash
-# OpenRouter (hundreds of models, one key)
-export ANTHROPIC_BASE_URL=https://openrouter.ai/api/v1
-export ANTHROPIC_API_KEY=sk-or-...
-export LOKI_MODEL_OVERRIDE=<model-id-from-openrouter.ai/models>
-loki start prd.md
+loki provider set aider
+export OPENROUTER_API_KEY=sk-or-...
+loki start prd.md                          # defaults to deepseek-v3.2
 
+export LOKI_AIDER_MODEL=openrouter/z-ai/glm-4.6   # or pick your own
+```
+
+OpenRouter serves **only** the OpenAI-shaped `/v1/chat/completions`; it has no
+Anthropic `/v1/messages` endpoint. Pointing `ANTHROPIC_BASE_URL` at it does not
+work, which earlier versions of this README incorrectly suggested.
+
+*Route 2 -- Anthropic-protocol gateways.* `ANTHROPIC_BASE_URL` routes Claude
+Code itself, so the endpoint must speak the Anthropic Messages API. LiteLLM,
+Bedrock proxies, and self-hosted gateways can:
+
+```bash
 # Ollama, fully local (no API key, no per-token cost)
 export ANTHROPIC_BASE_URL=http://localhost:11434/v1
 export LOKI_MODEL_OVERRIDE=<model you have pulled, e.g. the output of `ollama list`>

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: Autonomous spec-driven build system with a built-in trust layer. It does not call work done until it is verified (RARV-C closure loop, 8 quality gates, completion council, verified-completion evidence gate). Triggers on "Loki Mode". Takes a spec (PRD, GitHub issue, OpenAPI doc, etc.) to deployed product with minimal human intervention. Provider-agnostic. Requires --dangerously-skip-permissions flag.
 ---
 
-# Loki Mode v8.0.3
+# Loki Mode v8.2.0
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -469,4 +469,4 @@ See `CHANGELOG.md` entries [7.5.7], [7.5.8], [7.5.13] for the per-fix list and r
 
 ---
 
-**v8.0.3 | [Autonomi](https://www.autonomi.dev/) flagship product | ~410 lines core**
+**v8.2.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~410 lines core**

package/VERSION

@@ -1 +1 @@
-8.0.3
+8.2.0

package/autonomy/completion-council.sh

@@ -2267,11 +2267,17 @@ PYEOF
         if [ -z "$_nm_cc_dir" ] || [ ! -f "$_nm_scanner" ]; then
             _nm_status="INCONCLUSIVE:scanner_unavailable"
         else
+            # STDIN, not an env var: a single env string is capped at
+            # MAX_ARG_STRLEN (131071 bytes) on Linux, so a large changed-file
+            # union makes execve fail with E2BIG and this gate silently
+            # degrades to inconclusive (pass-through). macOS has no per-string
+            # cap, so that failure mode was Linux-only.
             _nm_status=$(
-                _NM_FILES="$_nm_files" \
-                _NM_TREE="." \
-                python3 -I "$_nm_scanner" 2>/dev/null \
-                    || echo "INCONCLUSIVE:detector_error"
+                printf '%s\n' "$_nm_files" | {
+                    _NM_TREE="." \
+                    python3 -I "$_nm_scanner" 2>/dev/null \
+                        || echo "INCONCLUSIVE:detector_error"
+                }
             )
         fi
         case "$_nm_status" in
@@ -3135,6 +3141,25 @@ ISSUES: CRITICAL:description (optional, one per line per issue)"
                 _provider_rc=$?
             fi
             ;;
+        *)
+            # v8.2.0 TIMEOUT SEAM. Any provider exposing provider_invoke_argv can
+            # cast a real council vote instead of falling straight to the
+            # heuristic. argv is a REAL command, so `timeout` bounds it exactly as
+            # it bounds the named arms above (providers/claude.sh:321).
+            #
+            # SEMANTICS PRESERVED: _provider_rc is captured the same way, so the
+            # bash-F4 safe default below still forces a conservative REJECT on a
+            # timeout kill (124/137/143). An empty verdict falls to
+            # council_heuristic_review, identical to a missing CLI today.
+            if type provider_invoke_argv >/dev/null 2>&1; then
+                provider_invoke_argv fast "$prompt"
+                # caveman HARD-SUPPRESS: this vote is parsed for "VOTE:".
+                verdict=$(timeout "${LOKI_COUNCIL_REVIEW_TIMEOUT:-600}" \
+                    env CAVEMAN_DEFAULT_MODE=off \
+                    "${_LOKI_INVOKE_ARGV[@]+"${_LOKI_INVOKE_ARGV[@]}"}" 2>/dev/null)
+                _provider_rc=$?
+            fi
+            ;;
     esac
 
     # bash-F4 (WAVE10 SAFE-DEFAULT): a provider timeout (124, incl. 128+SIGTERM
@@ -3303,6 +3328,22 @@ REASON: your reasoning"
                 verdict=$(timeout "${LOKI_COUNCIL_REVIEW_TIMEOUT:-600}" aider --message "$prompt" --yes-always --no-auto-commits --no-git 2>/dev/null)
             fi
             ;;
+        *)
+            # v8.2.0 TIMEOUT SEAM (contrarian / devil's-advocate vote). Same
+            # rationale as the member vote: a real argv keeps the `timeout`
+            # bound that a shell function would silently remove.
+            #
+            # SEMANTICS PRESERVED: this path tracks no _provider_rc by design --
+            # an empty verdict (timeout or failure) already routes to the
+            # conservative REJECT fallback immediately below.
+            if type provider_invoke_argv >/dev/null 2>&1; then
+                provider_invoke_argv fast "$prompt"
+                # caveman HARD-SUPPRESS: parsed for "VOTE:".
+                verdict=$(timeout "${LOKI_COUNCIL_REVIEW_TIMEOUT:-600}" \
+                    env CAVEMAN_DEFAULT_MODE=off \
+                    "${_LOKI_INVOKE_ARGV[@]+"${_LOKI_INVOKE_ARGV[@]}"}" 2>/dev/null)
+            fi
+            ;;
     esac
 
     if [ -z "$verdict" ]; then

package/autonomy/council-v2.sh

@@ -82,6 +82,9 @@ council_v2_vote() {
     local first=true
     local approve_count=0
     local reject_count=0
+    # Reviewers we could not obtain a verdict from. Never folded into
+    # reject_count -- see the TRUST comment in the tally below.
+    local inconclusive_count=0
     for vote_file in "${vote_files[@]}"; do
         if [ -f "$vote_file" ]; then
             local vote_content
@@ -95,16 +98,40 @@ council_v2_vote() {
 
             local verdict
             verdict=$(echo "$vote_content" | python3 -c "import sys,json; print(json.load(sys.stdin).get('verdict','').upper())" 2>/dev/null || echo "UNKNOWN")
+            # TRUST: a reviewer that could not be REACHED did not vote REJECT.
+            #
+            # Every provider arm below used to substitute a literal
+            # {"verdict":"REJECT","reasoning":"review execution failed"} on any
+            # miss -- CLI absent, timeout, transient error, unparseable output --
+            # and this tally counted "anything not APPROVE" as a rejection. The
+            # engine therefore fabricated a reviewer vote the model never gave,
+            # and the run was BLOCKED by it.
+            #
+            # That is the same defect class as a receipt attesting to a diff stat
+            # it did not measure: the artifact claims a fact nobody established.
+            # On a weak model that formats poorly it is worse still -- low format
+            # compliance becomes a permanent BLOCK that reads to the user as
+            # "Loki is broken" rather than "your model could not answer".
+            #
+            # INCONCLUSIVE is counted separately and never as a rejection.
             if [ "$verdict" = "APPROVE" ]; then
                 ((approve_count++))
-            else
+            elif [ "$verdict" = "REJECT" ]; then
                 ((reject_count++))
+            else
+                ((inconclusive_count++))
             fi
         fi
     done
     votes_json="$votes_json]"
 
-    log_info "Blind review results: $approve_count APPROVE / $reject_count REJECT"
+    if [ "$inconclusive_count" -gt 0 ]; then
+        log_warn "Blind review results: $approve_count APPROVE / $reject_count REJECT / $inconclusive_count INCONCLUSIVE"
+        log_warn "  $inconclusive_count reviewer(s) produced no verdict (CLI missing, timeout, or unparseable output)."
+        log_warn "  These are NOT rejections. The council decides on the verdicts it actually obtained."
+    else
+        log_info "Blind review results: $approve_count APPROVE / $reject_count REJECT"
+    fi
 
     # Step 4: Sycophancy detection
     local sycophancy_score
@@ -137,8 +164,13 @@ print('{:.3f}'.format(detect_sycophancy(votes)))
 
             if [ -f "$da_vote" ]; then
                 local da_verdict
-                da_verdict=$(cat "$da_vote" | python3 -c "import sys,json; print(json.load(sys.stdin).get('verdict','').upper())" 2>/dev/null || echo "REJECT")
-                if [ "$da_verdict" = "REJECT" ]; then
+                # Same trust rule as the main tally: an unparseable devil's
+                # advocate did not vote REJECT. Defaulting to REJECT here would
+                # silently overturn a unanimous APPROVE on a transient failure.
+                da_verdict=$(cat "$da_vote" | python3 -c "import sys,json; print(json.load(sys.stdin).get('verdict','').upper())" 2>/dev/null || echo "INCONCLUSIVE")
+                if [ "$da_verdict" = "INCONCLUSIVE" ]; then
+                    log_warn "Devil's advocate produced no verdict -- unanimous approval left UNCHANGED (not overturned)"
+                elif [ "$da_verdict" = "REJECT" ]; then
                     log_warn "Devil's advocate REJECTED unanimous approval"
                     approve_count=$((approve_count - 1))
                     reject_count=$((reject_count + 1))
@@ -374,42 +406,64 @@ except Exception:
                 fi
                 # Fall through to the plain text call (+ sed-carve) on any miss.
                 if [ -z "$result" ]; then
-                    result=$(echo "$full_prompt" | CAVEMAN_DEFAULT_MODE=off claude "${_c2_argv[@]}" -p 2>/dev/null || echo '{"verdict":"REJECT","reasoning":"review execution failed","issues":[]}')
+                    result=$(echo "$full_prompt" | CAVEMAN_DEFAULT_MODE=off claude "${_c2_argv[@]}" -p 2>/dev/null || echo '{"verdict":"INCONCLUSIVE","reasoning":"review execution failed (no verdict obtained; NOT a rejection)","issues":[]}')
                 fi
             else
-                result='{"verdict":"REJECT","reasoning":"reviewer CLI unavailable","issues":[]}'
+                result='{"verdict":"INCONCLUSIVE","reasoning":"reviewer CLI unavailable (no verdict obtained; NOT a rejection)","issues":[]}'
             fi
             ;;
         codex)
             if command -v codex &>/dev/null; then
-                result=$(codex exec -q "$full_prompt" 2>/dev/null || echo '{"verdict":"REJECT","reasoning":"review execution failed","issues":[]}')
+                result=$(codex exec -q "$full_prompt" 2>/dev/null || echo '{"verdict":"INCONCLUSIVE","reasoning":"review execution failed (no verdict obtained; NOT a rejection)","issues":[]}')
             else
-                result='{"verdict":"REJECT","reasoning":"reviewer CLI unavailable","issues":[]}'
+                result='{"verdict":"INCONCLUSIVE","reasoning":"reviewer CLI unavailable (no verdict obtained; NOT a rejection)","issues":[]}'
             fi
             ;;
         gemini)
             if command -v gemini &>/dev/null; then
-                result=$(echo "$full_prompt" | gemini 2>/dev/null || echo '{"verdict":"REJECT","reasoning":"review execution failed","issues":[]}')
+                result=$(echo "$full_prompt" | gemini 2>/dev/null || echo '{"verdict":"INCONCLUSIVE","reasoning":"review execution failed (no verdict obtained; NOT a rejection)","issues":[]}')
             else
-                result='{"verdict":"REJECT","reasoning":"reviewer CLI unavailable","issues":[]}'
+                result='{"verdict":"INCONCLUSIVE","reasoning":"reviewer CLI unavailable (no verdict obtained; NOT a rejection)","issues":[]}'
             fi
             ;;
         cline)
             if command -v cline &>/dev/null; then
-                result=$(cline -y "$full_prompt" 2>/dev/null || echo '{"verdict":"REJECT","reasoning":"review execution failed","issues":[]}')
+                result=$(cline -y "$full_prompt" 2>/dev/null || echo '{"verdict":"INCONCLUSIVE","reasoning":"review execution failed (no verdict obtained; NOT a rejection)","issues":[]}')
             else
-                result='{"verdict":"REJECT","reasoning":"reviewer CLI unavailable","issues":[]}'
+                result='{"verdict":"INCONCLUSIVE","reasoning":"reviewer CLI unavailable (no verdict obtained; NOT a rejection)","issues":[]}'
             fi
             ;;
         aider)
             if command -v aider &>/dev/null; then
-                result=$(aider --message "$full_prompt" --yes-always --no-auto-commits --no-git 2>/dev/null || echo '{"verdict":"REJECT","reasoning":"review execution failed","issues":[]}')
+                result=$(aider --message "$full_prompt" --yes-always --no-auto-commits --no-git 2>/dev/null || echo '{"verdict":"INCONCLUSIVE","reasoning":"review execution failed (no verdict obtained; NOT a rejection)","issues":[]}')
             else
-                result='{"verdict":"REJECT","reasoning":"reviewer CLI unavailable","issues":[]}'
+                result='{"verdict":"INCONCLUSIVE","reasoning":"reviewer CLI unavailable (no verdict obtained; NOT a rejection)","issues":[]}'
             fi
             ;;
         *)
-            result='{"verdict":"REJECT","reasoning":"review not supported for this provider","issues":[]}'
+            # v8.2.0 TIMEOUT SEAM. A provider exposing provider_invoke_argv gets
+            # a real reviewer instead of an automatic INCONCLUSIVE. The argv is a
+            # REAL command so `timeout` genuinely bounds it (providers/claude.sh:321);
+            # routing this through a shell function would silently drop the bound.
+            #
+            # VERDICT SEMANTICS UNCHANGED: on empty output, non-zero exit, or a
+            # timeout kill (124/137/143) we fall back to the SAME INCONCLUSIVE
+            # string used below -- never REJECT. A judge that produced no
+            # judgement has not rejected anything (v8.1.0 TRUST-3).
+            result=''
+            if type provider_invoke_argv >/dev/null 2>&1; then
+                local _c2_seam_rc=0
+                provider_invoke_argv fast "$full_prompt"
+                # caveman HARD-SUPPRESS: this verdict is parsed for the JSON
+                # "verdict" field; compression would reword it.
+                result="$(timeout "${LOKI_SDK_REVIEW_TIMEOUT:-180}" \
+                    env CAVEMAN_DEFAULT_MODE=off \
+                    "${_LOKI_INVOKE_ARGV[@]+"${_LOKI_INVOKE_ARGV[@]}"}" 2>/dev/null)" || _c2_seam_rc=$?
+                [ "$_c2_seam_rc" -ne 0 ] && result=''
+            fi
+            if [ -z "$result" ]; then
+                result='{"verdict":"INCONCLUSIVE","reasoning":"review not supported for this provider (no verdict obtained; NOT a rejection)","issues":[]}'
+            fi
             ;;
     esac
 
@@ -420,8 +474,52 @@ except Exception:
         # Try removing markdown fencing
         extracted=$(echo "$result" | sed 's/^```json//;s/^```//' | sed -n '/^{/,/^}/p' | head -50)
     fi
+    # STRUCTURE-TOLERANT RECOVERY (v8.2.0).
+    #
+    # A strict JSON carve is the single most model-sensitive contract in the
+    # engine: schema adherence is exactly what varies most across models, while
+    # every coding model can state a verdict in prose. Measured elsewhere (Forge
+    # replication): scaffolding drove tool-call errors 42 -> 0 while
+    # advanced-reasoning accuracy stayed flat -- i.e. a harness CAN rescue
+    # format compliance but cannot manufacture judgment. So recovering a verdict
+    # the model genuinely expressed is legitimate; inventing one is not.
+    #
+    # This runs ONLY when the JSON carve produced nothing, and it accepts a
+    # verdict only when the model stated it UNAMBIGUOUSLY (exactly one of
+    # APPROVE/REJECT appears as a standalone word). A response mentioning both,
+    # or neither, stays INCONCLUSIVE -- never guessed.
+    if [ -z "$extracted" ] && [ -n "${result:-}" ]; then
+        local _recovered
+        _recovered="$(printf '%s' "$result" | _LOKI_RAW="$result" python3 -c '
+import os, re, sys, json
+raw = os.environ.get("_LOKI_RAW", "")
+# Standalone words only: "APPROVE" not "approved-by", and not inside a URL.
+approve = len(re.findall(r"(?<![A-Za-z0-9_-])APPROVE(?![A-Za-z0-9_-])", raw, re.I))
+reject  = len(re.findall(r"(?<![A-Za-z0-9_-])REJECT(?![A-Za-z0-9_-])",  raw, re.I))
+if approve and not reject:
+    v = "APPROVE"
+elif reject and not approve:
+    v = "REJECT"
+else:
+    sys.exit(1)   # ambiguous or absent -> stay inconclusive
+print(json.dumps({
+    "verdict": v,
+    "reasoning": "recovered from unstructured output (model stated %s in prose)" % v,
+    "issues": [],
+    "recovered": True,
+}))
+' 2>/dev/null)" || _recovered=""
+        if [ -n "$_recovered" ]; then
+            extracted="$_recovered"
+        fi
+    fi
+
     if [ -z "$extracted" ]; then
-        extracted='{"verdict":"REJECT","reasoning":"failed to parse review output","issues":[]}'
+        # The weak-model case, and the reason this matters most: a model whose
+        # prose could not be carved into JSON did not vote REJECT. Recording one
+        # here would turn "your model formats poorly" into "your code was
+        # rejected" -- a block the user cannot act on and did not earn.
+        extracted='{"verdict":"INCONCLUSIVE","reasoning":"failed to parse review output (no verdict obtained; NOT a rejection)","issues":[]}'
     fi
 
     echo "$extracted" > "$output_file"

package/autonomy/grill.sh

@@ -158,6 +158,12 @@ grill_check_provider() {
             fi
             ;;
         *)
+            # v8.2.0: capability, not identity. Must stay in lockstep with the
+            # matching arm in grill_invoke_provider -- this gate runs FIRST, so
+            # rejecting here would make that arm dead code.
+            if type provider_invoke_argv >/dev/null 2>&1; then
+                return 0
+            fi
             _grill_err "grill currently supports the claude and codex providers (got: $provider)"
             return $GRILL_EXIT_ERROR
             ;;
@@ -278,6 +284,32 @@ grill_invoke_provider() {
             return 0
             ;;
         *)
+            # v8.2.0 TIMEOUT SEAM. Previously any other provider was a hard
+            # error. A provider exposing provider_invoke_argv builds a REAL argv
+            # (not a shell function), so _grill_with_timeout still bounds it --
+            # the whole reason the seam exists (providers/claude.sh:321).
+            # Nothing to preserve on this arm, so nothing can regress: it
+            # produced no output at all before.
+            #
+            # Deliberate: no --disallowedTools. That flag is claude-specific with
+            # no portable equivalent, so a seam-provider grill CAN write to the
+            # tree. Accepted; the alternative is the hard error below.
+            if type provider_invoke_argv >/dev/null 2>&1; then
+                local out
+                provider_invoke_argv fast "$prompt"
+                # env CAVEMAN_DEFAULT_MODE=off: grill output is parsed downstream
+                # and caveman compression would reword the questions. `env` (not a
+                # bare prefix) because _grill_with_timeout execs its first token.
+                out="$(_grill_with_timeout "${LOKI_GRILL_TIMEOUT:-180}" \
+                    env CAVEMAN_DEFAULT_MODE=off \
+                    "${_LOKI_INVOKE_ARGV[@]+"${_LOKI_INVOKE_ARGV[@]}"}" 2>/dev/null)"
+                if [ -z "$out" ]; then
+                    _grill_err "provider returned no output (timeout or invocation error)"
+                    return $GRILL_EXIT_ERROR
+                fi
+                printf '%s\n' "$out"
+                return 0
+            fi
             _grill_err "grill currently supports the claude and codex providers (got: $provider)"
             return $GRILL_EXIT_ERROR
             ;;

package/autonomy/lib/done-recognition.sh

@@ -159,12 +159,24 @@ except Exception:
     return 0
 }
 
-# Decide whether model verification can be attempted. Returns 0 (ok) only when
-# the active provider is claude and not degraded. Mirrors
-# _loki_prd_enrich_provider_ok (autonomy/lib/prd-enrich.sh:65).
+# Decide whether model verification can be attempted.
+#
+# v8.2.0: this used to require LOKI_PROVIDER=claude specifically, so a user on
+# codex/opencode/cline/aider silently lost done-recognition. That is a
+# CAPABILITY question, not an identity question -- the real requirement is "can
+# we reach a model AND bound the call with a timeout". Any provider exposing the
+# argv seam (provider_invoke_argv, see providers/claude.sh) satisfies both.
+#
+# Falls back to the historical claude-binary check when the seam is absent, so
+# nothing regresses for existing installs.
 _loki_done_recog_provider_ok() {
-    [ "${LOKI_PROVIDER:-claude}" = "claude" ] || return 1
     [ "${PROVIDER_DEGRADED:-false}" != "true" ] || return 1
+    # Preferred: a provider that can build a timeout-able argv.
+    if type provider_invoke_argv >/dev/null 2>&1; then
+        return 0
+    fi
+    # Legacy path: claude binary present.
+    [ "${LOKI_PROVIDER:-claude}" = "claude" ] || return 1
     command -v claude >/dev/null 2>&1 || return 1
     return 0
 }