loki-mode 11.39.2 → 11.41.0

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: Runs an autonomous software factory that knows what it is supposed to deliver and proves it did, with a signed receipt. Use when the user says Loki Mode or asks to build, fix or verify software autonomously.
 ---
 
-# Loki Mode v11.39.2
+# Loki Mode v11.41.0
 
 **Current entry points (Loki 10 engine):** `loki "<task>"`, `loki owner/repo#N` and `loki quick "<task>"` run the Loki 10 engine and end with a signed receipt (`loki verify`). `loki backlog owner/repo --all` runs many issues in parallel. Guide: `docs/v10/GUIDE.md`. The skill instructions below, and `loki start`, describe the previous bash loop. PRD-file starts (`loki start ./prd.md`) and the opencode provider still run on it until FC38-SWEEP ports them; the legacy-engine command and the LOKI_ENGINE switch remain removed. Prefer `loki owner/repo#N` for issues.
 
@@ -259,9 +259,9 @@ loki start --provider codex ./prd.json       # GPT-5.3 Codex, degraded mode
 loki start --provider cline ./prd.md         # Cline CLI, degraded mode
 loki start --provider aider ./prd.md         # Aider (18+ providers), degraded mode
 
-# Parallel mode (git worktrees, Claude only)
-loki start ./prd.md --parallel
-loki start 123 --ship                        # Issue -> PR -> auto-merge
+# Parallel and auto-merge (legacy loop only; the default engine refuses these flags)
+loki start ./prd.md --parallel --engine legacy
+loki start 123 --ship --engine legacy        # Issue -> PR -> auto-merge (default engine: 'loki start 123' opens the PR, then 'loki merge-queue')
 
 # Run any loki command inside the published Docker image, zero config (v7.45.0).
 # Bind-mounts the current folder to /workspace so .loki state, resume, and
@@ -476,4 +476,4 @@ Implemented, planned and deprecated items, with the version each landed in: `ski
 
 ---
 
-**v11.39.2 | [Autonomi](https://www.autonomi.dev/) flagship product | core skill**
+**v11.41.0 | [Autonomi](https://www.autonomi.dev/) flagship product | core skill**

package/VERSION

@@ -1 +1 @@
-11.39.2
+11.41.0

package/autonomy/lib/efficiency_cost.py

@@ -32,6 +32,7 @@ __all__ = [
     "read_child_ledger",
     "load_prices",
     "price_from_tokens",
+    "inference_geo_multiplier",
     "DEFAULT_PRICES_PATH",
 ]
 
@@ -48,6 +49,29 @@ DEFAULT_PRICES_PATH = os.path.join(
 # small helpers (self-contained copies; proof-generator.py keeps its own)
 # ---------------------------------------------------------------------------
 
+# Price multiplier for LOKI_INFERENCE_GEO, read from the same file the TS gate
+# reads (inference_geo_multipliers in loki-ts/data/model-pricing.json). Unset,
+# global and unknown values are 1.0; an unreadable file falls back to 1.1 for
+# "us" so a budget never silently under-counts.
+MODEL_PRICING_PATH = os.path.join(_REPO_ROOT, "loki-ts", "data", "model-pricing.json")
+
+
+def inference_geo_multiplier(env=None, pricing_path=None):
+    geo = ((env if env is not None else os.environ).get("LOKI_INFERENCE_GEO") or "").strip().lower()
+    if not geo:
+        return 1.0
+    table = None
+    try:
+        with open(pricing_path or MODEL_PRICING_PATH, "r") as f:
+            table = json.load(f).get("inference_geo_multipliers")
+    except Exception:
+        table = None
+    if not isinstance(table, dict):
+        table = {"us": 1.1}
+    m = table.get(geo)
+    return float(m) if isinstance(m, (int, float)) and m > 0 else 1.0
+
+
 def _read_json(path, default=None):
     try:
         with open(path, "r") as f:

package/autonomy/route.sh

@@ -4,20 +4,49 @@
 # 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).
+#   The legacy engine runs only on --engine legacy / LOKI_ENGINE=legacy, or a size or
+#   env-provider fallback. A flag never changes the engine: engine10 maps it or refuses it.
 # 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 "
+_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 --max-duration --log-level --compliance --cost --remote --issue --bmad-project --openspec --mirofish-docker --destination --domain --env-file --health-url --health-match "
 # Flags engine10 honors as-is.
-_ROUTE_E10_FLAGS=" --no-pr --deep --json --verbose --provider --max-cost --spec --attempts "
+_ROUTE_E10_FLAGS=" --no-pr --deep --json --verbose --quiet --resume --provider --max-cost --spec --attempts "
+# The most a run cap can reach (capCeilingS(true) in loki-ts/src/util/run_cap.ts: the subscription ceiling).
+_ROUTE_CAP_CEILING_S=3600
 # Accepted and dropped (no-ops on a non-interactive run).
-_ROUTE_NOOP_FLAGS=" --yes -y --no-plan --no-mirofish --no-dashboard "
+# --pr is a no-op because engine10 opens a PR by default (--no-pr turns it off).
+_ROUTE_NOOP_FLAGS=" --yes -y --no-plan --no-mirofish --no-dashboard --pr "
+
+# _route_refusal_hint FLAG: the engine10 replacement for a legacy-only flag (no engine10 equivalent exists).
+_route_refusal_hint() {
+    case "$1" in
+        --ship) echo "engine10 opens the PR itself and does not auto-merge; merge it with 'loki merge-queue', or pass --engine legacy to keep --ship" ;;
+        --worktree|-w) echo "engine10 runs each attempt in its own isolated worktree already; drop the flag, or pass --engine legacy for a git-worktree run" ;;
+        --detach|-d) echo "run it in the background yourself ('nohup loki start ... &') or queue it with 'loki queue run', or pass --engine legacy for --detach" ;;
+        --parallel) echo "use 'loki queue run --parallel K' or 'loki issues run --parallel K' for parallel runs, or pass --engine legacy for --parallel" ;;
+        *) echo "drop it, or pass --engine legacy to run the legacy loop with it" ;;
+    esac
+}
 
 _route_has() { case "$1" in *" $2 "*) return 0 ;; esac; return 1; }
 
+# _route_duration_s VALUE: seconds from 90, 90s, 90m or 2h; empty output when unusable or zero.
+_route_duration_s() {
+    local v="$1" n unit
+    case "$v" in
+        [0-9]*[0-9]|[0-9]) n="$v"; unit=s ;;
+        [0-9]*[smh]) n="${v%?}"; unit="${v#"$n"}" ;;
+        *) return 0 ;;
+    esac
+    case "$n" in *[!0-9]*|"") return 0 ;; esac
+    n=$((10#$n))
+    [ "$n" -gt 0 ] || return 0
+    case "$unit" in m) n=$((n * 60)) ;; h) n=$((n * 3600)) ;; esac
+    printf '%s' "$n"
+}
+
 _route_json_str() {
     printf '%s' "$1" | tr '\n\t\r' '   ' | sed -e 's/\\/\\\\/g' -e 's/"/\\"/g'
 }
@@ -45,9 +74,9 @@ 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=()
+    R_E10_ARGS=(); R_CLEAN=(); R_ADAPTER=""; R_CAPDIFF=(); R_E10_CAP_S=""; R_DRY=0; R_MAXCOST=""
 
-    local a engine_req="" help=0 legacy_flag="" session_model="" provider_flag=""
+    local a engine_req="" dry=0 help=0 legacy_flag="" session_model="" provider_flag="" max_duration="" cap_err="" input_flag=""
     local -a positionals=() passthru=()
     local i=0 n=$#
     local -a argv=("$@")
@@ -73,15 +102,21 @@ loki_route_resolve() {
                     fi
                 fi
                 case "$name" in
-                    --prd) positionals+=("$val"); continue ;;
-                    --brief) positionals+=("$val"); continue ;;
+                    --prd|--brief) input_flag="$name"; 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 ;;
+                    --budget|--budget-limit|--max-cost) passthru+=(--max-cost "$val"); R_MAXCOST="$val"; continue ;;
+                    --dry-run) dry=1; continue ;;
                     --json) R_JSON=1; passthru+=(--json); continue ;;
                     -v) passthru+=(--verbose); continue ;;
                     --attempts) passthru+=(--attempts "$val"); continue ;;
                     --spec) passthru+=(--spec "$val"); continue ;;
+                    --max-duration)
+                        max_duration="$(_route_duration_s "$val")"
+                        if [ -z "$max_duration" ] && [ -z "$cap_err" ]; then
+                            cap_err="loki: --max-duration '$val' is not a duration (use seconds, or 90m / 2h)"
+                        fi
+                        continue ;;
                 esac
                 if _route_has "$_ROUTE_NOOP_FLAGS" "$name"; then continue; fi
                 if _route_has "$_ROUTE_E10_FLAGS" "$name"; then passthru+=("$name"); continue; fi
@@ -131,10 +166,10 @@ loki_route_resolve() {
             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 [ -n "$cap_err" ]; then R_ERR="$cap_err"; return 0; fi
     if [ "$R_INPUT_TYPE" = "missing-prd" ]; then
         R_ERR="loki: PRD file not found: ${positionals[0]}"
         return 0
@@ -177,19 +212,39 @@ loki_route_resolve() {
     if [ -n "$task" ]; then R_E10_ARGS+=("$task"); fi
     R_E10_ARGS+=("${passthru[@]+"${passthru[@]}"}")
 
+    # --prd and --brief name the input themselves; a second input would have glued its words into the task.
+    if [ -n "$input_flag" ] && [ "$npos" -gt 1 ]; then
+        R_ERR="loki: $input_flag cannot be combined with another input (${positionals[*]}); give one input"
+        return 0
+    fi
+    # A flag never changes the engine (#236): an unmapped one is refused, not routed to legacy.
+    if [ -n "$legacy_flag" ] && [ "$engine_req" != "legacy" ]; then
+        R_ERR="loki: flag $legacy_flag is not supported by the Loki 10 engine; $(_route_refusal_hint "$legacy_flag")"
+        return 0
+    fi
+    # Wall-clock cap: LOKI_E10_CAP_S seconds, bounded by the run-cap ceiling.
+    if [ -n "$max_duration" ] && [ "$engine_req" != "legacy" ]; then
+        R_E10_CAP_S="$max_duration"
+        if [ "$R_E10_CAP_S" -gt "$_ROUTE_CAP_CEILING_S" ]; then
+            R_E10_CAP_S="$_ROUTE_CAP_CEILING_S"
+            R_NOTICE="loki: --max-duration $max_duration s is above the engine10 run-cap ceiling; using ${_ROUTE_CAP_CEILING_S}s."
+        fi
+    fi
+    if [ -n "$provider_flag" ] && [ "$engine_req" != "legacy" ]; then
+        case "$provider_flag" in
+            claude|codex|cline|aider|opencode) ;;
+            *)
+                R_ERR="loki: --provider $provider_flag has no Loki 10 engine invoker (use claude, codex, cline, aider or opencode, or pass --engine legacy)"
+                return 0 ;;
+        esac
+    fi
+    # --dry-run (engine10 has no preview of its own for these inputs): print the route, then exit 0 without a run.
+    if [ "$dry" = "1" ] && [ "$engine_req" != "legacy" ]; then R_DRY=1; fi
     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) ;;
@@ -245,9 +300,9 @@ loki_route_print() {
         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' \
+        printf '{"engine":"%s","adapter":"%s","provider":"%s","model":"%s","input_type":"%s","input":"%s","reason":"%s","capability_differences":[%s],"run_cap_s":%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"
+            "$(_route_json_str "$R_INPUT_TYPE")" "$(_route_json_str "$shown")" "$(_route_json_str "$R_REASON")" "$diffs" "${R_E10_CAP_S:-null}"
     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"
@@ -296,6 +351,11 @@ loki_route_dispatch() {
     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 [ "$R_DRY" = "1" ]; then
+        loki_route_print
+        printf 'max-cost: %s\nrun-cap: %ss\ndry-run: nothing was started\n' "${R_MAXCOST:-default (engine10 resolves its own)}" "${R_E10_CAP_S:-$_ROUTE_CAP_CEILING_S}"
+        return 7
+    fi
     if [ -n "$R_NOTICE" ]; then echo "$R_NOTICE" >&2; fi
     R_VERB="$verb"
     return 0

package/autonomy/run.sh

@@ -20502,8 +20502,16 @@ check_budget_limit() {
     # Calculate cost from per-iteration efficiency files (same source as /api/cost)
     if [ -d "$efficiency_dir" ]; then
         current_cost=$(python3 -c "
-import json, glob
+import json, glob, os, sys
 total = 0.0
+# LOKI_INFERENCE_GEO multiplier on token-priced records, from the same JSON the
+# TS gate reads (autonomy/lib/efficiency_cost.py); the fallback keeps us at 1.1.
+try:
+    sys.path.insert(0, '${SCRIPT_DIR}/lib')
+    from efficiency_cost import inference_geo_multiplier
+    geo = inference_geo_multiplier()
+except Exception:
+    geo = 1.1 if os.environ.get('LOKI_INFERENCE_GEO', '').strip().lower() == 'us' else 1.0
 pricing = {
     'fable': {'input': 10.00, 'output': 50.00, 'cache_read': 0.25, 'cache_write': 12.5, 'cache_write_1h': 20},
     'claude-fable-5': {'input': 10.00, 'output': 50.00, 'cache_read': 0.25, 'cache_write': 12.5, 'cache_write_1h': 20},
@@ -20544,8 +20552,9 @@ for f in glob.glob('${efficiency_dir}/*.json'):
             # same run reports two different spends.
             cr = d.get('cache_read_tokens', 0) or 0
             cw = d.get('cache_creation_tokens', 0) or 0
-            total += (inp / 1_000_000) * p['input'] + (out / 1_000_000) * p['output']
-            total += (cr / 1_000_000) * p.get('cache_read', p['input'] * 0.1) + (cw / 1_000_000) * p.get('cache_write', p['input'] * 1.25)
+            rec = (inp / 1_000_000) * p['input'] + (out / 1_000_000) * p['output']
+            rec += (cr / 1_000_000) * p.get('cache_read', p['input'] * 0.1) + (cw / 1_000_000) * p.get('cache_write', p['input'] * 1.25)
+            total += rec * geo
     except: pass
 print(round(total, 4))
 " 2>/dev/null || echo "0")

package/autonomy/trigger-server.py

@@ -29,7 +29,7 @@ every /jobs request is rejected with 503 and an audit log line.
 Self-healing entry point: POST /sentry accepts a Sentry integration webhook
 authenticated by Sentry's own HMAC (sentry-hook-signature) under a THIRD,
 separate secret (LOKI_SENTRY_WEBHOOK_SECRET or SENTRY_CLIENT_SECRET). A valid
-alert enqueues `loki start "<normalized brief>" --pr --detach`: the output is a
+alert enqueues `loki start "<normalized brief>" --pr`: the output is a
 receipt-gated PR only, never a deploy. No secret means the route answers 503.
 
 Usage:
@@ -268,9 +268,9 @@ def constant_time_equals(a, b):
 
 
 # How long to wait for a dispatched `loki start` to finish before we stop
-# waiting on it. The child is launched detached (--detach) so it backgrounds
-# itself quickly; this bound only guards the worker thread against a wedged
-# launch. The child keeps running independently after we stop waiting.
+# waiting on it. The start runs in the foreground on the Loki 10 engine; this bound only
+# stops the worker thread waiting on a long run. The child keeps running and
+# is reaped in the background after we stop waiting.
 DISPATCH_WAIT_SECONDS = 30
 
 # Defaults for the bounded worker queue.
@@ -445,6 +445,32 @@ def send_notification(message):
         pass
 
 
+def _dispatch_log_paths():
+    """Fresh stdout and stderr log paths for one dispatch under .loki/triggers."""
+    paths = []
+    for suffix in (".out", ".err"):
+        fd, path = tempfile.mkstemp(prefix="dispatch-", suffix=suffix, dir=str(get_loki_dir()))
+        os.close(fd)
+        paths.append(path)
+    return paths
+
+
+def _read_bytes(path):
+    try:
+        with open(path, "rb") as f:
+            return f.read()
+    except OSError:
+        return b""
+
+
+def _remove_quietly(*paths):
+    for path in paths:
+        try:
+            os.unlink(path)
+        except OSError:
+            pass
+
+
 def _reap_child(proc):
     """Wait on a child process so it is always reaped (no zombie).
 
@@ -514,29 +540,34 @@ def run_loki_outcome(args, dry_run=False, stdout_sink=None, extra_env=None):
         logging.info("[DRY-RUN] Would run: %s", " ".join(cmd))
         return OUTCOME_PASSED
     logging.info("Running: %s", " ".join(cmd))
+    # Child output goes to per-run files, never a pipe: past the wait window
+    # nothing reads a pipe, so a child writing more than the ~64KB pipe buffer
+    # would block forever. The files double as the run log for a detached child.
+    out_path, err_path = _dispatch_log_paths()
     try:
-        proc = subprocess.Popen(
-            cmd,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            env=_scoped_child_env(extra_env),
-        )
+        with open(out_path, "wb") as out_f, open(err_path, "wb") as err_f:
+            proc = subprocess.Popen(
+                cmd,
+                stdout=out_f,
+                stderr=err_f,
+                env=_scoped_child_env(extra_env),
+            )
     except (FileNotFoundError, OSError) as e:
         logging.error("Failed to launch %s: %s", " ".join(cmd), e)
+        _remove_quietly(out_path, err_path)
         return OUTCOME_FAILED
 
     try:
-        stdout, stderr = proc.communicate(timeout=DISPATCH_WAIT_SECONDS)
-        if stdout_sink is not None:
-            stdout_sink.append((stdout or b"").decode("utf-8", errors="replace"))
+        proc.wait(timeout=DISPATCH_WAIT_SECONDS)
     except subprocess.TimeoutExpired:
         # Detached past the wait window. The reaper collects the child, but we
         # never see its exit code, so the outcome is genuinely UNKNOWN -- NOT a
         # pass. Reporting success here is exactly the defect this replaces.
         logging.info(
-            "Dispatch pid=%d still running after %ds; reaping in background",
+            "Dispatch pid=%d still running after %ds; reaping in background, output in %s",
             proc.pid,
             DISPATCH_WAIT_SECONDS,
+            out_path,
         )
         threading.Thread(
             target=_reap_child,
@@ -546,6 +577,12 @@ def run_loki_outcome(args, dry_run=False, stdout_sink=None, extra_env=None):
         ).start()
         return OUTCOME_UNKNOWN
 
+    stdout = _read_bytes(out_path)
+    stderr = _read_bytes(err_path)
+    _remove_quietly(out_path, err_path)
+    if stdout_sink is not None:
+        stdout_sink.append(stdout.decode("utf-8", errors="replace"))
+
     if proc.returncode == 0:
         logging.info("Dispatch pid=%d completed (exit 0)", proc.pid)
         return OUTCOME_PASSED
@@ -778,7 +815,7 @@ def tracker_comment_steer(kind, payload, is_live, dry_run=False):
 
 
 def handle_issues_event(payload, dry_run=False):
-    """Handle issues event: opened -> loki start <issue-ref> --pr --detach."""
+    """Handle issues event: opened -> loki start <issue-ref> --pr."""
     action = payload.get("action", "")
     if action != "opened":
         return None, "skipped (action=%s)" % action
@@ -801,7 +838,7 @@ def handle_issues_event(payload, dry_run=False):
     ref = str(issue_number)
     if repo_full_name:
         ref = "%s#%s" % (repo_full_name, issue_number)
-    args = ["start", ref, "--pr", "--detach"]
+    args = ["start", ref, "--pr"]
     summary = "issue #%s opened in %s" % (issue_number, repo_full_name)
     success = run_loki_command(args, dry_run=dry_run)
     status = "fired" if success else "error"
@@ -811,7 +848,7 @@ def handle_issues_event(payload, dry_run=False):
 
 
 def handle_pull_request_event(payload, dry_run=False):
-    """Handle pull_request event: synchronize -> loki start <pr-ref> --detach."""
+    """Handle pull_request event: synchronize -> loki start <pr-ref>."""
     action = payload.get("action", "")
     if action != "synchronize":
         return None, "skipped (action=%s)" % action
@@ -828,7 +865,7 @@ def handle_pull_request_event(payload, dry_run=False):
     ref = str(pr_number)
     if repo_full_name:
         ref = "%s#%s" % (repo_full_name, pr_number)
-    args = ["start", ref, "--detach"]
+    args = ["start", ref]
     summary = "PR #%s synchronized in %s" % (pr_number, repo_full_name)
     success = run_loki_command(args, dry_run=dry_run)
     status = "fired" if success else "error"
@@ -852,7 +889,7 @@ def handle_workflow_run_event(payload, dry_run=False):
     summary = "workflow '%s' failed in %s" % (wf_name, repo_full_name)
     # CI-failure context: re-run the current spec in the working directory so
     # the agent can repair the failing build. No issue/PR ref to attach here.
-    args = ["start", "--detach"]
+    args = ["start"]
     success = run_loki_command(args, dry_run=dry_run)
     status = "fired" if success else "error"
     if success:
@@ -862,14 +899,14 @@ def handle_workflow_run_event(payload, dry_run=False):
 
 def brief_start_args(brief):
     """argv for a delegated PR run. `--brief` forces brief mode so the text is
-    never reclassified as a PRD path or issue URL, and `--pr --detach` are only
+    never reclassified as a PRD path or issue URL, and `--pr` are only
     honored by `loki start` in brief mode because cmd_start routes them through
     the worktree + PR path."""
-    return ["start", "--brief", brief, "--pr", "--detach"]
+    return ["start", "--brief", brief, "--pr"]
 
 
 def handle_job_event(payload, dry_run=False):
-    """Handle a remotely-submitted job: loki start <spec> --detach.
+    """Handle a remotely-submitted job: loki start <spec>.
 
     Runs on the same worker pool as the webhook handlers. The spec was already
     validated by valid_spec() at admission; it is re-checked here so this
@@ -890,7 +927,7 @@ def handle_job_event(payload, dry_run=False):
     elif payload.get("pr") is True:
         args = brief_start_args(spec.strip())
     else:
-        args = ["start", spec.strip(), "--detach"]
+        args = ["start", spec.strip()]
     summary = "job %s: %s" % (payload.get("job_id", "?"), spec.strip())
     # A remote submitter gates CI on this, so report the BUILD's outcome, not
     # merely that a build was launched. "fired" (launched) and "passed" must
@@ -1338,7 +1375,7 @@ def build_sentry_brief(norm, payload=None):
 
 
 def handle_sentry_event(payload, dry_run=False):
-    """Handle a verified Sentry alert: loki start <brief> --pr --detach.
+    """Handle a verified Sentry alert: loki start <brief> --pr.
 
     PR only. Never passes a deploy argument: a fix still has to earn a VERIFIED
     receipt, and shipping it stays a separate, gated human step.
@@ -1535,7 +1572,7 @@ class Dispatcher:
         borrowed-receipt failure this design exists to prevent.
 
         Attribution is deliberately NOT resolved when the dispatch returns.
-        `loki start --detach` returns as soon as the child forks, while the
+        `loki start` can outlast the dispatch wait window, and the
         build runs for minutes and writes its receipt at the very end -- so a
         window closed at dispatch-return would always see an unchanged pointer
         and every real build would 404. Resolution happens lazily in

package/bin/loki

@@ -635,6 +635,7 @@ if [ -f "$REPO_ROOT/autonomy/route.sh" ] && { [ "$_LOKI_START_ATTEMPTS" != "1" ]
             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" ] && [ -n "${R_E10_CAP_S:-}" ]; then export LOKI_E10_CAP_S="$R_E10_CAP_S"; fi
         if [ "$R_E10" != "1" ]; then
             set -- "$([ "$R_VERB" = "bare" ] && echo start || echo "$R_VERB")" ${R_CLEAN[@]+"${R_CLEAN[@]}"}
         fi

package/dashboard/__init__.py

@@ -7,6 +7,6 @@ Modules:
     control: Session control helpers (status, atomic writes, origin check)
 """
 
-__version__ = "11.39.2"
+__version__ = "11.41.0"
 
 __all__ = ["__version__"]

package/dashboard/server.py

@@ -7830,6 +7830,25 @@ def _record_is_measured(rec: Any) -> bool:
     return False
 
 
+def _inference_geo_multiplier() -> float:
+    """LOKI_INFERENCE_GEO price multiplier. Mirrors inference_geo_multiplier() in
+    autonomy/lib/efficiency_cost.py (same JSON key, us falls back to 1.1); kept as
+    a local copy for the same reason as _MEASURED_FIELDS."""
+    geo = (os.environ.get("LOKI_INFERENCE_GEO") or "").strip().lower()
+    if not geo:
+        return 1.0
+    table = None
+    try:
+        path = _Path(__file__).resolve().parent.parent / "loki-ts" / "data" / "model-pricing.json"
+        table = json.loads(path.read_text()).get("inference_geo_multipliers")
+    except Exception:
+        table = None
+    if not isinstance(table, dict):
+        table = {"us": 1.1}
+    m = table.get(geo)
+    return float(m) if isinstance(m, (int, float)) and m > 0 else 1.0
+
+
 def _calculate_model_cost(
     model: str,
     input_tokens: int,
@@ -7856,7 +7875,9 @@ def _calculate_model_cost(
     output_cost = (output_tokens / 1_000_000) * pricing.get("output", 15.00)
     cache_read_cost = (cache_read_tokens / 1_000_000) * pricing.get("cache_read", inp_rate * 0.1)
     cache_write_cost = (cache_creation_tokens / 1_000_000) * pricing.get("cache_write", inp_rate * 1.25)
-    return round(input_cost + output_cost + cache_read_cost + cache_write_cost, 6)
+    return round(
+        (input_cost + output_cost + cache_read_cost + cache_write_cost) * _inference_geo_multiplier(), 6
+    )
 
 
 @app.get("/api/cost", dependencies=[Depends(auth.require_scope("read"))])

package/docs/CLI-REFERENCE.md

@@ -1,6 +1,6 @@
 # CLI reference
 
-Generated from `loki-ts/src/cli/registry.ts` by `scripts/generate-stale-zero.sh` for v11.39.2. Do not edit by hand.
+Generated from `loki-ts/src/cli/registry.ts` by `scripts/generate-stale-zero.sh` for v11.41.0. Do not edit by hand.
 Hidden and legacy-only commands are omitted; see `docs/v10/CLI-MODERN.md` for the full inventory.
 
 | Command | Description |

package/docs/DEPLOYMENT.md

@@ -119,9 +119,11 @@ logged and ignored.
 
 | Event | Action | What runs |
 |---|---|---|
-| `issues` | `opened` | `loki start owner/repo#N --pr --detach` |
-| `pull_request` | `synchronize` | `loki start owner/repo#N --detach` |
-| `workflow_run` | `completed` with `conclusion=failure` | `loki start --detach` |
+| `issues` | `opened` | `loki start owner/repo#N --pr` |
+| `pull_request` | `synchronize` | `loki start owner/repo#N` |
+| `workflow_run` | `completed` with `conclusion=failure` | `loki start` |
+
+The trigger server runs each of these starts in the foreground on the Loki 10 engine (Wall and VERIFIED apply). A run longer than the dispatch wait window is reaped in the background and its job status stays unknown until it exits.
 
 Note what is **not** there. Labelling an issue does nothing. Commenting on an
 issue does nothing. Opening a pull request does nothing -- for PRs it is

package/docs/INSTALLATION.md

@@ -2,7 +2,7 @@
 
 Loki Mode, by [Autonomi](https://www.autonomi.dev/), turns a spec or an issue into a verified pull request with a receipt you can check. This page covers installing it, a first run, and the options around it.
 
-**Version:** v11.39.2
+**Version:** v11.41.0
 
 **Engine note:** `loki start` is the primary command. `loki start`, `loki "<task>"`, `loki owner/repo#N` and `loki quick` all run the Loki 10 engine, whatever the flag order or input form (PRD file, issue ref, task or one-word brief). The previous loop runs only on `--engine legacy`, `LOKI_ENGINE=legacy`, or for one call when a flag Loki 10 cannot honor is present. See the [user guide](v10/GUIDE.md) and the [5-minute quickstart](QUICKSTART.md).
 

package/docs/KNOWN-ISSUES.md

@@ -4,7 +4,7 @@ Issues in the current release that are known and not yet fixed. Report new ones
 
 ## Which engine runs
 
-From 11.4.0, `loki start`, `loki "<task>"`, `loki owner/repo#N` and `loki quick` run the Loki 10 engine whatever the flag order or input form. The previous loop runs only on `--engine legacy`, `LOKI_ENGINE=legacy`, for a provider with no Loki 10 invoker, for a PRD over 100000 bytes, or for one call when a flag Loki 10 cannot honor is present (`--simple`, `--parallel`, `--sandbox`, ...). Check with `loki route start <args> --json`: it reports `engine`, `adapter`, `reason` and `capability_differences`. The full table is in the Routing contract section of `docs/exit-codes.md`.
+From 11.4.0, `loki start`, `loki "<task>"`, `loki owner/repo#N` and `loki quick` run the Loki 10 engine whatever the flag order or input form. The previous loop runs only on `--engine legacy`, `LOKI_ENGINE=legacy`, for a provider with no Loki 10 invoker, for a PRD over 100000 bytes, or never because of a flag: a flag Loki 10 cannot honor (`--simple`, `--sandbox`, `--ship`, `--worktree`, `--detach`, `--parallel`, ...) is refused with exit 2 and names its replacement, and `--engine legacy` keeps it. `--pr` is accepted (Loki 10 opens the PR by default), `--quiet` and `--resume` are honored, and `--dry-run` prints the route, max-cost and run cap without starting. Check with `loki route start <args> --json`: it reports `engine`, `adapter`, `reason` and `capability_differences`. The full table is in the Routing contract section of `docs/exit-codes.md`.
 
 ## Exit codes
 

package/docs/exit-codes.md

@@ -455,13 +455,10 @@ The table below is rendered from live `loki route --json` output by `tests/test-
 | `start p.md --provider cline` | engine10 | engine10:cline | 1 listed | default: prd input runs on engine10 regardless of flag order |
 | `start p.md --provider aider` | engine10 | engine10:aider | 1 listed | default: prd input runs on engine10 regardless of flag order |
 | `start p.md --provider opencode` | engine10 | engine10:opencode | 1 listed | default: prd input runs on engine10 regardless of flag order |
-| `start p.md --provider gemini` | legacy | legacy-bash:gemini | 2 listed | provider gemini has no engine10 invoker (use claude, codex, cline, aider or opencode) |
 | `start p.md --engine legacy` | legacy | legacy-bash:claude | 1 listed | explicit: --engine legacy or LOKI_ENGINE=legacy |
 | `start --engine legacy p.md` | legacy | legacy-bash:claude | 1 listed | explicit: --engine legacy or LOKI_ENGINE=legacy |
 | `LOKI_ENGINE=legacy start p.md` | legacy | legacy-bash:claude | 1 listed | explicit: --engine legacy or LOKI_ENGINE=legacy |
 | `start p.md --engine engine10` | engine10 | engine10:claude | none | explicit: --engine engine10 |
 | `LOKI_ENGINE=engine10 start p.md` | engine10 | engine10:claude | none | explicit: --engine engine10 |
-| `start p.md --parallel` | legacy | legacy-bash:claude | 2 listed | flag --parallel is not supported by engine10 |
-| `start --parallel p.md` | legacy | legacy-bash:claude | 2 listed | flag --parallel is not supported by engine10 |
 | `start big.md` | legacy | legacy-bash:claude | 1 listed | PRD is larger than 100000 bytes (engine10 takes the task as one argument) |
 <!-- route-table:end -->

package/docs/merge-queue.md

@@ -28,5 +28,5 @@ tail to a bounded repair session on the PR branch (LOKI_PR_REPAIR_CMD, default a
 argument), pushes, and re-checks, up to LOKI_PR_REPAIR_MAX attempts (default 2).
 Green goes through the same merge gate as `loki merge pr`. When attempts run out
 the PR is returned to draft, nothing merges, and the last failure log is printed.
-`loki start --ship` calls this after it opens the PR; `/merge watch <pr>` runs it
+`loki start --ship --engine legacy` calls this after it opens the PR; `/merge watch <pr>` runs it
 from `loki chat`.