loki-mode 7.28.2 → 7.30.0

package/autonomy/mcp-launch.sh

@@ -0,0 +1,282 @@
+#!/usr/bin/env bash
+# mcp-launch.sh -- launch the Loki Mode MCP server, bootstrapping its Python
+# dependencies on first run (task 562).
+#
+# Why this exists: a fresh `npm install -g loki-mode` ships mcp/server.py and
+# mcp/requirements.txt but installs NO Python packages and exposes only the
+# `loki` bin. So `python3 -m mcp.server` exits because the MCP SDK is absent.
+# `loki mcp` closes that gap: it checks for python3 + the MCP SDK, and when the
+# SDK is missing it offers a consent-gated bootstrap into a project-local
+# virtualenv (.loki/mcp-venv), then execs the server over stdio using THAT
+# venv's python so the SDK is actually importable.
+#
+# Design (least-invasive, honest):
+#   * Venv location: <user-cwd>/.loki/mcp-venv (the project Loki is invoked in,
+#     NOT the install root). Project-local, no global site-packages pollution,
+#     no sudo, no curl-pipe-bash, no root-owned writes under a global install.
+#     Removing the project's .loki fully uninstalls. Override with
+#     LOKI_MCP_VENV=/abs/path. Honors LOKI_DIR (defaults to .loki).
+#   * The server is launched with PYTHONPATH set to the install root (NOT by
+#     cd-ing into it) so the user's cwd is preserved: mcp/server.py resolves the
+#     project .loki from os.getcwd(). Without PYTHONPATH, `import mcp` from an
+#     arbitrary cwd resolves to the pip MCP SDK's own `mcp` package (zero Loki
+#     tools); PYTHONPATH puts the install root first so the LOCAL mcp/server.py
+#     wins, while server.py's namespace juggle still hands the real SDK its own
+#     `mcp.*` subtree.
+#   * The ONLY command run on the user's behalf is, after explicit consent:
+#       <venv>/bin/pip install -r mcp/requirements.txt
+#     The exact command is printed before it runs.
+#   * Non-interactive / CI: NEVER install. Print the manual command to stderr
+#     and exit 2 (mirrors autonomy/provider-offer.sh gate semantics).
+#   * Opt-out: LOKI_NO_INSTALL_OFFER=1 -> never prompt, print manual command,
+#     exit 2. --yes / LOKI_ASSUME_YES / LOKI_AUTO_CONFIRM=true -> auto-accept.
+#
+# Self-containment: depends only on bash builtins + python3 on PATH. Defines
+# its own colors so it behaves identically whether sourced by autonomy/loki or
+# run standalone.
+
+# Guard against double-source.
+if [ -n "${_LOKI_MCP_LAUNCH_SOURCED:-}" ]; then
+    return 0 2>/dev/null || true
+fi
+_LOKI_MCP_LAUNCH_SOURCED=1
+
+# --- Self-contained colors (honor NO_COLOR) --------------------------------
+if [ -n "${NO_COLOR:-}" ] || [ ! -t 1 ]; then
+    _ML_RED=''; _ML_YELLOW=''; _ML_BOLD=''; _ML_NC=''
+else
+    _ML_RED=$'\033[0;31m'
+    _ML_YELLOW=$'\033[1;33m'
+    _ML_BOLD=$'\033[1m'
+    _ML_NC=$'\033[0m'
+fi
+
+# Repo root = parent of the directory holding this script (autonomy/..).
+_ml_repo_root() {
+    local self_dir
+    self_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+    (cd "$self_dir/.." && pwd)
+}
+
+# _ml_assume_yes: true when the user opted into unattended confirmation.
+_ml_assume_yes() {
+    [ "${LOKI_ASSUME_YES:-}" = "1" ] && return 0
+    [ "${LOKI_AUTO_CONFIRM:-}" = "true" ] && return 0
+    return 1
+}
+
+# _ml_non_interactive: true when we must NEVER prompt (non-TTY or CI).
+_ml_non_interactive() {
+    [ ! -t 0 ] && return 0
+    [ ! -t 1 ] && return 0
+    [ -n "${CI:-}" ] && return 0
+    return 1
+}
+
+# _ml_python: echo the best base python3 for creating the venv, or empty.
+_ml_python() {
+    local p
+    for p in python3 python3.12 python3.11; do
+        if command -v "$p" >/dev/null 2>&1; then
+            printf '%s' "$p"
+            return 0
+        fi
+    done
+    return 1
+}
+
+# _ml_sdk_importable <python> <root>: true (0) only if the real MCP SDK's
+# FastMCP can actually be CONSTRUCTED -- not merely that the SDK files exist on
+# disk. A file-exists check is a false positive: under the local-vs-SDK `mcp`
+# namespace collision the package-dir FastMCP can be present yet fail to import
+# (`No module named 'mcp.types'`). We delegate to mcp/server.py's own
+# `--check-sdk` probe, which runs the exact loader the server uses and exits 0
+# only when FastMCP loaded.
+#
+# Critical: we set PYTHONPATH to the install root and DO NOT cd into it, so the
+# probe exercises the SAME module resolution as the real launch (which preserves
+# the user's cwd). The redirect of stdin from /dev/null is insurance: if the
+# pip SDK's own `mcp.server` were ever reached, its stub starts a stdio receive
+# loop; the EOF makes it exit instead of hanging.
+_ml_sdk_importable() {
+    local py="$1" root="$2"
+    PYTHONPATH="$root${PYTHONPATH:+:$PYTHONPATH}" \
+        "$py" -m mcp.server --check-sdk </dev/null >/dev/null 2>&1
+}
+
+# _ml_print_manual <root> <venv>: print the honest manual install commands.
+# The venv lives in the user's project (.loki/mcp-venv by default), while
+# requirements.txt is shipped under the install root.
+_ml_print_manual() {
+    local root="$1" venv="$2"
+    printf 'Install the MCP server dependencies manually:\n' >&2
+    printf '  python3 -m venv %s\n' "$venv" >&2
+    printf '  %s/bin/pip install -r %s/mcp/requirements.txt\n' "$venv" "$root" >&2
+    printf '  PYTHONPATH=%s %s/bin/python -m mcp.server\n' "$root" "$venv" >&2
+}
+
+_ml_help() {
+    cat <<'EOF'
+Loki Mode -- launch the MCP (Model Context Protocol) server
+
+Usage: loki mcp [--transport stdio|http] [--port N] [--help]
+
+Starts the Loki Mode MCP server so MCP-aware clients (Claude Code, IDEs)
+can call Loki's tools (memory, task queue, code search, build management).
+
+On first run, if the Python MCP SDK is not installed, Loki offers to create
+a project-local virtualenv at .loki/mcp-venv and install mcp/requirements.txt
+into it (with your consent). The exact pip command is printed before it runs.
+It then launches the server using that venv's python.
+
+Options:
+  --transport stdio|http  Transport to use (default: stdio).
+  --port N                Port for http transport (default: 8421).
+  --help, -h              Show this help and exit.
+
+Environment:
+  LOKI_MCP_VENV=/abs/path   Use a custom venv location instead of .loki/mcp-venv.
+  LOKI_NO_INSTALL_OFFER=1   Never prompt to install; print the manual command.
+  --yes / LOKI_ASSUME_YES=1 Auto-accept the dependency install.
+
+Behavior in non-interactive / CI shells: never installs. Prints the manual
+install command to stderr and exits 2.
+EOF
+}
+
+# mcp_launch_main: dispatcher invoked by cmd_mcp() (autonomy/loki) or directly.
+mcp_launch_main() {
+    # Parse only flags we own; everything else is forwarded to the server.
+    local arg
+    for arg in "$@"; do
+        case "$arg" in
+            --help|-h|help)
+                _ml_help
+                return 0
+                ;;
+        esac
+    done
+
+    local root
+    root="$(_ml_repo_root)"
+
+    # 1. python3 presence.
+    local base_py
+    if ! base_py="$(_ml_python)"; then
+        printf '%sNo python3 found on PATH.%s The MCP server needs Python 3.\n' "$_ML_RED" "$_ML_NC" >&2
+        printf 'Install Python 3 (https://www.python.org/downloads), then re-run: loki mcp\n' >&2
+        return 2
+    fi
+
+    # 2. venv location. Lives in the USER'S project (their cwd), NOT the install
+    #    root: $root may be a root-owned global npm prefix where we must never
+    #    write. LOKI_DIR (default .loki) keeps this consistent with every other
+    #    .loki artifact; LOKI_MCP_VENV overrides outright.
+    local venv="${LOKI_MCP_VENV:-$PWD/${LOKI_DIR:-.loki}/mcp-venv}"
+    local venv_py="$venv/bin/python"
+
+    # 3. If the venv already has the SDK, use it directly. The server is launched
+    #    with PYTHONPATH=$root (NOT by cd-ing) so the user's cwd is preserved for
+    #    .loki resolution; see _ml_sdk_importable for why.
+    #    Known narrow residual: if the user's cwd itself contains a Python
+    #    package literally named mcp/ with a server submodule, python -m puts
+    #    the cwd ahead of PYTHONPATH and that package wins. Essentially never
+    #    true for real projects; documented rather than fought.
+    if [ -x "$venv_py" ] && _ml_sdk_importable "$venv_py" "$root"; then
+        exec env PYTHONPATH="$root${PYTHONPATH:+:$PYTHONPATH}" "$venv_py" -m mcp.server "$@"
+    fi
+
+    # 4. If the BASE python already has the SDK (e.g. user pip-installed it),
+    #    use it -- no venv needed.
+    if _ml_sdk_importable "$base_py" "$root"; then
+        exec env PYTHONPATH="$root${PYTHONPATH:+:$PYTHONPATH}" "$base_py" -m mcp.server "$@"
+    fi
+
+    # 5. SDK missing. Decide whether we may bootstrap.
+    if [ "${LOKI_NO_INSTALL_OFFER:-}" = "1" ]; then
+        printf '%sMCP SDK not installed.%s\n' "$_ML_YELLOW" "$_ML_NC" >&2
+        _ml_print_manual "$root" "$venv"
+        return 2
+    fi
+
+    if _ml_non_interactive; then
+        printf '%sMCP SDK not installed%s and this is a non-interactive shell, so Loki will not install it automatically.\n' "$_ML_YELLOW" "$_ML_NC" >&2
+        _ml_print_manual "$root" "$venv"
+        return 2
+    fi
+
+    # 6. Interactive TTY: offer the consent-gated bootstrap.
+    local answer=""
+    if _ml_assume_yes; then
+        answer="y"
+    else
+        printf '\n'
+        printf 'The MCP server needs Python dependencies that are not installed.\n'
+        printf 'Loki can create a project-local virtualenv and install them:\n'
+        printf '  python3 -m venv %s\n' "$venv"
+        printf '  %s/bin/pip install -r %s/mcp/requirements.txt\n' "$venv" "$root"
+        printf '\n'
+        printf 'Nothing is installed globally and no sudo is used. Proceed? [Y/n] '
+        read -r answer || answer="n"
+    fi
+
+    case "$answer" in
+        ""|y|Y|yes|YES) ;;
+        *)
+            printf 'Skipped.\n'
+            _ml_print_manual "$root" "$venv"
+            return 2
+            ;;
+    esac
+
+    # 7. Create the venv if needed. Ensure the parent .loki exists in the user's
+    #    project first (never write under the install root).
+    if [ ! -x "$venv_py" ]; then
+        local venv_parent
+        venv_parent="$(dirname "$venv")"
+        if [ ! -d "$venv_parent" ] && ! mkdir -p "$venv_parent"; then
+            printf '%sCannot create %s (no write access).%s\n' "$_ML_RED" "$venv_parent" "$_ML_NC" >&2
+            _ml_print_manual "$root" "$venv"
+            return 2
+        fi
+        printf 'Creating virtualenv (%s) ...\n' "$venv"
+        if ! "$base_py" -m venv "$venv"; then
+            printf '%sFailed to create virtualenv at %s.%s\n' "$_ML_RED" "$venv" "$_ML_NC" >&2
+            _ml_print_manual "$root" "$venv"
+            return 2
+        fi
+    fi
+
+    # 8. Install requirements into the venv.
+    local req="$root/mcp/requirements.txt"
+    if [ ! -f "$req" ]; then
+        printf '%smcp/requirements.txt not found at %s.%s\n' "$_ML_RED" "$req" "$_ML_NC" >&2
+        return 2
+    fi
+    printf 'Installing MCP dependencies (%s/bin/pip install -r %s) ...\n' "$venv" "$req"
+    local code=0
+    "$venv/bin/pip" install -r "$req" || code=$?
+    if [ "$code" -ne 0 ]; then
+        printf '%sInstall failed (pip exited %s).%s You can retry manually:\n' "$_ML_RED" "$code" "$_ML_NC" >&2
+        _ml_print_manual "$root" "$venv"
+        return 2
+    fi
+
+    # 9. Verify, then exec the server using the venv python (critical: the
+    #    site-packages walk in server.py only finds the SDK if we run the
+    #    venv's interpreter, not the ambient python3). PYTHONPATH=$root keeps the
+    #    user's cwd intact for .loki resolution; see _ml_sdk_importable.
+    if ! _ml_sdk_importable "$venv_py" "$root"; then
+        printf '%sDependencies installed but the MCP SDK still is not importable.%s\n' "$_ML_RED" "$_ML_NC" >&2
+        _ml_print_manual "$root" "$venv"
+        return 2
+    fi
+    printf "%sMCP dependencies ready. Launching server over stdio ...%s\n" "$_ML_BOLD" "$_ML_NC" >&2
+    exec env PYTHONPATH="$root${PYTHONPATH:+:$PYTHONPATH}" "$venv_py" -m mcp.server "$@"
+}
+
+# Executed directly (tests, manual): run the dispatcher.
+# When sourced by autonomy/loki, this block does not run.
+if [ "${BASH_SOURCE[0]}" = "$0" ]; then
+    mcp_launch_main "$@"
+fi

package/autonomy/provider-offer.sh

@@ -0,0 +1,249 @@
+#!/usr/bin/env bash
+# provider-offer.sh -- shared, self-contained provider install offer (v7.29.0).
+#
+# Single source of truth for "no AI provider CLI found" handling, used by BOTH
+# the bash CLI (autonomy/loki, sourced) and the Bun-routed doctor
+# (loki-ts/src/commands/doctor.ts, via child_process). Parity is by
+# construction: there is exactly one prompt + npm install + login handoff
+# implementation, and both routes call it.
+#
+# Self-containment contract (load-bearing for parity): this file depends ONLY
+# on bash builtins + npm/claude on PATH. It defines its own colors and never
+# reads $RED/$NC or any other variable owned by autonomy/loki, because when
+# doctor.ts spawns it standalone those variables are unset. If this file ever
+# starts depending on loki's environment, the bash-route and Bun-route bytes
+# diverge and the bun-parity matrix breaks.
+#
+# Security posture (design 1.7): the ONLY command ever executed on the user's
+# behalf is `npm install -g @anthropic-ai/claude-code`, only after explicit
+# consent, with the exact command printed first. No sudo. No curl-pipe-bash.
+# Non-interactive / CI contexts never run an install.
+
+# Guard against double-source (loki may source this more than once via reloads).
+if [ -n "${_LOKI_PROVIDER_OFFER_SOURCED:-}" ]; then
+    return 0 2>/dev/null || true
+fi
+_LOKI_PROVIDER_OFFER_SOURCED=1
+
+# --- Self-contained colors (honor NO_COLOR; no dependency on loki) ----------
+if [ -n "${NO_COLOR:-}" ] || [ ! -t 1 ]; then
+    _PO_RED=''; _PO_YELLOW=''; _PO_BOLD=''; _PO_DIM=''; _PO_NC=''
+else
+    _PO_RED=$'\033[0;31m'
+    _PO_YELLOW=$'\033[1;33m'
+    _PO_BOLD=$'\033[1m'
+    _PO_NC=$'\033[0m'
+fi
+
+# The one canonical install command. Quoted everywhere; never re-derived.
+_PO_INSTALL_CMD="npm install -g @anthropic-ai/claude-code"
+
+# detect_any_provider: true (0) if any supported provider CLI is on PATH.
+# Extracted verbatim from the loki doctor detection loop (design 1.2).
+detect_any_provider() {
+    local _dp
+    for _dp in claude codex cline aider; do
+        command -v "$_dp" >/dev/null 2>&1 && return 0
+    done
+    return 1
+}
+
+# _po_assume_yes: true when the user has opted into unattended confirmation.
+# Honors --yes (LOKI_AUTO_CONFIRM, set by loki:1013) and LOKI_ASSUME_YES.
+_po_assume_yes() {
+    [ "${LOKI_ASSUME_YES:-}" = "1" ] && return 0
+    [ "${LOKI_AUTO_CONFIRM:-}" = "true" ] && return 0
+    return 1
+}
+
+# _po_non_interactive: true when we must NEVER prompt (non-TTY or CI).
+# Mirrors cmd_welcome_maybe_firstrun (loki:4286) and maybe_show_auto_plan.
+_po_non_interactive() {
+    [ ! -t 1 ] && return 0
+    [ ! -t 0 ] && return 0
+    [ -n "${CI:-}" ] && return 0
+    return 1
+}
+
+# _po_run_login: offer (or auto-accept) the claude auth login handoff after a
+# successful install. Inherited stdio; Loki never handles credentials.
+_po_run_login() {
+    # claude must actually be on PATH for login to make sense.
+    if ! command -v claude >/dev/null 2>&1; then
+        printf "%sInstalled, but 'claude' is not on your PATH yet. You may need to restart your shell or add npm's global bin to PATH (npm config get prefix). Run 'loki doctor' to recheck.%s\n" "$_PO_YELLOW" "$_PO_NC"
+        return 0
+    fi
+
+    local do_login=""
+    if _po_assume_yes; then
+        do_login="y"
+    else
+        printf 'Claude Code installed.\n'
+        printf '\n'
+        printf 'You still need to authenticate. Run the login flow now? [Y/n] '
+        read -r do_login || do_login="n"
+    fi
+    case "$do_login" in
+        ""|y|Y|yes|YES)
+            if claude auth login; then
+                # Do not trust the exit code alone: verify the session is
+                # actually authenticated before claiming readiness (council
+                # HIGH: the old path could falsely report success).
+                if claude auth status 2>/dev/null | grep -q '"loggedIn"[[:space:]]*:[[:space:]]*true'; then
+                    printf "%sProvider ready. Run 'loki doctor' to confirm, or 'loki quickstart' to build.%s\n" "$_PO_BOLD" "$_PO_NC"
+                    return 0
+                fi
+                printf "Login finished but authentication could not be confirmed. Run 'claude auth status' to check, then 'loki doctor'.\n"
+                return 0
+            fi
+            printf "Login not completed. Run 'claude auth login' when ready, then 'loki doctor'.\n"
+            return 0
+            ;;
+        *)
+            printf "Login not completed. Run 'claude auth login' when ready, then 'loki doctor'.\n"
+            return 0
+            ;;
+    esac
+}
+
+# _po_do_install: run the one consented command, print it first, handle result.
+# Returns 0 on success, non-zero on failure (caller decides exit behavior).
+_po_do_install() {
+    printf 'Installing Claude Code (%s) ...\n' "$_PO_INSTALL_CMD"
+    # The exact, fixed argv. No interpolation, no extra flags. (design 1.7)
+    # Capture npm's exit code directly (not via `if`, whose statement status is
+    # 0 when the condition is false with no else, masking the real npm code).
+    local code=0
+    npm install -g @anthropic-ai/claude-code || code=$?
+    if [ "$code" -eq 0 ]; then
+        printf '\n'
+        _po_run_login
+        return 0
+    fi
+    printf '%sInstall failed (npm exited %s). You can retry manually:%s\n' "$_PO_RED" "$code" "$_PO_NC"
+    printf '  %s\n' "$_PO_INSTALL_CMD"
+    printf 'If this is a permissions error, see https://docs.npmjs.com/resolving-eacces-permissions-errors\n'
+    return "$code"
+}
+
+# offer_provider_install <mode>
+#   mode = "report"  -> doctor: append the offer on a TTY; on non-TTY/CI do
+#                       NOTHING (doctor already printed the FAIL + install line,
+#                       and we must keep non-TTY/json bytes identical for parity).
+#                       Never exits the process.
+#   mode = "gate"    -> start/demo/quick pre-flight: on non-TTY/CI print the
+#                       honest one-liner to stderr and return 2. On a TTY, prompt;
+#                       on decline return 2. On accept install + login.
+#
+# Honors:
+#   LOKI_NO_INSTALL_OFFER=1  -> never prompt; print manual command (1.4)
+#   --yes / LOKI_ASSUME_YES  -> auto-accept install + login (1.4)
+offer_provider_install() {
+    local mode="${1:-gate}"
+
+    # Opt-out: never offer, just surface the manual command.
+    if [ "${LOKI_NO_INSTALL_OFFER:-}" = "1" ]; then
+        if [ "$mode" = "gate" ]; then
+            printf 'No AI provider CLI found. Install one when ready:\n' >&2
+            printf '  %s   (then: claude auth login)\n' "$_PO_INSTALL_CMD" >&2
+            return 2
+        fi
+        printf '\n'
+        printf 'Install a provider when ready:\n'
+        printf '  %s   (then: claude auth login)\n' "$_PO_INSTALL_CMD"
+        printf '  Other supported providers: codex, cline, aider.\n'
+        return 0
+    fi
+
+    # Non-interactive / CI: NEVER prompt, NEVER install.
+    #
+    # gate (start/demo/quick): print the honest one-liner to stderr and return 2
+    #   so the caller exits with an actionable message before any spend.
+    # report (doctor): stay SILENT. doctor has already printed the FAIL line and
+    #   the install command on stdout, so no information is lost. Silence here is
+    #   load-bearing for parity: doctor.ts gates its child_process bridge on
+    #   process.stdout.isTTY, so on a non-TTY/CI run the Bun route emits nothing
+    #   extra. If report-mode printed a stderr line, the bash route would diverge
+    #   from Bun in exactly the no-provider/non-TTY case the bun-parity matrix
+    #   captures (2>&1) on CI runners, which have no provider installed.
+    if _po_non_interactive; then
+        if [ "$mode" = "gate" ]; then
+            printf 'No AI provider CLI found; cannot prompt to install in a non-interactive shell. Run: %s\n' "$_PO_INSTALL_CMD" >&2
+            return 2
+        fi
+        return 0
+    fi
+
+    # npm missing: degraded path, never attempt a non-npm install.
+    if ! command -v npm >/dev/null 2>&1; then
+        printf '\n'
+        printf '%sNo AI provider CLI was found, and npm is not installed either, so Loki%s\n' "$_PO_BOLD" "$_PO_NC"
+        printf 'cannot install one for you.\n'
+        printf '\n'
+        printf 'Install Node.js + npm first (https://nodejs.org), then run:\n'
+        printf '  %s\n' "$_PO_INSTALL_CMD"
+        printf '  claude auth login\n'
+        printf '\n'
+        printf "Already have a provider via another method? Make sure 'claude' (or codex,\n"
+        printf "cline, aider) is on your PATH, then run 'loki doctor'.\n"
+        [ "$mode" = "gate" ] && return 2
+        return 0
+    fi
+
+    # TTY, npm present: the interactive offer.
+    printf '\n'
+    printf 'No AI provider CLI was found. Loki needs one agent CLI to run a build.\n'
+    printf '\n'
+    printf 'Claude Code is the recommended provider (full feature support).\n'
+    printf '  Install:  %s\n' "$_PO_INSTALL_CMD"
+    printf '  Then:     claude auth login\n'
+    printf '\n'
+
+    local answer=""
+    if _po_assume_yes; then
+        answer="y"
+    else
+        printf 'Install Claude Code now? [Y/n] '
+        read -r answer || answer="n"
+    fi
+
+    case "$answer" in
+        ""|y|Y|yes|YES)
+            if _po_do_install; then
+                return 0
+            fi
+            # Install failed: honest failure already printed by _po_do_install.
+            [ "$mode" = "gate" ] && return 2
+            return 1
+            ;;
+        *)
+            printf 'Skipped. Install a provider when ready:\n'
+            printf '  %s   (then: claude auth login)\n' "$_PO_INSTALL_CMD"
+            printf 'Other supported providers: codex, cline, aider.\n'
+            [ "$mode" = "gate" ] && return 2
+            return 0
+            ;;
+    esac
+}
+
+# provider_offer_gate: convenience wrapper for the start/demo/quick pre-flight.
+# Returns 0 if a provider is present (or one was just installed); returns 2 to
+# signal the caller should `exit 2` (no provider, declined or non-interactive).
+provider_offer_gate() {
+    detect_any_provider && return 0
+    offer_provider_install gate || return 2
+    # After an accepted install, re-detect; if still absent, fail the gate.
+    detect_any_provider && return 0
+    return 2
+}
+
+# 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
+    case "${1:-report}" in
+        offer|report) offer_provider_install report ;;
+        gate)         offer_provider_install gate ;;
+        detect)       detect_any_provider ;;
+        *)            offer_provider_install report ;;
+    esac
+fi