loki-mode 11.3.9 → 11.4.2

package/autonomy/route.sh

@@ -0,0 +1,270 @@
+#!/usr/bin/env bash
+# One predictable execution path (OC-ROUTE).
+# Sourced by bin/loki. Normalizes argv BEFORE the engine decision so argument
+# order and input form never change the engine:
+#   engine10 is the default for a PRD file, an issue ref, a multi-word task and a
+#   one-word brief, whether the flags come first or last.
+#   The legacy engine runs only on --engine legacy / LOKI_ENGINE=legacy, or, for
+#   one specific flag engine10 cannot honor, for that call only (with a notice).
+# Pure functions: no exec, no side effects except R_* globals and the printers.
+# Bash 3.2 compatible (no associative arrays, no ${var,,}).
+
+# Flags that take a separate value token.
+_ROUTE_VALUE_FLAGS=" --provider --budget --budget-limit --max-cost --max-iterations --max-retries --session-model --completion-promise --base-wait --max-wait --prd --brief --attempts --spec --aider-model --aider-flags --cline-model --isolation --output --engine --mirofish-rounds --mirofish-timeout "
+# Flags engine10 honors as-is.
+_ROUTE_E10_FLAGS=" --no-pr --deep --json --verbose --provider --max-cost --spec --attempts "
+# Accepted and dropped (no-ops on a non-interactive run).
+_ROUTE_NOOP_FLAGS=" --yes -y --no-plan --no-mirofish --no-dashboard "
+
+_route_has() { case "$1" in *" $2 "*) return 0 ;; esac; return 1; }
+
+_route_json_str() {
+    printf '%s' "$1" | tr '\n\t\r' '   ' | sed -e 's/\\/\\\\/g' -e 's/"/\\"/g'
+}
+
+_route_classify() {
+    # $1 = single positional. Echoes: issue | prd | task | brief | missing-prd
+    local p="$1"
+    case "$p" in
+        */*\#[0-9]*|http*://*/issues/*|http*://*/browse/*|jira:*|linear:*|https://linear.app/*/issue/*) echo issue; return 0 ;;
+    esac
+    if [ -f "$p" ]; then echo prd; return 0; fi
+    case "$p" in
+        *" "*) echo task; return 0 ;;
+        *.md|*.markdown|*.txt|*.json|*.yaml|*.yml) echo missing-prd; return 0 ;;
+    esac
+    echo brief
+}
+
+# loki_route_resolve VERB ARGS...   VERB = start | quick | bare
+# Sets: R_DECIDED R_E10 R_HARD R_ENGINE R_REASON R_INPUT_TYPE R_INPUT R_PROVIDER
+#       R_MODEL R_NOTICE R_ERR R_EXPLAIN R_JSON R_E10_ARGS[] R_CLEAN[] R_SESSION_MODEL R_VERB
+# R_* are the result interface read by the sourcing caller.
+# shellcheck disable=SC2034
+loki_route_resolve() {
+    local verb="$1"; shift
+    R_DECIDED=0; R_E10=0; R_HARD=0; R_ENGINE=""; R_REASON=""; R_INPUT_TYPE=""; R_INPUT=""
+    R_PROVIDER=""; R_MODEL=""; R_NOTICE=""; R_ERR=""; R_EXPLAIN=0; R_JSON=0; R_SESSION_MODEL=""; R_VERB=""
+    R_E10_ARGS=(); R_CLEAN=()
+
+    local a engine_req="" help=0 legacy_flag="" session_model="" provider_flag=""
+    local -a positionals=() passthru=()
+    local i=0 n=$#
+    local -a argv=("$@")
+    while [ "$i" -lt "$n" ]; do
+        a="${argv[$i]}"
+        i=$((i + 1))
+        case "$a" in
+            --engine) engine_req="${argv[$i]:-}"; i=$((i + 1)); continue ;;
+            --engine=*) engine_req="${a#--engine=}"; continue ;;
+            --explain-route) R_EXPLAIN=1; continue ;;
+            --help|-h) help=1; R_CLEAN+=("$a"); continue ;;
+            --) R_CLEAN+=("$a"); while [ "$i" -lt "$n" ]; do positionals+=("${argv[$i]}"); R_CLEAN+=("${argv[$i]}"); i=$((i + 1)); done; break ;;
+        esac
+        R_CLEAN+=("$a")
+        case "$a" in
+            -*)
+                local name="${a%%=*}" val=""
+                if _route_has "$_ROUTE_VALUE_FLAGS" "$name"; then
+                    if [ "$name" = "$a" ]; then
+                        val="${argv[$i]:-}"; i=$((i + 1)); R_CLEAN+=("$val")
+                    else
+                        val="${a#*=}"
+                    fi
+                fi
+                case "$name" in
+                    --prd) positionals+=("$val"); continue ;;
+                    --brief) positionals+=("$val"); continue ;;
+                    --provider) provider_flag="$val"; passthru+=(--provider "$val"); continue ;;
+                    --session-model) session_model="$val"; continue ;;
+                    --budget|--budget-limit|--max-cost) passthru+=(--max-cost "$val"); continue ;;
+                    --json) R_JSON=1; passthru+=(--json); continue ;;
+                    -v) passthru+=(--verbose); continue ;;
+                    --attempts) passthru+=(--attempts "$val"); continue ;;
+                    --spec) passthru+=(--spec "$val"); continue ;;
+                esac
+                if _route_has "$_ROUTE_NOOP_FLAGS" "$name"; then continue; fi
+                if _route_has "$_ROUTE_E10_FLAGS" "$name"; then passthru+=("$name"); continue; fi
+                # Everything else is a flag engine10 does not honor.
+                if [ -z "$legacy_flag" ]; then legacy_flag="$name"; fi
+                ;;
+            *) positionals+=("$a") ;;
+        esac
+    done
+
+    if [ "$help" = "1" ]; then return 0; fi
+
+    # Engine request: flag wins over env.
+    if [ -z "$engine_req" ]; then engine_req="${LOKI_ENGINE:-}"; fi
+    engine_req=$(printf '%s' "$engine_req" | tr '[:upper:]' '[:lower:]')
+    case "$engine_req" in
+        ""|legacy) ;;
+        engine10|e10|v10|10) engine_req=engine10 ;;
+        *) R_ERR="loki: unknown engine '$engine_req' (use --engine legacy or --engine engine10)"; R_DECIDED=1; return 0 ;;
+    esac
+
+    # Input.
+    local npos=${#positionals[@]}
+    if [ "$npos" -eq 0 ]; then
+        R_INPUT_TYPE=none
+        local k=0 sp=0
+        while [ "$k" -lt "${#passthru[@]}" ]; do
+            if [ "${passthru[$k]}" = "--spec" ]; then sp=1; fi
+            k=$((k + 1))
+        done
+        # No positional and no --spec: not ours (bare `loki start` auto-detects a PRD).
+        if [ "$sp" = "0" ]; then R_INPUT_TYPE=""; return 0; fi
+        R_INPUT_TYPE=spec
+        R_INPUT="(from --spec)"
+    elif [ "$npos" -eq 1 ]; then
+        R_INPUT_TYPE=$(_route_classify "${positionals[0]}")
+        R_INPUT="${positionals[0]}"
+    else
+        R_INPUT_TYPE=task
+        R_INPUT="${positionals[*]}"
+    fi
+
+    # Bare flag-first form takes over only multi-word tasks and issue refs (a one-word
+    # first argument is the command namespace) and only when no unknown flag is present.
+    if [ "$verb" = "bare" ]; then
+        case "$R_INPUT_TYPE" in
+            task|issue) ;;
+            *) R_INPUT_TYPE=""; return 0 ;;
+        esac
+        if [ -n "$legacy_flag" ] && [ -z "$engine_req" ]; then R_INPUT_TYPE=""; return 0; fi
+    fi
+
+    R_DECIDED=1
+    if [ "$R_INPUT_TYPE" = "missing-prd" ]; then
+        R_ERR="loki: PRD file not found: ${positionals[0]}"
+        return 0
+    fi
+
+    # Provider and model (display only; engine10 resolves its own at run time).
+    R_PROVIDER="$provider_flag"
+    if [ -z "$R_PROVIDER" ]; then R_PROVIDER="${LOKI_PROVIDER:-}"; fi
+    if [ -z "$R_PROVIDER" ] && [ -f "${PWD}/.loki/state/provider" ]; then
+        R_PROVIDER="$(sed -n '1p' "${PWD}/.loki/state/provider" 2>/dev/null || true)"
+    fi
+    if [ -z "$R_PROVIDER" ]; then R_PROVIDER=claude; fi
+    if [ -n "$session_model" ]; then
+        R_MODEL="$session_model"
+    elif [ -n "${LOKI_SESSION_MODEL:-}" ]; then
+        R_MODEL="$LOKI_SESSION_MODEL"
+    elif [ -n "${LOKI_MODEL_ROUTE:-}" ]; then
+        R_MODEL="route: $LOKI_MODEL_ROUTE"
+    elif [ -n "${LOKI_MODEL_OVERRIDE:-}" ]; then
+        R_MODEL="$LOKI_MODEL_OVERRIDE"
+    elif [ "$R_PROVIDER" = "opencode" ] && [ -n "${LOKI_OPENCODE_MODEL:-}" ]; then
+        R_MODEL="$LOKI_OPENCODE_MODEL"
+    elif [ "$R_PROVIDER" = "claude" ]; then
+        R_MODEL="${LOKI_CLAUDE_MODEL_DEVELOPMENT:-${LOKI_MODEL_DEVELOPMENT:-claude (provider default)}}"
+    else
+        R_MODEL="$R_PROVIDER (model not recorded)"
+    fi
+    R_SESSION_MODEL="$session_model"
+
+    # Task text for engine10: a PRD file is read, anything else is the words.
+    local task
+    if [ "$R_INPUT_TYPE" = "prd" ]; then
+        task=$(cat "${positionals[0]}" 2>/dev/null || true)
+    elif [ "$R_INPUT_TYPE" = "spec" ]; then
+        task=""
+    else
+        task="${positionals[*]}"
+    fi
+    if [ "$verb" = "quick" ]; then R_E10_ARGS+=(--no-pr); fi
+    if [ -n "$task" ]; then R_E10_ARGS+=("$task"); fi
+    R_E10_ARGS+=("${passthru[@]+"${passthru[@]}"}")
+
+    local why=""
+    if [ "$engine_req" = "legacy" ]; then
+        R_ENGINE=legacy; R_REASON="explicit: --engine legacy or LOKI_ENGINE=legacy"
+    elif [ "$engine_req" = "engine10" ]; then
+        if [ -n "$legacy_flag" ]; then
+            R_ERR="loki: flag $legacy_flag is not supported by the engine10 engine; drop it or use --engine legacy"
+            return 0
+        fi
+        R_ENGINE=engine10; R_E10=1; R_HARD=1; R_REASON="explicit: --engine engine10"
+    elif [ -n "$legacy_flag" ]; then
+        R_ENGINE=legacy
+        R_REASON="flag $legacy_flag is not supported by engine10"
+        R_NOTICE="loki: routing this call to the legacy engine because of $legacy_flag (engine10 does not support it). Drop the flag to use engine10, or pass --engine legacy to silence this."
+    else
+        case "$R_PROVIDER" in
+            claude|codex|cline|aider|opencode) ;;
+            *) why="provider $R_PROVIDER has no engine10 invoker (use claude, codex, cline, aider or opencode)" ;;
+        esac
+        if [ -z "$why" ] && [ "$R_INPUT_TYPE" = "prd" ]; then
+            local sz
+            sz=$(wc -c < "${positionals[0]}" 2>/dev/null | tr -d ' ' || echo 0)
+            if [ "${sz:-0}" -gt 100000 ]; then why="PRD is larger than 100000 bytes (engine10 takes the task as one argument)"; fi
+        fi
+        if [ -n "$why" ]; then
+            R_ENGINE=legacy; R_REASON="$why"
+            R_NOTICE="loki: routing this call to the legacy engine: $why."
+        else
+            R_ENGINE=engine10; R_E10=1
+            R_REASON="default: $R_INPUT_TYPE input runs on engine10 regardless of flag order"
+        fi
+    fi
+    return 0
+}
+
+# Print the route (human or --json). Returns 0.
+loki_route_print() {
+    local shown="$R_INPUT"
+    if [ "${#shown}" -gt 72 ]; then shown="$(printf '%s' "$shown" | cut -c1-69)..."; fi
+    if [ "$R_JSON" = "1" ]; then
+        printf '{"engine":"%s","provider":"%s","model":"%s","input_type":"%s","input":"%s","reason":"%s"}\n' \
+            "$(_route_json_str "$R_ENGINE")" "$(_route_json_str "$R_PROVIDER")" "$(_route_json_str "$R_MODEL")" \
+            "$(_route_json_str "$R_INPUT_TYPE")" "$(_route_json_str "$shown")" "$(_route_json_str "$R_REASON")"
+    else
+        printf 'engine:   %s\nprovider: %s\nmodel:    %s\ninput:    %s (%s)\nreason:   %s\n' \
+            "$R_ENGINE" "$R_PROVIDER" "$R_MODEL" "$R_INPUT_TYPE" "$shown" "$R_REASON"
+    fi
+}
+
+# Entry used by bin/loki. Args: the full original argv. Sets R_* and returns:
+#   0 = handled (caller reads R_DECIDED); 7 = `loki route` / --explain-route printed (caller exits 0)
+#   8 = usage or input error already printed (caller exits 2)
+# shellcheck disable=SC2034
+loki_route_dispatch() {
+    R_DECIDED=0
+    local verb="" first="${1:-}"
+    case "$first" in
+        route)
+            shift
+            case "${1:-}" in start|quick) verb="$1"; shift ;; *) verb=start ;; esac
+            loki_route_resolve "$verb" "$@"
+            if [ -n "$R_ERR" ]; then echo "$R_ERR" >&2; return 8; fi
+            if [ "$R_DECIDED" != "1" ]; then
+                echo "loki: usage: loki route [start|quick] <task | prd.md | owner/repo#N> [flags] [--json]" >&2; return 8
+            fi
+            loki_route_print; return 7
+            ;;
+        start|quick)
+            verb="$first"; shift
+            loki_route_resolve "$verb" "$@"
+            ;;
+        -*)
+            loki_route_resolve bare "$@"
+            verb=bare
+            ;;
+        *)
+            # Positional-first call: only LOKI_ENGINE needs the resolver here.
+            if [ -n "${LOKI_ENGINE:-}" ]; then
+                case "$first" in
+                    *" "*|*/*\#[0-9]*|http*://*/issues/*)
+                        loki_route_resolve bare "$@"; verb=bare ;;
+                esac
+            fi
+            ;;
+    esac
+    if [ "$R_DECIDED" != "1" ]; then return 0; fi
+    if [ -n "$R_ERR" ]; then echo "$R_ERR" >&2; return 8; fi
+    if [ "$R_EXPLAIN" = "1" ]; then loki_route_print; return 7; fi
+    if [ -n "$R_NOTICE" ]; then echo "$R_NOTICE" >&2; fi
+    R_VERB="$verb"
+    return 0
+}

package/autonomy/run.sh

@@ -29819,6 +29819,12 @@ except (json.JSONDecodeError, OSError): pass
         _loki_surface_why_hint || true
     fi
 
+    # OC-OUTPUT: unified run summary (same format as engine10); best-effort, never changes the exit code.
+    if [ -f "$SCRIPT_DIR/lib/run-summary.sh" ]; then
+        # shellcheck source=lib/run-summary.sh
+        source "$SCRIPT_DIR/lib/run-summary.sh" 2>/dev/null && loki_run_summary "$result" 2>/dev/null || true
+    fi
+
     exit $result
 }
 

package/autonomy/setup-wizard.sh

@@ -0,0 +1,161 @@
+#!/usr/bin/env bash
+# setup-wizard.sh -- `loki setup`: the single first-run wizard.
+# Sourced by autonomy/loki; relies on cmd_config_set and SKILL_DIR from that
+# file. `loki welcome` (intro), `loki quickstart` (first build) and
+# `loki doctor` (health) remain separate entry points.
+#
+# REQUIRED (doctor fails without them): node >= 18, python3 >= 3.8, jq, git, curl
+# AT LEAST ONE of: a provider CLI (claude, codex, cline, aider, opencode) or the
+#   bundled Claude Agent SDK with credentials. Claude Code is the default.
+# OPTIONAL: bun (bundled by npm), bash >= 4, codex/cline/aider/opencode, ollama.
+
+_lsw_ask() {
+    # _lsw_ask PROMPT DEFAULT -> echoes the answer; DEFAULT when --yes or no TTY
+    local prompt="$1" def="$2" ans=""
+    if [ "$_LSW_YES" = "1" ] || [ ! -t 0 ]; then
+        printf '%s' "$def"
+        return 0
+    fi
+    printf '%s [%s]: ' "$prompt" "$def" >&2
+    read -r ans || ans=""
+    printf '%s' "${ans:-$def}"
+}
+
+_lsw_confirm() {
+    # _lsw_confirm PROMPT -> 0 for yes; --yes accepts, no TTY declines
+    local ans=""
+    [ "$_LSW_YES" = "1" ] && return 0
+    [ ! -t 0 ] && return 1
+    printf '%s [y/N] ' "$1" >&2
+    read -r ans || ans=""
+    case "$ans" in y|Y|yes|YES) return 0 ;; *) return 1 ;; esac
+}
+
+_lsw_tool() {
+    # _lsw_tool NAME LABEL INSTALL_HINT
+    if command -v "$1" >/dev/null 2>&1; then
+        printf '  [ OK ]  %-10s %s\n' "$1" "$2"
+        return 0
+    fi
+    printf '  [MISS]  %-10s %s. Install: %s\n' "$1" "$2" "$3"
+    [ "$2" = "REQUIRED" ] && _LSW_MISSING=$((_LSW_MISSING + 1))
+    return 1
+}
+
+_lsw_help() {
+    echo "loki setup - first-run wizard (tools, provider, model route, spend cap)"
+    echo ""
+    echo "Usage: loki setup [--yes] [--provider NAME] [--model ROUTE] [--budget USD] [--global] [--check]"
+    echo ""
+    echo "  --yes, -y         Non-interactive: accept defaults, never prompt"
+    echo "  --provider NAME   claude (default), codex, cline, aider, opencode"
+    echo "  --model ROUTE     claude (default), ollama/<model>, openrouter/<vendor>/<model>"
+    echo "  --budget USD      Spend cap in USD (default: none)"
+    echo "  --global          Write to ~/.config/loki-mode instead of .loki/config"
+    echo "  --check           Report only; change nothing"
+    echo ""
+    echo "Related: loki welcome (intro), loki quickstart (first build), loki doctor (health)."
+}
+
+cmd_setup() {
+    _LSW_YES=0
+    _LSW_MISSING=0
+    local provider="" model="" budget="" use_global="" check_only=0
+    while [ $# -gt 0 ]; do
+        case "$1" in
+            --yes|-y) _LSW_YES=1 ;;
+            --provider) provider="${2:-}"; shift ;;
+            --model) model="${2:-}"; shift ;;
+            --budget) budget="${2:-}"; shift ;;
+            --global) use_global="--global" ;;
+            --check) check_only=1 ;;
+            --help|-h) _lsw_help; return 0 ;;
+            *) echo "Unknown option: $1" >&2; _lsw_help >&2; return 2 ;;
+        esac
+        shift
+    done
+    [ -n "${CI:-}" ] && _LSW_YES=1
+
+    echo "Loki Mode setup"
+    echo ""
+    echo "1. Required tools"
+    _lsw_tool node REQUIRED "https://nodejs.org (Node 20+ recommended, 18 minimum)" || true
+    _lsw_tool python3 REQUIRED "brew install python3, or your package manager" || true
+    _lsw_tool jq REQUIRED "brew install jq, or your package manager" || true
+    _lsw_tool git REQUIRED "brew install git, or your package manager" || true
+    _lsw_tool curl REQUIRED "brew install curl, or your package manager" || true
+    _lsw_tool bun OPTIONAL "bundled by npm; else see https://bun.sh" || true
+    if [ "$_LSW_MISSING" -gt 0 ]; then
+        echo ""
+        echo "Install the missing REQUIRED tools above with your package manager (setup never installs system packages), then rerun: loki setup"
+        return 1
+    fi
+
+    echo ""
+    echo "2. Provider CLI (Claude Code is the default and the only Tier-1 provider)"
+    local p
+    for p in codex cline aider opencode; do
+        _lsw_tool "$p" OPTIONAL "see 'loki doctor' for the command" || true
+    done
+    if command -v claude >/dev/null 2>&1; then
+        printf '  [ OK ]  %-10s DEFAULT\n' claude
+        if claude auth status 2>/dev/null | grep -q '"loggedIn"[[:space:]]*:[[:space:]]*true'; then
+            echo "          claude is logged in."
+        else
+            echo "          claude is installed but not logged in. Run: claude auth login"
+            if [ "$check_only" = 0 ] && _lsw_confirm "Run 'claude auth login' now?"; then
+                claude auth login || true
+            fi
+        fi
+    else
+        echo "  [MISS]  claude     DEFAULT. Install: npm install -g @anthropic-ai/claude-code   (then: claude auth login)"
+        if [ "$check_only" = 0 ] && [ -f "${SKILL_DIR}/autonomy/provider-offer.sh" ]; then
+            if _lsw_confirm "Run that install command now?"; then
+                # shellcheck disable=SC1091
+                . "${SKILL_DIR}/autonomy/provider-offer.sh"
+                LOKI_ASSUME_YES="$_LSW_YES" _po_do_install || true
+            fi
+        fi
+        if ! command -v claude >/dev/null 2>&1; then
+            echo "          Claude Code is not mandatory if another provider above is installed,"
+            echo "          or if the bundled Claude Agent SDK has credentials."
+        fi
+    fi
+
+    if [ "$check_only" = 1 ]; then
+        echo ""
+        echo "Check only: no config written."
+        return 0
+    fi
+
+    echo ""
+    echo "3. Provider and model route"
+    [ -z "$provider" ] && provider="$(_lsw_ask "Provider (claude|codex|cline|aider|opencode)" claude)"
+    [ -z "$model" ] && model="$(_lsw_ask "Model route (claude | ollama/<model> | openrouter/<vendor>/<model>)" claude)"
+    echo ""
+    echo "4. Spend cap"
+    [ -z "$budget" ] && budget="$(_lsw_ask "Spend cap in USD (blank for none)" "")"
+
+    echo ""
+    echo "5. Writing config"
+    # shellcheck disable=SC2086
+    cmd_config_set $use_global provider "$provider" || return 1
+    if [ -n "$budget" ]; then
+        # shellcheck disable=SC2086
+        cmd_config_set $use_global budget "$budget" || return 1
+    fi
+    case "$model" in
+        ""|claude) ;;
+        ollama/*)
+            echo "  Model route: pass '--model $model' to loki start (Ollama must be running: ollama serve)."
+            ;;
+        openrouter/*)
+            echo "  Model route: pass '--model $model' and export OPENROUTER_API_KEY (setup never stores keys)."
+            ;;
+        *) echo "  Unrecognized route '$model'; using the provider default." ;;
+    esac
+
+    echo ""
+    echo "Done. Next: loki doctor (verify), loki quickstart (first build). Inspect: loki config list"
+    return 0
+}

package/autonomy/verify.sh

@@ -38,6 +38,8 @@
 #   1  CONCERNS
 #   2  BLOCKED
 #   3  verifier error (could not complete; never silently passes)
+#   64 usage error (unknown option / unexpected argument)
+#   Not a git repo exits 2; an empty diff exits 3 (enforced from v11.4.0).
 #
 # EXIT-CODE ORDERING, RECONCILED. An early draft spec listed
 # 0=VERIFIED, 1=BLOCKED, 2=CONCERNS, and this header used to say a human must
@@ -66,6 +68,7 @@ VERIFY_EXIT_VERIFIED=0
 VERIFY_EXIT_CONCERNS=1
 VERIFY_EXIT_BLOCKED=2
 VERIFY_EXIT_ERROR=3
+VERIFY_EXIT_USAGE=64
 VERIFY_SCHEMA_VERSION="1.0"
 
 # S-216: verify runs from the tree under review (tree="."), and a bare
@@ -355,8 +358,10 @@ verify_diff_base() {
     VERIFY_DIFF_INS=0
     VERIFY_DIFF_DEL=0
     VERIFY_DIFF_NAMES=""
+    VERIFY_NOT_GIT=0
 
     if ! git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+        VERIFY_NOT_GIT=1
         _verify_log "not a git repository; diff base unresolved (inconclusive)"
         return 0
     fi
@@ -2187,6 +2192,16 @@ verify_compute_verdict() {
     elif [ "$has_nonblock_finding" = "true" ] || [ "$inconclusive" = "true" ]; then
         VERIFY_VERDICT="CONCERNS"
         VERIFY_EXIT=$VERIFY_EXIT_CONCERNS
+        # Exit contract (v11.4.0): the two inputs that give the verifier nothing
+        # to check map to their own codes. The verdict word stays CONCERNS so
+        # evidence.json is unchanged; only the process status is sharper.
+        if [ "$has_nonblock_finding" != "true" ]; then
+            if [ "${VERIFY_NOT_GIT:-0}" = "1" ]; then
+                VERIFY_EXIT=$VERIFY_EXIT_BLOCKED
+            elif [ "${VERIFY_DIFF_RESOLVED:-false}" = "true" ] && [ "${VERIFY_DIFF_FILES:-0}" -eq 0 ]; then
+                VERIFY_EXIT=$VERIFY_EXIT_ERROR
+            fi
+        fi
     else
         VERIFY_VERDICT="VERIFIED"
         VERIFY_EXIT=$VERIFY_EXIT_VERIFIED
@@ -2570,6 +2585,11 @@ EXIT CODES:
     1  CONCERNS
     2  BLOCKED
     3  verifier error (could not complete; never silently passes)
+    64 usage error (unknown option or unexpected argument)
+
+    Two inputs that leave nothing to check have their own codes: a directory
+    that is not a git repository exits 2, an empty diff vs base exits 3. The
+    VERDICT line still reads CONCERNS for both.
 
     Severity rises with the code, so `[ $rc -ge 2 ]` means "at least blocked".
     An early draft spec listed 1=BLOCKED, 2=CONCERNS; that ordering was
@@ -3238,10 +3258,10 @@ verify_main() {
             --allow-unsigned) VERIFY_ALLOW_UNSIGNED=1; shift ;;
             --) shift; break ;;
             -*)
-                _verify_err "unknown option: $1"; verify_help; return $VERIFY_EXIT_ERROR ;;
+                _verify_err "unknown option: $1"; verify_help; return $VERIFY_EXIT_USAGE ;;
             *)
                 if [ -z "$base_ref" ]; then base_ref="$1"; else
-                    _verify_err "unexpected argument: $1"; return $VERIFY_EXIT_ERROR
+                    _verify_err "unexpected argument: $1"; return $VERIFY_EXIT_USAGE
                 fi
                 shift ;;
         esac

package/bin/loki

@@ -245,6 +245,48 @@ if [ "${LOKI_PROVIDER:-}" = "gemini" ]; then
     exit 1
 fi
 
+# OC-MODELS: `loki start|quick ... --model <id>` (also flag-first). One place maps the flag to
+# env before ANY engine/route decision, so engine10, the Bun start command and the legacy
+# loop all see the same thing. Route specs (openrouter|ollama|lmstudio|llamacpp|vllm|custom/<id>)
+# set LOKI_MODEL_ROUTE (claude child only); tier names and Claude aliases become --session-model;
+# any other id sets LOKI_OPENCODE_MODEL for opencode or LOKI_MODEL_OVERRIDE otherwise.
+case "${1:-}" in
+    start|quick|--model|--model=*)
+        _lm_has=0
+        for _lm_a in "$@"; do case "$_lm_a" in --model|--model=*) _lm_has=1 ;; esac; done
+        if [ "$_lm_has" = "1" ]; then
+            _lm_out=(); _lm_model=""; _lm_prov=""; _lm_skip=0; _lm_pnext=0
+            for _lm_a in "$@"; do
+                if [ "$_lm_skip" = "1" ]; then case "$_lm_a" in -*) _lm_model=""; break ;; esac; _lm_model="$_lm_a"; _lm_skip=0; continue; fi
+                if [ "$_lm_pnext" = "1" ]; then _lm_prov="$_lm_a"; _lm_pnext=0; fi
+                case "$_lm_a" in
+                    --model) _lm_skip=1; continue ;;
+                    --model=*) _lm_model="${_lm_a#--model=}"; continue ;;
+                    --provider) _lm_pnext=1 ;;
+                    --provider=*) _lm_prov="${_lm_a#--provider=}" ;;
+                esac
+                _lm_out+=("$_lm_a")
+            done
+            if [ -n "$_lm_model" ]; then
+                [ -n "$_lm_prov" ] || _lm_prov="${LOKI_PROVIDER:-claude}"
+                case "$_lm_model" in
+                    openrouter/*|ollama/*|lmstudio/*|llamacpp/*|vllm/*|custom/*) export LOKI_MODEL_ROUTE="$_lm_model" ;;
+                    small|medium|high|opus|sonnet|haiku) _lm_out+=(--session-model "$_lm_model") ;;
+                    *)
+                        if [ "$_lm_prov" = "opencode" ]; then export LOKI_OPENCODE_MODEL="$_lm_model"
+                        else export LOKI_MODEL_OVERRIDE="$_lm_model"; fi
+                        ;;
+                esac
+            else
+                echo "loki: --model requires a value (for example ollama/qwen3-coder or openrouter/<id>)." >&2
+                exit 2
+            fi
+            set -- ${_lm_out[@]+"${_lm_out[@]}"}
+        fi
+        unset _lm_has _lm_out _lm_model _lm_prov _lm_skip _lm_pnext _lm_a
+        ;;
+esac
+
 # First-run funnel, stage C: the activation ATTEMPT (first `loki start`).
 #
 # WHY HERE. This shim runs for BOTH routes before any exec, so one emit at this
@@ -406,29 +448,16 @@ _loki_start_needs_bash() {
         esac
     done
     unset _loki_iso_next
-
-    # The Bun RARV loop has not ported the opencode invoker yet. Keep the
-    # released, autonomous shell adapter reachable when SDK mode is enabled
-    # instead of accepting the selection and then failing after intake. CLI
-    # selection wins over env, which wins over the project-level saved choice.
-    local effective_provider="$explicit_provider"
-    if [ -z "$effective_provider" ] && [ -n "${LOKI_PROVIDER:-}" ]; then
-        effective_provider="$LOKI_PROVIDER"
-    fi
-    if [ -z "$effective_provider" ] && [ -f "${PWD}/.loki/state/provider" ]; then
-        effective_provider="$(sed -n '1p' "${PWD}/.loki/state/provider" 2>/dev/null || true)"
-    fi
-    [ "$effective_provider" = "opencode" ] && return 0
     return 1
 }
 _loki_attempts_refuse() {
     if _loki_start_needs_bash "$@"; then
-        echo "loki: 'loki start --attempts' runs only the Loki 10 engine; an option or provider in this command (for example --parallel, --github, --sandbox, --issue, --dry-run, --detach, or opencode) was only honored by the removed legacy loop. Remove it, or use a task string, an issue ref or a PRD path." >&2
+        echo "loki: 'loki start --attempts' runs only the Loki 10 engine; an option or provider in this command (for example --parallel, --github, --sandbox, --issue, --dry-run, or --detach) was only honored by the removed legacy loop. Remove it, or use a task string, an issue ref or a PRD path." >&2
         exit 2
     fi
     case "${LOKI_PROVIDER:-claude}" in
-        claude|codex|cline|aider) ;;
-        *) echo "loki: the Loki 10 engine does not support LOKI_PROVIDER=${LOKI_PROVIDER:-}; use claude, codex, cline or aider." >&2; exit 2 ;;
+        claude|codex|cline|aider|opencode) ;;
+        *) echo "loki: the Loki 10 engine does not support LOKI_PROVIDER=${LOKI_PROVIDER:-}; use claude, codex, cline, aider or opencode." >&2; exit 2 ;;
     esac
 }
 
@@ -482,6 +511,28 @@ if [ "${1:-}" = "start" ]; then
     unset _loki_sp_a
 fi
 
+# OC-ROUTE: normalize flags before the engine decision so argument order and input form
+# never change the engine (autonomy/route.sh; `loki route ...` and --explain-route print it).
+_R_APPLIED=0
+if [ -f "$REPO_ROOT/autonomy/route.sh" ] && { [ "$_LOKI_START_ATTEMPTS" != "1" ] || case " $* " in *" --explain-route "*) true ;; *) false ;; esac; }; then
+    # shellcheck source=/dev/null
+    . "$REPO_ROOT/autonomy/route.sh"
+    _r_rc=0
+    loki_route_dispatch "$@" || _r_rc=$?
+    case "$_r_rc" in 7) exit 0 ;; 8) exit 2 ;; esac
+    if [ "$R_DECIDED" = "1" ]; then
+        _R_APPLIED=1
+        if [ -n "$R_SESSION_MODEL" ]; then
+            case "$R_SESSION_MODEL" in small) R_SESSION_MODEL=fast ;; medium) R_SESSION_MODEL=development ;; high) R_SESSION_MODEL=planning ;; esac
+            export LOKI_SESSION_MODEL="$R_SESSION_MODEL"
+        fi
+        if [ "$R_E10" != "1" ]; then
+            set -- "$([ "$R_VERB" = "bare" ] && echo start || echo "$R_VERB")" ${R_CLEAN[@]+"${R_CLEAN[@]}"}
+        fi
+    fi
+    unset _r_rc
+fi
+
 # Loki 10 engine (D29, the only engine from 11.0.0). Routes `loki "<task>"`,
 # `loki owner/repo#N`, `loki quick "<task>"`, `keys` and `verify --pubkey` to engine10.
 # shellcheck disable=SC2194
@@ -566,14 +617,18 @@ case "v10" in
             # issue refs reach v10.
             *) _e10=0 ;;
         esac
+        if [ "$_R_APPLIED" = "1" ]; then
+            _e10="$R_E10"; _e10_hard="$R_HARD"
+            if [ "$R_E10" = "1" ]; then _e10_args=("${R_E10_ARGS[@]}"); fi
+        fi
         # Default (unset) mode never breaks a host: no bun, or a provider engine10 has no
         # invoker for, falls through to the legacy engine. Explicit v10 keeps its hard error.
         if [ "$_e10" = "1" ] && [ "$_e10_hard" = "0" ]; then
             case "${LOKI_PROVIDER:-claude}" in
-                claude|codex|cline|aider) ;;
+                claude|codex|cline|aider|opencode) ;;
                 *)
                     _e10=0
-                    echo "loki: using the legacy engine (the Loki 10 engine does not support LOKI_PROVIDER=${LOKI_PROVIDER:-}; use claude, codex, cline or aider)." >&2
+                    echo "loki: using the legacy engine (the Loki 10 engine does not support LOKI_PROVIDER=${LOKI_PROVIDER:-}; use claude, codex, cline, aider or opencode)." >&2
                     ;;
             esac
             if [ "$_e10" = "1" ]; then