loki-mode 11.39.3 → 11.40.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.3
+# Loki Mode v11.40.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.3 | [Autonomi](https://www.autonomi.dev/) flagship product | core skill**
+**v11.40.0 | [Autonomi](https://www.autonomi.dev/) flagship product | core skill**

package/VERSION

@@ -1 +1 @@
-11.39.3
+11.40.0

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/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.3"
+__version__ = "11.40.0"
 
 __all__ = ["__version__"]

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.3. Do not edit by hand.
+Generated from `loki-ts/src/cli/registry.ts` by `scripts/generate-stale-zero.sh` for v11.40.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.3
+**Version:** v11.40.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`.

package/docs/sentry-intake.md

@@ -18,7 +18,7 @@ The token is sent only to the Sentry host through a curl config on stdin, never
 
 1. Set the client secret: `LOKI_SENTRY_WEBHOOK_SECRET` (or `SENTRY_CLIENT_SECRET`). It must differ from the GitHub webhook secret and the API token. With no secret the route answers 503 and nothing is enqueued.
 2. Start the server: `python3 autonomy/trigger-server.py --port 8080` and point the Sentry alert webhook at `/sentry`.
-3. A valid alert is normalized with `normalize_sentry_json` and enqueues `loki start "<brief>" --pr --detach`. A bad signature gets 401.
+3. A valid alert is normalized with `normalize_sentry_json` and enqueues `loki start "<brief>" --pr`. A bad signature gets 401.
 
 The brief also carries the event's release and environment, the newest `.loki/deploys` record (`last deploy <sha7> <finished_at> health=<status>`) and, when the culprit file resolves inside the project, its last `git log -1` author. All of it is sanitized to one line and capped; it adds no authority.
 
@@ -35,30 +35,30 @@ Slack (`POST /slack`):
 
 1. Set `SLACK_SIGNING_SECRET`. Point a `/loki` slash command (and Events URL verification) at `/slack`.
 2. The signature is `v0=` + hex HMAC-SHA256 over `v0:<X-Slack-Request-Timestamp>:<raw body>`, window 300s, the same contract as `loki-ts/src/contrib/slack_inbound.ts`. Bad, stale or missing signature: 401, nothing queued.
-3. The command text is the spec (one line, not starting with `-`) and runs as `loki start <text> --detach`. Slack gets an ephemeral reply carrying the job id.
+3. The command text is the spec (one line, not starting with `-`) and runs as `loki start <text>`. Slack gets an ephemeral reply carrying the job id.
 4. On completion the summary is posted to the request's `response_url`, only if it starts with `https://hooks.slack.com/`. Any other host is never contacted.
 
 Linear (`POST /linear`):
 
 1. Set `LINEAR_WEBHOOK_SECRET`. Point a Linear issue webhook at `/linear`.
 2. `Linear-Signature` is the hex HMAC-SHA256 of the raw body, and the signed `webhookTimestamp` must be within 300s. Otherwise 401.
-3. A created issue enqueues `loki start linear:<identifier> --detach` and answers 202 with the job id. Other events are skipped.
+3. A created issue enqueues `loki start linear:<identifier>` and answers 202 with the job id. Other events are skipped.
 4. If `LINEAR_API_KEY` is set, a comment with the result is posted on the issue through `https://api.linear.app/graphql`. Without it nothing is posted.
 
 Jira (`POST /jira`):
 
 1. Set `JIRA_WEBHOOK_SECRET` (the secret on a Jira Cloud webhook) and point the webhook at `/jira`. Set `JIRA_ASSIGNEES` (comma-separated accountId, email or display name) and/or `JIRA_LABELS`. With neither set, every event is skipped.
 2. `X-Hub-Signature` is `sha256=` + hex HMAC-SHA256 of the raw body. Bad or missing signature: 401. Jira signs no timestamp and the `X-Atlassian-Webhook-Identifier` header is not covered by the HMAC, so replay is bounded two ways: a repeated delivery id, or a repeated signed body (sha256 of the raw body, so changing or dropping the header does not help), answers `duplicate` and queues nothing. A replay of a body Jira never sent twice still needs the secret to forge.
-3. `jira:issue_created`, or `jira:issue_updated` whose changelog touches assignee or labels, runs only when the issue is assigned to a configured user or has a configured label. The key, summary and description are folded into a one-line brief (1500 bytes max; an Atlassian Document Format description is flattened to its text) and run as `loki start --brief "<brief>" --pr --detach`. Answers 202 with the job id.
+3. `jira:issue_created`, or `jira:issue_updated` whose changelog touches assignee or labels, runs only when the issue is assigned to a configured user or has a configured label. The key, summary and description are folded into a one-line brief (1500 bytes max; an Atlassian Document Format description is flattened to its text) and run as `loki start --brief "<brief>" --pr`. Answers 202 with the job id.
 
 Teams (`POST /teams`):
 
 1. Set `TEAMS_SECURITY_TOKEN` (the base64 token Teams shows when you create the outgoing webhook) and point the webhook at `/teams`.
 2. `Authorization: HMAC <base64>` is the base64 HMAC-SHA256 of the raw body keyed by the base64-decoded token. Bad signature: 401. The activity `timestamp` must be within 300s; a stale or missing one is refused with 401.
-3. The message text (with `<at>` mentions and tags removed) is the brief and runs as `loki start --brief "<brief>" --pr --detach`. Teams gets a synchronous reply whose text starts with "Queued" and ends with the job id. A repeated activity id is not queued twice.
+3. The message text (with `<at>` mentions and tags removed) is the brief and runs as `loki start --brief "<brief>" --pr`. Teams gets a synchronous reply whose text starts with "Queued" and ends with the job id. A repeated activity id is not queued twice.
 
 Jira completion comments: set `JIRA_BASE_URL` (https only), `JIRA_EMAIL` and `JIRA_API_TOKEN`; the result is then posted as a comment on the issue that triggered the run. Without all three nothing is posted, and `JIRA_API_TOKEN` never reaches the `loki start` child environment.
 
-Jira and Teams runs are receipt-gated PR runs only: the server always passes `--pr` and never a deploy argument, so shipping stays a separate gated step. `--brief` forces brief mode, so text that ends in `.md` or contains an issue URL is never reclassified, and `loki start --brief ... --pr/--worktree/--detach` runs in an isolated worktree, detached, and opens a PR carrying the Evidence Receipt (the same machinery as `loki start <issue>`). Sentry alerts use the same form. Neither secret reaches the `loki start` child environment, and both must differ from every other credential. A missing secret answers 503 naming the variable.
+Jira and Teams runs are receipt-gated PR runs only: the server always passes `--pr` and never a deploy argument, so shipping stays a separate gated step. `--brief` forces brief mode, so text that ends in `.md` or contains an issue URL is never reclassified, and `loki start --brief ... --pr` runs on the Loki 10 engine, which opens a PR carrying the Evidence Receipt (the same machinery as `loki start <issue>`). Sentry alerts use the same form. The server never passes `--detach` and never sets `LOKI_ENGINE`, so every webhook start gets the Wall and VERIFIED. Neither secret reaches the `loki start` child environment, and both must differ from every other credential. A missing secret answers 503 naming the variable.
 
 Reply targets are stored server side keyed by job id, captured only after verification. Notifier errors are logged and never fail the job. Poll status with `GET /jobs/<id>`.