loki-mode 11.3.9 → 11.5.1

package/autonomy/provider-offer.sh

@@ -80,6 +80,60 @@ detect_any_provider() {
     return 1
 }
 
+# sdk_binary_present: true (0) when an executable Claude Agent SDK platform binary exists
+# in an installed node_modules. Shared by detect_bundled_sdk_provider and
+# loki_requirements_json.
+sdk_binary_present() {
+    # Search the node_modules trees Loki is actually installed into. The root is
+    # derived from THIS FILE's location (self-containment contract, see header):
+    # SKILL_DIR belongs to autonomy/loki and is NOT exported, so it would be
+    # empty when doctor.ts spawns this script standalone -- which would silently
+    # answer "no SDK" on the Bun route while the bash route said yes, exactly the
+    # kind of route split the parity gate exists to prevent.
+    # LOKI_SDK_NODE_MODULES is a TEST-ONLY seam (never set in production) so the
+    # shell tests can point at a fixture tree without mutating real node_modules.
+    local _po_root
+    _po_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." 2>/dev/null && pwd)" || _po_root=""
+    # Array, not a word-split string: install roots can contain spaces.
+    local _po_search=()
+    if [ -n "${LOKI_SDK_NODE_MODULES:-}" ]; then
+        # When the test seam is set it is AUTHORITATIVE (not merely first): the
+        # real tree must not be consulted as a fallback, or a fixture asserting
+        # "no usable SDK" would silently pass by finding the repo's own binary.
+        _po_search=("$LOKI_SDK_NODE_MODULES")
+    elif [ -n "$_po_root" ]; then
+        # Two layouts, both real:
+        #   repo clone      -> <root>/node_modules, <root>/loki-ts/node_modules
+        #   npm install     -> npm HOISTS the SDK out of node_modules/loki-mode/
+        #                      up to the installing tree's top-level
+        #                      node_modules/ (verified by packing this repo and
+        #                      installing the tarball). Without the hoisted
+        #                      candidates the predicate silently returns 1 for
+        #                      every npm-installed user, i.e. the feature would
+        #                      be dead for exactly the audience it targets.
+        # <root> is .../node_modules/loki-mode, so ../ is the @scope-less
+        # top-level node_modules and ../../ covers a scoped install.
+        _po_search=(
+            "$_po_root/node_modules"
+            "$_po_root/loki-ts/node_modules"
+            "$_po_root/.."
+            "$_po_root/../.."
+        )
+    fi
+    local _nm
+    for _nm in ${_po_search+"${_po_search[@]}"}; do
+        [ -n "$_nm" ] || continue
+        set -- "$_nm"/@anthropic-ai/claude-agent-sdk-*/claude
+        # Unmatched globs stay literal in bash, so test the expansion for real.
+        while [ "$#" -gt 0 ]; do
+            [ -x "$1" ] && return 0
+            shift
+        done
+    done
+    return 1
+}
+
+
 # detect_bundled_sdk_provider: true (0) only when the bundled Claude Agent SDK
 # can ACTUALLY run this machine's main loop with no separate CLI install.
 #
@@ -130,53 +184,7 @@ detect_bundled_sdk_provider() {
         return 1
     fi
 
-    # Search the node_modules trees Loki is actually installed into. The root is
-    # derived from THIS FILE's location (self-containment contract, see header):
-    # SKILL_DIR belongs to autonomy/loki and is NOT exported, so it would be
-    # empty when doctor.ts spawns this script standalone -- which would silently
-    # answer "no SDK" on the Bun route while the bash route said yes, exactly the
-    # kind of route split the parity gate exists to prevent.
-    # LOKI_SDK_NODE_MODULES is a TEST-ONLY seam (never set in production) so the
-    # shell tests can point at a fixture tree without mutating real node_modules.
-    local _po_root
-    _po_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." 2>/dev/null && pwd)" || _po_root=""
-    # Array, not a word-split string: install roots can contain spaces.
-    local _po_search=()
-    if [ -n "${LOKI_SDK_NODE_MODULES:-}" ]; then
-        # When the test seam is set it is AUTHORITATIVE (not merely first): the
-        # real tree must not be consulted as a fallback, or a fixture asserting
-        # "no usable SDK" would silently pass by finding the repo's own binary.
-        _po_search=("$LOKI_SDK_NODE_MODULES")
-    elif [ -n "$_po_root" ]; then
-        # Two layouts, both real:
-        #   repo clone      -> <root>/node_modules, <root>/loki-ts/node_modules
-        #   npm install     -> npm HOISTS the SDK out of node_modules/loki-mode/
-        #                      up to the installing tree's top-level
-        #                      node_modules/ (verified by packing this repo and
-        #                      installing the tarball). Without the hoisted
-        #                      candidates the predicate silently returns 1 for
-        #                      every npm-installed user, i.e. the feature would
-        #                      be dead for exactly the audience it targets.
-        # <root> is .../node_modules/loki-mode, so ../ is the @scope-less
-        # top-level node_modules and ../../ covers a scoped install.
-        _po_search=(
-            "$_po_root/node_modules"
-            "$_po_root/loki-ts/node_modules"
-            "$_po_root/.."
-            "$_po_root/../.."
-        )
-    fi
-    local _nm
-    for _nm in ${_po_search+"${_po_search[@]}"}; do
-        [ -n "$_nm" ] || continue
-        set -- "$_nm"/@anthropic-ai/claude-agent-sdk-*/claude
-        # Unmatched globs stay literal in bash, so test the expansion for real.
-        while [ "$#" -gt 0 ]; do
-            [ -x "$1" ] && return 0
-            shift
-        done
-    done
-    return 1
+    sdk_binary_present
 }
 
 # _po_assume_yes: true when the user has opted into unattended confirmation.
@@ -545,6 +553,46 @@ print(json.dumps({"selected": selected, "providers": rows}, indent=2))
     ) || return 1
 }
 
+# loki_requirements_json: print the setup requirements report (shared table
+# autonomy/lib/setup-requirements.json) as one JSON object, matching the "requirements"
+# key of the Bun doctor (loki-ts/src/commands/doctor.ts). Used by the minimal
+# `loki doctor --json` fallback when the Bun doctor cannot run. Presence only: unlike the
+# Bun evaluator it does not compare versions.
+loki_requirements_json() {
+    local table statuses="" id kind target values st v
+    table="$(cd "$(dirname "${BASH_SOURCE[0]}")" 2>/dev/null && pwd)/lib/setup-requirements.json"
+    if [ ! -f "$table" ] || ! command -v jq >/dev/null 2>&1; then
+        printf 'null\n'
+        return 0
+    fi
+    while IFS=$'\t' read -r id kind target values; do
+        st=missing
+        case "$kind" in
+            command) command -v "$target" >/dev/null 2>&1 && st=present ;;
+            env_any)
+                for v in ${target//,/ }; do [ -n "${!v:-}" ] && st=present; done ;;
+            env_value)
+                for v in ${target//,/ }; do
+                    case ",${values}," in *",${!v:-},"*) [ -n "${!v:-}" ] && st=present ;; esac
+                done ;;
+            sdk_binary) sdk_binary_present && st=present ;;
+        esac
+        statuses="${statuses}${id} ${st}"$'\n'
+    done < <(jq -r '.requirements[] | [.id, .kind, (.target | if type == "array" then join(",") else . end), ((.values // []) | join(","))] | @tsv' "$table")
+
+    jq -n --rawfile st <(printf '%s' "$statuses") --slurpfile t "$table" '
+      ($st | split("\n") | map(select(length > 0) | split(" ") | {(.[0]): .[1]}) | add) as $s
+      | $t[0] as $tab
+      | {paths: [ $tab.paths[] as $p
+          | ([ $tab.requirements[] | select(.path == $p.id)
+               | {id, label, level, status: $s[.id], detail: (if $s[.id] == "present" then null else "not found by presence check" end), fix} ]) as $items
+          | ([ $items[] | select(.level == "required") ]) as $req
+          | {id: $p.id, title: $p.title,
+             ready: (if ($req | length) > 0 then ($req | all(.status == "present")) else ($items | any(.status == "present")) end),
+             items: $items} ]}
+      | . + {first_task_ready: ((.paths[] | select(.id == "common") | .ready) and ([.paths[] | select(.id != "common") | .ready] | any))}'
+}
+
 # Executed directly (doctor.ts child_process bridge, or manual): run the offer.
 # When sourced by autonomy/loki, this block does not run.
 if [ "${BASH_SOURCE[0]}" = "$0" ]; then

package/autonomy/route.sh

@@ -0,0 +1,302 @@
+#!/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=(); R_ADAPTER=""; R_CAPDIFF=()
+
+    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
+    _route_adapter_and_diffs "$legacy_flag"
+    return 0
+}
+
+# Sets R_ADAPTER and R_CAPDIFF[] from R_ENGINE / R_PROVIDER. Empty R_CAPDIFF means the
+# full Claude Code path on the Loki 10 engine. Statements mirror providers/*.sh
+# (PROVIDER_HAS_TASK_TOOL=false for every non-claude provider).
+_route_adapter_and_diffs() {
+    local legacy_flag="$1"
+    R_CAPDIFF=()
+    if [ "$R_ENGINE" = "legacy" ]; then
+        R_ADAPTER="legacy-bash:$R_PROVIDER"
+        R_CAPDIFF+=("runs the previous bash loop (autonomy/run.sh) instead of the Loki 10 supervisor")
+        if [ -n "$legacy_flag" ]; then
+            R_CAPDIFF+=("honors $legacy_flag, which engine10 does not support")
+        fi
+    else
+        R_ADAPTER="engine10:$R_PROVIDER"
+    fi
+    case "$R_PROVIDER" in
+        claude) ;;
+        codex|cline|aider|opencode)
+            R_CAPDIFF+=("provider $R_PROVIDER has no Claude Code Task-tool subagents (providers/$R_PROVIDER.sh)") ;;
+        *)
+            R_CAPDIFF+=("provider $R_PROVIDER has no engine10 invoker") ;;
+    esac
+}
+
+# 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
+        local diffs="" d
+        for d in ${R_CAPDIFF[@]+"${R_CAPDIFF[@]}"}; do
+            diffs="${diffs:+$diffs,}\"$(_route_json_str "$d")\""
+        done
+        printf '{"engine":"%s","adapter":"%s","provider":"%s","model":"%s","input_type":"%s","input":"%s","reason":"%s","capability_differences":[%s]}\n' \
+            "$(_route_json_str "$R_ENGINE")" "$(_route_json_str "$R_ADAPTER")" "$(_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")" "$diffs"
+    else
+        printf 'engine:   %s\nadapter:  %s\nprovider: %s\nmodel:    %s\ninput:    %s (%s)\nreason:   %s\n' \
+            "$R_ENGINE" "$R_ADAPTER" "$R_PROVIDER" "$R_MODEL" "$R_INPUT_TYPE" "$shown" "$R_REASON"
+        local d
+        for d in ${R_CAPDIFF[@]+"${R_CAPDIFF[@]}"}; do printf 'differs:  %s\n' "$d"; done
+    fi
+    return 0
+}
+
+# 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

@@ -31,7 +31,7 @@
 #   LOKI_RESOURCE_MEM_THRESHOLD  - Memory % threshold to warn (default: 80)
 #
 # Budget / Cost Limits (opt-in):
-#   LOKI_BUDGET_LIMIT            - Max USD spend before auto-pause (default: empty = unlimited)
+#   LOKI_BUDGET_LIMIT            - Max USD spend before auto-pause (default: loki-ts/data/model-pricing.json default_max_cost_usd, 100 USD; empty = unlimited)
 #                                  Example: "50.00" pauses session when estimated cost >= $50
 #
 # Security & Autonomy Controls (Enterprise):
@@ -532,7 +532,7 @@ for key, env_var in mapping.items():
     val = get_nested(data, key) or data.get(key) or data.get(key.replace('.', '_'))
     if val and isinstance(val, str):
         safe_val = shlex.quote(val)
-        print(f'[ -z \"\${{{env_var}:-}}\" ] && export {env_var}={safe_val}')
+        print(f'[ -z \"\${{{env_var}:-}}\" ] && export {env_var}={safe_val}' + (\" && export LOKI_BUDGET_SOURCE=config\" if env_var == 'LOKI_BUDGET_LIMIT' else ''))
 " 2>/dev/null)" 2>/dev/null || true
 }
 _LOKI_SETTINGS_FILE="${TARGET_DIR:-.}/.loki/config/settings.json" _load_json_settings
@@ -565,7 +565,23 @@ RESOURCE_MEM_THRESHOLD=${LOKI_RESOURCE_MEM_THRESHOLD:-80}     # Memory % thresho
 # it never kills work or discards a deliverable. The user removes .loki/PAUSE
 # to resume, or raises LOKI_BUDGET_LIMIT. Set LOKI_BUDGET_LIMIT="" to restore
 # the old unlimited behavior explicitly.
-BUDGET_LIMIT=${LOKI_BUDGET_LIMIT-"100.00"}  # USD. Note `-` not `:-`: an
+# LM-002: the default value is read from default_max_cost_usd in loki-ts/data/model-pricing.json, the same
+# file the Loki 10 engine reads (docs/cost-controls.md). "100.00" is only the
+# fallback when that file is absent, and budget_cap.test.ts pins it to the file.
+_loki_budget_default="$(sed -n 's/.*"default_max_cost_usd"[[:space:]]*:[[:space:]]*\([0-9][0-9.]*\).*/\1/p' \
+    "${SCRIPT_DIR}/../loki-ts/data/model-pricing.json" 2>/dev/null | head -n 1)"
+case "$_loki_budget_default" in
+    '' | *[!0-9.]*) _loki_budget_default="100.00" ;;
+    *) _loki_budget_default="$(awk -v v="$_loki_budget_default" 'BEGIN{printf "%.2f", v}')" ;;
+esac
+# Where the active cap came from: flag (loki start --budget), config (settings.json),
+# env (LOKI_BUDGET_LIMIT set by the caller), or default. Printed once at run start.
+if [ "${LOKI_BUDGET_LIMIT+set}" = "set" ]; then
+    BUDGET_SOURCE="${LOKI_BUDGET_SOURCE:-env}"
+else
+    BUDGET_SOURCE="default"
+fi
+BUDGET_LIMIT=${LOKI_BUDGET_LIMIT-"$_loki_budget_default"}  # USD. Note `-` not `:-`: an
                                             # explicit empty value means the
                                             # operator chose unlimited, and is
                                             # honored.
@@ -7536,7 +7552,7 @@ EOF
   "created_at": "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
 }
 BUDGET_EOF
-        log_info "Budget limit set: \$$BUDGET_LIMIT"
+        log_info "Budget limit set: \$$BUDGET_LIMIT (source: ${BUDGET_SOURCE:-default})"
     fi
 
     # v7.0.0 Phase 2: remote->local hydrate. Runs ONCE at session boot (not
@@ -9041,21 +9057,25 @@ _read_iteration_cost() {
     if [ -f "$result_cost_file" ]; then
         python3 -c "
 import json
+def _c(v):
+    return v if isinstance(v, (int, float)) and not isinstance(v, bool) else 'unmeasured'
 try:
     d = json.load(open('$result_cost_file'))
     print(
         d.get('input_tokens', 0) or 0,
         d.get('output_tokens', 0) or 0,
-        d.get('total_cost_usd', 0) or 0,
+        _c(d.get('total_cost_usd')),
         d.get('cache_read_tokens', 0) or 0,
         d.get('cache_creation_tokens', 0) or 0,
     )
 except Exception:
-    print(0, 0, 0, 0, 0)
-" 2>/dev/null || echo "0 0 0 0 0"
+    print(0, 0, 'unmeasured', 0, 0)
+" 2>/dev/null || echo "0 0 unmeasured 0 0"
     elif [ -f ".loki/context/tracking.json" ]; then
         python3 -c "
 import json
+def _c(v):
+    return v if isinstance(v, (int, float)) and not isinstance(v, bool) else 'unmeasured'
 try:
     t = json.load(open('.loki/context/tracking.json'))
     iters = t.get('per_iteration', [])
@@ -9065,17 +9085,17 @@ try:
         print(
             m.get('input_tokens', 0),
             m.get('output_tokens', 0),
-            m.get('cost_usd', 0),
+            _c(m.get('cost_usd')),
             m.get('cache_read_tokens', 0),
             m.get('cache_creation_tokens', 0),
         )
     else:
-        print(0, 0, 0, 0, 0)
+        print(0, 0, 'unmeasured', 0, 0)
 except Exception:
-    print(0, 0, 0, 0, 0)
-" 2>/dev/null || echo "0 0 0 0 0"
+    print(0, 0, 'unmeasured', 0, 0)
+" 2>/dev/null || echo "0 0 unmeasured 0 0"
     else
-        echo "0 0 0 0 0"
+        echo "0 0 unmeasured 0 0"
     fi
 }
 
@@ -9192,6 +9212,15 @@ track_iteration_complete() {
 $iter_cost_line
 ITER_COST_EOF
 
+    # Unknown cost is omitted with a reason, never written as 0 (readers treat absence as unmeasured).
+    local iter_cost_json
+    case "${iter_cost:-unmeasured}" in
+        unmeasured) iter_cost_json='  "cost_unmeasured_reason": "no dollar figure recorded for this iteration",
+' ;;
+        *) iter_cost_json="  \"cost_usd\": ${iter_cost},
+" ;;
+    esac
+
     cat > ".loki/metrics/efficiency/iteration-${iteration}.json" << EFF_EOF
 {
   "iteration": $iteration,
@@ -9204,8 +9233,7 @@ ITER_COST_EOF
   "output_tokens": ${iter_output:-0},
   "cache_read_tokens": ${iter_cache_read:-0},
   "cache_creation_tokens": ${iter_cache_creation:-0},
-  "cost_usd": ${iter_cost:-0},
-  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+${iter_cost_json}  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
 }
 EFF_EOF
 
@@ -29819,6 +29847,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
 }