loki-mode 7.129.5 → 8.0.0

package/loki-ts/package.json

@@ -21,6 +21,8 @@
     "typescript": "^5.6.0"
   },
   "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "0.3.208",
+    "@anthropic-ai/sdk": "^0.111.0",
     "@resvg/resvg-wasm": "^2.6.2"
   },
   "optionalDependencies": {

package/mcp/__init__.py

@@ -57,4 +57,4 @@ try:
 except ImportError:
     __all__ = ['mcp']
 
-__version__ = '7.129.5'
+__version__ = '8.0.0'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "loki-mode",
   "mcpName": "io.github.asklokesh/loki-mode",
-  "version": "7.129.5",
+  "version": "8.0.0",
   "description": "Loki Mode by Autonomi. Autonomous spec-to-product system: takes a PRD, GitHub issue, OpenAPI/JSON/YAML, or one-line brief to a deployed app via the RARV-C closure loop with 8 quality gates. Provider-agnostic (Claude Code, OpenAI Codex, Cline, Aider).",
   "keywords": [
     "agent",
@@ -126,10 +126,11 @@
     "linux"
   ],
   "optionalDependencies": {
-    "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/sdk-trace-node": "^1.30.0",
-    "@opentelemetry/sdk-trace-base": "^1.30.0",
-    "@opentelemetry/exporter-trace-otlp-http": "^0.57.0"
+    "@anthropic-ai/claude-agent-sdk": "0.3.208",
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.221.0",
+    "@opentelemetry/sdk-trace-base": "^2.10.0",
+    "@opentelemetry/sdk-trace-node": "^2.10.0"
   },
   "overrides": {
     "protobufjs": ">=8.4.2"
@@ -143,4 +144,4 @@
   "dependencies": {
     "@resvg/resvg-wasm": "^2.6.2"
   }
-}
+}

package/plugins/loki-mode/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "loki-mode",
   "displayName": "Loki Mode",
-  "version": "7.129.5",
+  "version": "8.0.0",
   "description": "Autonomous spec-to-product build system with a built-in trust layer (RARV-C closure loop, 8 quality gates, completion council). Ships Loki's spec-hardening, drift-detection, and deterministic PR verification commands plus the Loki MCP server.",
   "author": {
     "name": "Autonomi",

package/providers/claude.sh

@@ -281,6 +281,28 @@ Commit hygiene still applies: git checkpoints are LOCAL only. Never push or forc
 
 This precedence override is narrow. It does NOT relax any safety rule. Every safety prohibition in CLAUDE.md or memory still fully binds: anything genuinely destructive or irreversible remains out of scope unless the task explicitly calls for it. This includes (not limited to) force-pushing, deleting or overwriting the user's data, dropping or truncating databases, publishing or releasing, rotating or exfiltrating secrets, touching production systems, and anything a CLAUDE.md safety rule explicitly forbids. When in doubt about whether an action is destructive, treat it as destructive and do not do it.
 LOKI_AUTONOMY_EOF
+
+    # First-pass excellence directive (v8): front-load intelligence into
+    # iteration 1 so a single informed pass lands the COMPLETE, working solution
+    # instead of a rough draft the loop then spends iterations correcting. This
+    # is the mechanism behind "a cheap model in one pass matches a strong model":
+    # the iteration count is a proxy for how much the first pass missed, so a
+    # more directive first prompt is the lever, not more loops. Iteration-1-only
+    # (ITERATION_COUNT<=1) and gated on LOKI_FIRST_PASS_EXCELLENCE (default ON;
+    # set to 0 to disable). Grounded in the user-research directives: nail the
+    # first working preview, WIRE the backend (a form that does nothing is the #1
+    # churn), do not defer/stub, escape the AI-slop defaults.
+    if [ "${LOKI_FIRST_PASS_EXCELLENCE:-1}" != "0" ] && [ "${ITERATION_COUNT:-1}" -le 1 ] 2>/dev/null; then
+        cat <<'LOKI_FIRSTPASS_EOF'
+
+[FIRST-PASS EXCELLENCE] Treat THIS pass as your one shot to ship a complete, working, verified solution. Do not produce a rough draft to refine later; the loop exists as a safety net, not a plan. Before you finish this iteration:
+1. BUILD IT FULLY. Implement every requirement end to end. No stubs, no TODOs, no "coming soon", no placeholder or hardcoded/mock data where real logic belongs. If the spec implies a backend (auth, persistence, a form that submits, a list that saves), WIRE IT so it actually works and persists -- a beautiful UI whose buttons do nothing is the single most common failure, not a draft. Every list/table must trace to a real query, never an inline mock array.
+2. SELF-VERIFY BY RUNNING, not by reading. Run the build and the tests yourself; for each acceptance criterion, DRIVE the actual path and observe the result (submit the form, then reload and confirm the record persisted; hit a protected route logged-out and confirm it is rejected). Fix what fails now, in this pass. Do not mark done on "looks right" or a self-claim -- observed behavior is the only proof.
+3. LOCK THE ARCHITECTURE on this pass so later edits are small and additive. Decide the data model, routes, and component structure up front and build to them; never rewrite whole files later to patch a small thing (that is the doom loop that breaks working features).
+4. DESIGN: commit to ONE named aesthetic direction up front (editorial, brutalist, luxury, retro-futuristic, soft/pastel, industrial, etc. -- chosen from the product domain) and hold it on every surface. Use real content (never lorem). AVOID the AI-slop tells that instantly read as machine-generated: NO indigo/blue-to-purple gradient (the #1 tell), NO Inter/Roboto/system-font headlines (pick a real display+body pairing), NO three-equal-rounded-cards-in-a-row skeleton, NO flat 1px gray card borders or colored left-border strips, NO untouched shadcn defaults, NO reflexive dark mode. Cap the palette at ~3 hues (60/30/10), tinted not pure #fff/#000, separate sections by whitespace then a slight background shift before any border. Aim for Linear/Stripe/Duolingo-tier taste: "this does not look AI-generated".
+Deliver the finished, self-verified, genuinely-designed result in THIS pass. Additional iterations should be the exception, not the plan.
+LOKI_FIRSTPASS_EOF
+    fi
 }
 
 # Invocation function (basic, no tier).
@@ -380,6 +402,54 @@ loki_apply_max_tier_clamp() {
     printf '%s' "$model"
 }
 
+# Complexity-aware MODEL routing (net-new; effort routing already exists in
+# loki_effort_for_tier). ENV VAR: LOKI_TIER_ROUTING (DEFAULT "0" = OFF = current
+# flat resolution, zero change to stock runs). When LOKI_TIER_ROUTING=1 the
+# resolved model is nudged by the auto-detected project complexity signal
+# (LOKI_COMPLEXITY: simple|standard|complex):
+#   complex + planning -> opus  (deeper reasoning for hard architecture)
+#   simple  + fast     -> haiku ONLY when LOKI_ALLOW_HAIKU=true (support gate);
+#                         else stay put (never route to an unavailable model)
+#   standard, or the development/ACT tier -> UNCHANGED.
+# HARD GUARD: the development/ACT tier is NEVER routed below sonnet regardless of
+# complexity (implementation stays >= sonnet). "explicit override wins": we skip
+# the nudge whenever the operator pinned that tier via LOKI_CLAUDE_MODEL_PLANNING
+# / LOKI_MODEL_PLANNING (or the _FAST pair), so a deliberate pin is never
+# overridden. Byte-mirrored by loki_tier_route_model in loki-ts claude_flags.ts.
+loki_tier_route_model() {
+    local tier="$1"
+    local model="$2"
+    # Default OFF: only the explicit "1" opt-in engages routing.
+    [ "${LOKI_TIER_ROUTING:-0}" = "1" ] || { printf '%s' "$model"; return; }
+    local complexity="${LOKI_COMPLEXITY:-standard}"
+    case "$tier" in
+        planning)
+            # Bump to opus for complex work, but only when the operator did NOT
+            # pin planning explicitly (an explicit override always wins, even if
+            # they pinned it back to the flat default).
+            if [ "$complexity" = "complex" ] \
+               && [ -z "${LOKI_CLAUDE_MODEL_PLANNING:-}" ] \
+               && [ -z "${LOKI_MODEL_PLANNING:-}" ]; then
+                model="opus"
+            fi
+            ;;
+        fast)
+            # Drop to haiku for trivial verify work, gated on haiku availability
+            # and on the operator not having pinned fast explicitly.
+            if [ "$complexity" = "simple" ] \
+               && [ "${LOKI_ALLOW_HAIKU:-false}" = "true" ] \
+               && [ -z "${LOKI_CLAUDE_MODEL_FAST:-}" ] \
+               && [ -z "${LOKI_MODEL_FAST:-}" ]; then
+                model="haiku"
+            fi
+            ;;
+        # development/ACT and every other tier: unchanged. HARD GUARD -- never
+        # route implementation below sonnet, so this arm deliberately does nothing.
+        *) ;;
+    esac
+    printf '%s' "$model"
+}
+
 # Dynamic model resolution (v6.0.0)
 # Resolves a capability tier to a concrete model name at runtime.
 # Respects LOKI_MAX_TIER to cap cost via loki_apply_max_tier_clamp. NOTE the
@@ -432,6 +502,11 @@ resolve_model_for_tier() {
     # `fable)` arm above. Keeping the decision in run.sh is the only place that
     # has ITERATION_COUNT, so the scoping is honest.
 
+    # Complexity-aware MODEL routing (opt-in). Applied AFTER base resolution and
+    # BEFORE the max-tier clamp, so the ceiling still bounds any bump-up. Byte-
+    # mirrored by loki_tier_route_model in loki-ts claude_flags.ts.
+    model="$(loki_tier_route_model "$tier" "$model")"
+
     # Apply the shared LOKI_MAX_TIER ceiling (same clamp the run.sh override path
     # uses, so the cost ceiling is enforced byte-identically on both paths).
     model="$(loki_apply_max_tier_clamp "$model" "$tier")"

package/providers/codex.sh

@@ -45,16 +45,66 @@ PROVIDER_SKILL_DIR="${HOME}/.agents/skills"
 PROVIDER_SKILL_FORMAT="markdown"  # Codex v0.98+ loads skills from ~/.agents/skills
 
 # Capability Flags
+#
+# SUBAGENTS / TASK_TOOL stay false: Codex has no equivalent of Claude Code's
+# in-session subagent dispatch. These two are reporting-only in this codebase
+# (loader.sh display + the degraded-mode summary); nothing branches on them.
 PROVIDER_HAS_SUBAGENTS=false
-PROVIDER_HAS_PARALLEL=false
 PROVIDER_HAS_TASK_TOOL=false
 PROVIDER_HAS_MCP=true
-PROVIDER_MAX_PARALLEL=1
+#
+# PARALLEL: enabled 2026-07-27 after MEASURING it, not assuming it.
+#
+# The v0.98-era `false` was an untested assumption. On codex-cli 0.144.6 two
+# concurrent `codex exec` runs in separate git worktrees both completed, exit 0,
+# zero rate-limit errors. This flag gates exactly one behavior -- worktree
+# parallel sessions (run.sh:4832 spawn guard, run.sh:23473 mode downgrade) --
+# and that primitive is only "run the non-interactive CLI in N directories at
+# once". It needs no subagents and no Task tool, which is why those two stay
+# false above while this one does not.
+#
+# Enabling it required making the user-facing text honest first, because
+# "degraded" was being reported as if it always implied "sequential":
+# run.sh:23461 now enumerates the capabilities actually missing (read from
+# these flags) instead of hardcoding "Parallel agents and Task tool", and the
+# live-output banner only claims "Sequential execution only" when
+# PROVIDER_HAS_PARALLEL is genuinely false. PROVIDER_DEGRADED itself is
+# deliberately UNTOUCHED: its other consumers (run.sh:20340 workflow analysis,
+# done-recognition.sh:167) are claude-only guards and one is parity-locked with
+# the Bun route, so widening its meaning would ripple into prompt construction
+# for no gain here.
+#
+# MAX_PARALLEL is 2, not the Claude value. Two is what was actually verified,
+# and Codex's free ChatGPT tier -- the audience this matters for, since Codex is
+# the only zero-cost on-ramp in the category -- is rate-limited well before
+# process concurrency becomes the ceiling. Raise it only with evidence at the
+# higher number.
+PROVIDER_HAS_PARALLEL=true
+PROVIDER_MAX_PARALLEL=2
 
 # Model Configuration
-# Codex uses single model with effort parameter
-# NOTE: gpt-5.3-codex is the official model name for Codex CLI v0.98+
-CODEX_DEFAULT_MODEL="gpt-5.3-codex"
+# Codex uses a single model with an effort parameter.
+#
+# DEFAULT IS EMPTY ON PURPOSE (2026-07-26). Pinning a model name here broke
+# Codex outright for ChatGPT-account users -- the account tier that matters
+# most, since Codex ships free with every ChatGPT plan and is the only
+# zero-cost on-ramp in the category. Verified against codex-cli 0.144.6:
+#
+#   codex exec --model gpt-5.3-codex "..."
+#     -> 400 invalid_request_error: "The 'gpt-5.3-codex' model is not
+#        supported when using Codex with a ChatGPT account."
+#   codex exec "..."            (no --model)
+#     -> works, 22255 tokens, correct output
+#
+# The old pin ("official model name for Codex CLI v0.98+") was written against
+# v0.98 and never re-verified; the installed CLI is 0.144.6. Replacing it with
+# another hardcoded name would repeat the same mistake with a fresher string --
+# valid model names differ per account tier and change with upstream releases,
+# so THIS FILE CANNOT KNOW THEM. Codex already resolves an account-appropriate
+# default (honoring ~/.codex/config.toml), so the correct behavior is to say
+# nothing and let it choose. An operator who wants a specific model still sets
+# LOKI_CODEX_MODEL or LOKI_MODEL_*, which are passed through below.
+CODEX_DEFAULT_MODEL=""
 
 # Known valid Codex model prefixes for validation (BUG-PROV-002 fix)
 # Generic LOKI_MODEL_* may contain Claude model aliases (e.g. "opus", "sonnet",
@@ -69,7 +119,10 @@ _codex_validate_model() {
             return 0
         fi
     done
-    # Not a valid Codex model name -- fall back to default
+    # Not a valid Codex model name (e.g. a Claude alias leaking in via the
+    # generic LOKI_MODEL_*) -- fall back to the default, which is now EMPTY,
+    # i.e. "pass no --model and let Codex pick". That is deliberately the same
+    # safe outcome as an unset model rather than a guessed name.
     echo "$CODEX_DEFAULT_MODEL"
 }
 
@@ -125,16 +178,28 @@ provider_version() {
 # Invocation function
 # Note: Codex uses positional prompt, not -p flag
 # Note: Reasoning effort is configured via environment or config, not CLI flag
-# v7.x: pin the resolved model explicitly via -m/--model. Without it, codex
-# falls back to the installed CLI's built-in default (e.g. gpt-5.5 on codex
-# 0.132.0), which silently ignores _codex_validate_model and makes the run.sh
-# cost table (priced for gpt-5.3-codex) wrong. --model is the documented model
-# selector and is readable in process listings.
+# v7.x pinned the resolved model explicitly via -m/--model so the run.sh cost
+# table matched what actually ran. That is still the behavior WHEN A MODEL IS
+# SET -- but the flag is now OMITTED when the resolved model is empty, because
+# a hardcoded name broke ChatGPT-account users outright (see CODEX_DEFAULT_MODEL
+# above). Omitting it lets Codex resolve an account-appropriate default; the
+# trade-off is that the cost table falls back to its generic estimate, which is
+# strictly better than a run that cannot start at all.
+_codex_model_flag() {
+    # Echo nothing when no model is resolved, so the caller's array stays empty.
+    [ -n "${1:-}" ] && printf '%s\n%s\n' "--model" "$1"
+    return 0
+}
+
 provider_invoke() {
     local prompt="$1"
     shift
+    local model_flag=()
+    while IFS= read -r _mf; do
+        [ -n "$_mf" ] && model_flag+=("$_mf")
+    done < <(_codex_model_flag "$PROVIDER_MODEL_DEVELOPMENT")
     codex exec --sandbox workspace-write --skip-git-repo-check \
-        --model "$PROVIDER_MODEL_DEVELOPMENT" \
+        "${model_flag[@]+"${model_flag[@]}"}" \
         "$prompt" "$@"
 }
 
@@ -254,12 +319,19 @@ provider_invoke_with_tier() {
     # array is empty, and a bare "${arr[@]}" under `set -u` aborts with
     # "unbound variable" on bash 3.2 (stock macOS /bin/bash). ${arr[@]+...}
     # expands to nothing when empty and preserves spaced elements otherwise.
+    # Same conditional as provider_invoke: omit --model entirely when none
+    # resolved, rather than passing an empty string (which codex rejects).
+    local model_flag=()
+    while IFS= read -r _mf; do
+        [ -n "$_mf" ] && model_flag+=("$_mf")
+    done < <(_codex_model_flag "$model")
+
     codex \
         "${pre_exec_flags[@]+"${pre_exec_flags[@]}"}" \
         exec \
         --sandbox workspace-write \
         --skip-git-repo-check \
-        --model "$model" \
+        "${model_flag[@]+"${model_flag[@]}"}" \
         "${extra_flags[@]+"${extra_flags[@]}"}" \
         "$prompt" "$@"
 }

package/references/sdk-mode.md

@@ -0,0 +1,106 @@
+# SDK Mode: one-switch Anthropic SDK activation (v8.1)
+
+Loki's engine can run its model calls through the Anthropic SDKs instead of
+spawning the `claude` CLI. This is the enterprise / SaaS deploy path: a container
+or worker runs with just `ANTHROPIC_API_KEY`, no interactive `claude` login and
+no user-managed CLI version drift.
+
+Everything here is OPT-IN and DEFAULT-OFF. With nothing set, the engine is
+byte-identical to the bash `claude` route.
+
+## The one knob: `LOKI_SDK_MODE`
+
+| Value | What turns on | Use when |
+|---|---|---|
+| `off` (default) | nothing (byte-identical to v7/v8 bash route) | default |
+| `judges` | the 7 one-shot JUDGE/TEXT sites (done-recognition, council-v2, code-review, completion-council VOTE, voter-agents, grill, prd-enrich). The RARV loop stays OFF. | recommended scale tier: no `claude` binary needed for judging, loop unchanged |
+| `full` | all of `judges` PLUS the RARV main loop (`LOKI_SDK_LOOP`) | pre-flight only this release; requires `bun` (the loop runs on the Bun runner). The loop default-flip is a later release |
+
+Alias: `LOKI_SDK=1` == `judges`; `LOKI_SDK=full` == `full`.
+
+```bash
+# Scale tier: judges on the SDK, loop on the existing route.
+LOKI_SDK_MODE=judges loki start ./prd.md
+
+# Pre-flight the full SDK engine (needs bun).
+LOKI_SDK_MODE=full loki start ./prd.md
+
+# See what one switch turned on.
+LOKI_SDK_MODE_DEBUG=1 LOKI_SDK_MODE=judges loki start ./prd.md
+# stderr: loki: SDK mode=judges -> judges on, loop=0
+```
+
+## Rollback: `LOKI_LEGACY_BASH=1`
+
+Forces the legacy bash `claude` route for every command, overriding any
+`LOKI_SDK_MODE` / `LOKI_SDK_*` setting. Honored at the `bin/loki` shim AND inside
+the Bun provider resolver, so it wins even if the Bun route is reached another
+way. This is the always-available escape hatch; today the loop is default-off, so
+it is a no-op for the loop and only matters once the loop opts on.
+
+```bash
+LOKI_LEGACY_BASH=1 loki start ./prd.md   # legacy bash claude route, SDK off
+```
+
+## Advanced: the per-site flags (rollback appendix)
+
+`LOKI_SDK_MODE` is a convenience that sets the default for eight per-site flags.
+Set any of these EXPLICITLY to override the mode for one site (an explicit value,
+even `=0`, always wins over the mode):
+
+| Flag | Site |
+|---|---|
+| `LOKI_SDK_DONE_RECOG` | done-recognition judge |
+| `LOKI_SDK_COUNCIL_V2` | council-v2 judge |
+| `LOKI_SDK_CODE_REVIEW` | code-review reviewer |
+| `LOKI_SDK_COUNCIL_VOTE` | completion-council member + contrarian VOTE |
+| `LOKI_SDK_VOTER_AGENTS` | voter-agents council |
+| `LOKI_SDK_GRILL` | grill (free-form text) |
+| `LOKI_SDK_PRD_ENRICH` | prd-enrich (free-form text) |
+| `LOKI_SDK_LOOP` | the RARV main loop (Bun runner) |
+
+```bash
+# Everything on the SDK EXCEPT code review (keep that on the bash claude route):
+LOKI_SDK_MODE=full LOKI_SDK_CODE_REVIEW=0 loki start ./prd.md
+```
+
+## Guarantees
+
+- **Fail-closed.** Any SDK miss (no key, transport error, refusal, malformed
+  output, timeout, empty) falls through to the existing `claude` / deterministic
+  path. A quality gate or completion council can never fake-PASS or fake-APPROVE
+  via an SDK path.
+- **Parity.** The bash and Bun/TypeScript routes resolve the same mode -> flags
+  table (bound to a shared test fixture), so the two routes never diverge.
+- **Requires a key.** The SDK route needs `ANTHROPIC_API_KEY` (or a gateway /
+  Bedrock / Vertex base URL). Without it, every SDK site fail-closes to the bash
+  route. `full` additionally requires `bun` for the loop; on a bun-less host every
+  mode degrades to the legacy route.
+
+Implementation: `autonomy/lib/sdk-mode.sh` (bash), `loki-ts/src/runner/sdk_mode.ts`
+(TypeScript). Shared parity fixture: `loki-ts/test/fixtures/sdk-mode-table.json`.
+
+## Dev-only OAuth auth (`LOKI_SDK_OAUTH_DEV`)
+
+For local development you can drive the SDK JUDGE path with your existing `claude`
+login instead of a standalone `ANTHROPIC_API_KEY`. Set `LOKI_SDK_OAUTH_DEV=1` with
+NO `ANTHROPIC_API_KEY` present: the raw-SDK client (`sdk_invoker.ts`) reads the
+freshest claude.ai OAuth access token (macOS Keychain `Claude Code-credentials`
+first, then `${CLAUDE_CONFIG_DIR:-~/.claude}/.credentials.json`) and calls the
+Messages API with a Bearer token plus the required `anthropic-beta:
+oauth-2025-04-20` header.
+
+```bash
+# judges on the SDK, authenticated by your `claude` login (no API key):
+LOKI_SDK_OAUTH_DEV=1 LOKI_SDK_MODE=judges loki start ./prd.md
+```
+
+DEV ONLY, and deliberately gated so it can never affect production:
+- Activates only when the flag is set AND `ANTHROPIC_API_KEY` is ABSENT (an API
+  key always wins).
+- The token expires ~hourly and is NOT refreshed here; when it lapses mid-run the
+  SDK site fail-closes to the deterministic/bash fallback, same as a missing key.
+- Only wired for the JUDGE path (`sdk_invoker.ts`), not the agentic RARV loop.
+
+Implementation: `loki-ts/src/runner/oauth_dev.ts`. Gate tests:
+`loki-ts/test/runner/oauth_dev.test.ts`.

package/skills/model-selection.md

@@ -5,7 +5,7 @@
 Since v6.81.0, the main RARV loop uses **one pinned model per session** instead of rotating models per RARV phase. This eliminates per-iteration tier churn and keeps the main loop behavior predictable.
 
 - Controlled by `LOKI_SESSION_MODEL` (default: `sonnet`).
-- Accepted values: `opus`, `sonnet`, `haiku`, or a raw tier name (`planning`, `development`, `fast`). The value names a **tier**, not a fixed model: it is mapped to an abstract tier (opus -> planning, sonnet -> development, haiku -> fast) which is then resolved to a concrete model through the provider config (`PROVIDER_MODEL_PLANNING/DEVELOPMENT/FAST`). On stock config the default `sonnet` pin = the **development** tier = `PROVIDER_MODEL_DEVELOPMENT` = **opus** (the model the runner actually dispatches). Under `LOKI_ALLOW_HAIKU=true` the development tier lowers to sonnet (and fast to haiku). This tier-to-model resolution is why `loki plan` quotes Opus on the stock default path: the quote names the dispatched model, not the pin alias. A mid-flight `.loki/state/model-override` is different: that alias is fed straight to `--model` (a `sonnet` override dispatches sonnet, no tier route).
+- Accepted values: `opus`, `sonnet`, `haiku`, or a raw tier name (`planning`, `development`, `fast`). The value names a **tier**, not a fixed model: it is mapped to an abstract tier (opus -> planning, sonnet -> development, haiku -> fast) which is then resolved to a concrete model through the provider config (`PROVIDER_MODEL_PLANNING/DEVELOPMENT/FAST`). On stock config the default `sonnet` pin = the **development** tier = `PROVIDER_MODEL_DEVELOPMENT` = **sonnet** (since v7.104.0, `CLAUDE_DEFAULT_DEVELOPMENT=sonnet`; planning and fast also default to sonnet on the stock path). This is why `loki plan` quotes Sonnet on the stock default path: the quote names the dispatched model, and every tier resolves to the same sonnet model unless the provider config overrides a tier. A mid-flight `.loki/state/model-override` is different: that alias is fed straight to `--model` (a `sonnet` override dispatches sonnet, no tier route).
 - `get_rarv_tier()` is retained and still used for subagent Task-tool dispatches (planning vs implementation vs fast work), not for the main loop.
 
 **Rollback (legacy RARV tier rotation in the main loop):**

package/skills/quality-gates.md

@@ -264,6 +264,28 @@ LOKI_REVIEW_INCONCLUSIVE_BLOCK=1  # default 1. Treat a code-review round that
                                   # or zero real verdicts) as a BLOCK instead
                                   # of a silent pass. Set 0 to disable.
 
+LOKI_REVIEW_UNAVAILABLE_BLOCK=1   # default 1 (blocks under LOKI_HARD_GATES).
+                                  # When NO reviewer can run at all (no claude
+                                  # binary on PATH AND no reachable SDK judge),
+                                  # code_review would otherwise pass with ZERO
+                                  # review -- a fake-PASS that makes the blind
+                                  # 3-reviewer moat a no-op. Blocks instead. Set
+                                  # 0 for an honest degraded pass (a run that
+                                  # deliberately has no reviewer). The raw-SDK
+                                  # reviewer path (LOKI_SDK_CODE_REVIEW=1 + a key)
+                                  # counts as available, so this only fires with
+                                  # no reviewer at all.
+
+LOKI_GATE_TEST_COVERAGE_BLOCK=0   # default 0 (advisory, bash-parity). By default
+                                  # a failing test suite is surfaced and the
+                                  # completion-council evidence gate is the
+                                  # backstop that refuses "done" on red tests.
+                                  # Set 1 to ALSO refuse completion at the runner
+                                  # layer deterministically (fail-closed even if
+                                  # a heuristic council with no evidence gate is
+                                  # in play). Same opt-in shape as the
+                                  # semantic_tests / invariants _BLOCK toggles.
+
 LOKI_COMPLETION_TEST_CAPTURE=1    # default 1. The verified-completion gate
                                   # captures fresh test evidence when
                                   # test-results.json is absent, instead of