#!/usr/bin/env bash # shellcheck disable=SC2034 # Many variables are used by sourced scripts # shellcheck disable=SC2155 # Declare and assign separately (acceptable in this codebase) # shellcheck disable=SC2329 # Functions may be invoked indirectly or via dynamic dispatch # shellcheck disable=SC2086 # Word splitting is intentional in some contexts #=============================================================================== # Loki Mode - Autonomous Runner # Single script that handles prerequisites, setup, and autonomous execution # # Usage: # ./autonomy/run.sh [OPTIONS] [PRD_PATH] # ./autonomy/run.sh ./docs/requirements.md # ./autonomy/run.sh # Interactive mode # ./autonomy/run.sh --parallel # Parallel mode with git worktrees # ./autonomy/run.sh --parallel ./prd.md # Parallel mode with PRD # # Environment Variables: # LOKI_PROVIDER - AI provider: claude (default), codex, cline, aider # LOKI_MAX_RETRIES - Max retry attempts (default: 50) # LOKI_BASE_WAIT - Base wait time in seconds (default: 60) # LOKI_MAX_WAIT - Max wait time in seconds (default: 3600) # LOKI_SKIP_PREREQS - Skip prerequisite checks (default: false) # LOKI_DASHBOARD - Enable web dashboard (default: true) # LOKI_DASHBOARD_PORT - Dashboard port (default: 57374) # LOKI_TLS_CERT - Path to PEM certificate (enables HTTPS for dashboard) # LOKI_TLS_KEY - Path to PEM private key (enables HTTPS for dashboard) # # Resource Monitoring (prevents system overload): # LOKI_RESOURCE_CHECK_INTERVAL - Check resources every N seconds (default: 300 = 5min) # LOKI_RESOURCE_CPU_THRESHOLD - CPU % threshold to warn (default: 80) # LOKI_RESOURCE_MEM_THRESHOLD - Memory % threshold to warn (default: 80) # # Budget / Cost Limits (opt-in): # LOKI_BUDGET_LIMIT - Max USD spend before auto-pause (default: empty = unlimited) # Example: "50.00" pauses session when estimated cost >= $50 # # Security & Autonomy Controls (Enterprise): # LOKI_STAGED_AUTONOMY - Require approval before execution (default: false) # LOKI_AUDIT_LOG - Enable audit logging (default: true) # LOKI_AUDIT_DISABLED - Disable audit logging (default: false) # LOKI_MAX_PARALLEL_AGENTS - Limit concurrent agent spawning (default: 10) # LOKI_SANDBOX_MODE - Run in sandboxed container (default: false, requires Docker) # LOKI_ALLOWED_PATHS - Comma-separated path allowlist. PARTIAL enforcement # (honest scope): when set, run.sh rejects a sandbox # custom --mount whose host path is outside the # allowlist (a write surface run.sh itself controls). # It does NOT and CANNOT restrict provider-driven # agent file writes: claude/codex/cline/aider write # files directly, not through run.sh, so run.sh never # sees those writes. The containment for agent writes # is the OS user + the LOKI_SANDBOX_MODE container # (cap-drop, seccomp, read-only mounts), not this var. # Treat ALLOWED_PATHS as defense-in-depth on the # mount surface, not a complete write sandbox. # LOKI_BLOCKED_COMMANDS - Comma-separated blocked shell commands (default: rm -rf /) # # OIDC / SSO Authentication (optional, works alongside token auth): # LOKI_OIDC_ISSUER - OIDC issuer URL (e.g., https://accounts.google.com) # LOKI_OIDC_CLIENT_ID - OIDC client/application ID # LOKI_OIDC_AUDIENCE - Expected JWT audience (default: same as client_id) # # SDLC Phase Controls (all enabled by default, set to 'false' to skip): # LOKI_PHASE_UNIT_TESTS - Run unit tests (default: true) # LOKI_PHASE_API_TESTS - Functional API testing (default: true) # LOKI_PHASE_E2E_TESTS - E2E/UI testing with Playwright (default: true) # LOKI_PHASE_SECURITY - Security scanning OWASP/auth (default: true) # LOKI_PHASE_INTEGRATION - Integration tests SAML/OIDC/SSO (default: true) # LOKI_PHASE_CODE_REVIEW - 3-reviewer parallel code review (default: true) # LOKI_PHASE_WEB_RESEARCH - Competitor/feature gap research (default: true) # LOKI_PHASE_PERFORMANCE - Load/performance testing (default: true) # LOKI_PHASE_ACCESSIBILITY - WCAG compliance testing (default: true) # LOKI_PHASE_REGRESSION - Regression testing (default: true) # LOKI_PHASE_UAT - UAT simulation (default: true) # # Autonomous Loop Controls (Ralph Wiggum Mode): # LOKI_COMPLETION_PROMISE - EXPLICIT stop condition text (default: none - runs forever) # Example: "ALL TESTS PASSING 100%" # Only stops when the AI provider outputs this EXACT text # LOKI_MAX_ITERATIONS - Max loop iterations before exit (default: 1000) # LOKI_PERPETUAL_MODE - Ignore ALL completion signals (default: false) # Set to 'true' for truly infinite operation # # Completion Council (v5.25.0) - Multi-agent completion verification: # LOKI_COUNCIL_ENABLED - Enable completion council (default: true) # LOKI_COUNCIL_SIZE - Number of council members (default: 3) # LOKI_COUNCIL_THRESHOLD - Votes needed for completion (default: 2) # LOKI_COUNCIL_CHECK_INTERVAL - Check every N iterations (default: 5) # LOKI_COUNCIL_MIN_ITERATIONS - Min iterations before council runs (default: 3) # LOKI_COUNCIL_STAGNATION_LIMIT - Max iterations with no git changes (default: 5) # # Model Selection: # LOKI_ALLOW_HAIKU - Enable Haiku model for fast tier (default: false) # When false: Opus for dev/bugfix, Sonnet for tests/docs # When true: Sonnet for dev, Haiku for tests/docs (original) # Use --allow-haiku flag or set to 'true' # # 2026 Research Enhancements: # LOKI_PROMPT_REPETITION - Enable prompt repetition for Haiku agents (default: true) # arXiv 2512.14982v1: Improves accuracy 4-5x on structured tasks # LOKI_CONFIDENCE_ROUTING - Enable confidence-based routing (default: true) # HN Production: 4-tier routing (auto-approve, direct, supervisor, escalate) # LOKI_AUTONOMY_MODE - Autonomy level (default: perpetual) # Options: perpetual, checkpoint, supervised # Tim Dettmers: "Shorter bursts of autonomy with feedback loops" # # Parallel Workflows (Git Worktrees): # LOKI_PARALLEL_MODE - Enable git worktree-based parallelism (default: false) # Use --parallel flag or set to 'true' # LOKI_MAX_WORKTREES - Maximum parallel worktrees (default: 5) # LOKI_MAX_PARALLEL_SESSIONS - Maximum concurrent AI sessions (default: 3) # LOKI_PARALLEL_TESTING - Run testing stream in parallel (default: true) # LOKI_PARALLEL_DOCS - Run documentation stream in parallel (default: true) # LOKI_PARALLEL_BLOG - Run blog stream if site has blog (default: false) # LOKI_AUTO_MERGE - Auto-merge completed features (default: true) # # Complexity Tiers (Auto-Claude pattern): # LOKI_COMPLEXITY - Force complexity tier (default: auto) # Options: auto, simple, standard, complex # Simple (3 phases): 1-2 files, single service, UI fixes, text changes # Standard (6 phases): 3-10 files, 1-2 services, features, bug fixes # Complex (8 phases): 10+ files, multiple services, external integrations # # GitHub Integration (v4.1.0): # LOKI_GITHUB_IMPORT - Import open issues as tasks (default: false) # LOKI_GITHUB_PR - Create PR when feature complete (default: false) # LOKI_GITHUB_SYNC - Sync status back to issues (default: false) # LOKI_GITHUB_REPO - Override repo detection (default: from git remote) # LOKI_GITHUB_LABELS - Filter by labels (comma-separated) # LOKI_GITHUB_MILESTONE - Filter by milestone # LOKI_GITHUB_ASSIGNEE - Filter by assignee # LOKI_GITHUB_LIMIT - Max issues to import (default: 100) # LOKI_GITHUB_PR_LABEL - Label for PRs (default: none, avoids error if label missing) # # Desktop Notifications (v4.1.0): # LOKI_NOTIFICATIONS - Enable desktop notifications (default: true) # LOKI_NOTIFICATION_SOUND - Play sound with notifications (default: true) # # Uncertainty-Gated Escalation (v7.19.2, default-on): # LOKI_UNCERTAINTY_ESCALATION - Master on/off for proactive stuck-escalation (default: 1; set 0 to # disable; byte-identical when off). Decision lives in # completion-council.sh (uncertainty_should_escalate); action in run.sh. # NOTE: AUTONOMY_MODE defaults to "perpetual"; in perpetual mode PAUSE # is auto-cleared by check_human_intervention, so escalation degrades # to notify-only (notification fires, run does NOT halt). # LOKI_UNCERTAINTY_ROUNDS - Consecutive rounds where >=2 of 3 proxies must co-occur before # escalating (default: 2; recommended range 2-3). Debounces transient # noise: a single hot proxy never escalates alone. # LOKI_UNCERTAINTY_NOCHANGE_MIN - Proxy 1 threshold: consecutive_no_change value that marks p1 hot. # (default: COUNCIL_STAGNATION_LIMIT - 1, i.e. one below the circuit- # breaker limit so escalation fires before the breaker ends the run). # Floored at 1 at runtime. # LOKI_UNCERTAINTY_SPLIT_ROUNDS - Proxy 3 threshold: number of consecutive trailing council verdicts # that must be REJECTED-with-approver (split) to mark p3 hot # (default: 2). Between council votes p3 may be stale; it is always # fresh when proxy 1 is hot because proxy 1 hot forces a circuit- # breaker vote that refreshes verdicts. # # Human Intervention (Auto-Claude pattern): # PAUSE file: touch .loki/PAUSE - pauses after current session # HUMAN_INPUT.md: echo "instructions" > .loki/HUMAN_INPUT.md # STOP file: touch .loki/STOP - stops immediately # Ctrl+C (once): Pauses execution, shows options # Ctrl+C (twice): Exits immediately # # Security (Enterprise): # LOKI_PROMPT_INJECTION - Enable HUMAN_INPUT.md processing (default: false) # Set to "true" only in trusted environments # # Branch Protection (agent isolation): # LOKI_BRANCH_PROTECTION - Create feature branch for agent changes (default: true) # Agent works on loki/session-- branch # Set to "false" to opt out and work on the current branch # LOKI_AUTO_PR - Auto push + open a PR on session end (default: off) # Default behavior PRINTS the PR command (advisory, no push) # # Process Supervision (opt-in): # LOKI_WATCHDOG - Enable process health monitoring (default: false) # LOKI_WATCHDOG_INTERVAL - Check interval in seconds (default: 30) #=============================================================================== # # Compatibility: bash 3.2+ (macOS default), bash 4+ (Linux), WSL # Parallel mode (--parallel) requires bash 4.0+ for associative arrays #=============================================================================== set -uo pipefail # Compatibility check: Ensure we're running in bash (not sh, dash, zsh) if [ -z "${BASH_VERSION:-}" ]; then echo "[ERROR] This script requires bash. Please run with: bash $0" >&2 exit 1 fi # Extract major version for feature checks BASH_VERSION_MAJOR="${BASH_VERSION%%.*}" BASH_VERSION_MINOR="${BASH_VERSION#*.}" BASH_VERSION_MINOR="${BASH_VERSION_MINOR%%.*}" # Warn if bash version is very old (< 3.2) if [ "$BASH_VERSION_MAJOR" -lt 3 ] || { [ "$BASH_VERSION_MAJOR" -eq 3 ] && [ "$BASH_VERSION_MINOR" -lt 2 ]; }; then echo "[WARN] Bash version $BASH_VERSION is old. Recommend bash 3.2+ for full compatibility." >&2 echo "[WARN] Some features may not work correctly." >&2 fi SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" PROJECT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)" #=============================================================================== # Self-Copy Protection # Bash reads scripts incrementally, so editing a running script corrupts execution. # Solution: Copy ourselves to /tmp and run from there. The original can be safely edited. #=============================================================================== if [[ -z "${LOKI_RUNNING_FROM_TEMP:-}" ]] && [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then TEMP_SCRIPT=$(mktemp /tmp/loki-run-XXXXXX) mv "$TEMP_SCRIPT" "${TEMP_SCRIPT}.sh" TEMP_SCRIPT="${TEMP_SCRIPT}.sh" cp "${BASH_SOURCE[0]}" "$TEMP_SCRIPT" chmod 700 "$TEMP_SCRIPT" # BUG-XC-011: Set trap BEFORE exec so the temp file gets cleaned up trap 'rm -f "$TEMP_SCRIPT"' EXIT export LOKI_RUNNING_FROM_TEMP=1 # Record the EXACT temp-copy path so the post-exec cleanup trap deletes THIS # temp file and NEVER the canonical source (root cause of the recurring # "run.sh self-deleted on build spawn" bug: an inherited LOKI_RUNNING_FROM_TEMP # skips the self-copy block, leaving BASH_SOURCE[0]=the real run.sh). export LOKI_TEMP_SCRIPT_PATH="$TEMP_SCRIPT" export LOKI_ORIGINAL_SCRIPT_DIR="$SCRIPT_DIR" export LOKI_ORIGINAL_PROJECT_DIR="$PROJECT_DIR" exec "$TEMP_SCRIPT" "$@" fi # Restore original paths when running from temp SCRIPT_DIR="${LOKI_ORIGINAL_SCRIPT_DIR:-$SCRIPT_DIR}" PROJECT_DIR="${LOKI_ORIGINAL_PROJECT_DIR:-$PROJECT_DIR}" # Clean up ONLY the recorded temp copy, and ONLY if it is a real temp file. # Deleting BASH_SOURCE[0] here was the bug: an inherited LOKI_RUNNING_FROM_TEMP # made BASH_SOURCE[0] the canonical source, so run.sh deleted itself on spawned # builds. Guard on the recorded path being a real /tmp/loki-run-* file. if [[ "${LOKI_RUNNING_FROM_TEMP:-}" == "1" ]] \ && [[ -n "${LOKI_TEMP_SCRIPT_PATH:-}" ]] \ && [[ "${LOKI_TEMP_SCRIPT_PATH}" == /tmp/loki-run-* || "${LOKI_TEMP_SCRIPT_PATH}" == "${TMPDIR:-/tmp}"loki-run-* ]]; then trap 'rm -f "${LOKI_TEMP_SCRIPT_PATH}" 2>/dev/null' EXIT fi #=============================================================================== # Configuration File Support (v4.1.0) # Loads settings from config file, environment variables take precedence #=============================================================================== # #691: source the canonical config mapping + shared per-key export helper. This # is the SAME lib the loki CLI pre-pass uses, so the YAML/config-file mapping # cannot drift between the CLI and the runner. Side-effect-free on source. The # parsers below delegate to loki_config_export_key with override=0, preserving # the shipped env-wins auto-discovery contract byte-for-byte. _LOKI_CONFIG_MAP_LIB="$SCRIPT_DIR/lib/config-map.sh" if [ -f "$_LOKI_CONFIG_MAP_LIB" ]; then # shellcheck source=lib/config-map.sh source "$_LOKI_CONFIG_MAP_LIB" fi load_config_file() { local config_file="" # Search for config file in order of priority # Security: Reject symlinks to prevent path traversal attacks # 1. Project-local config if [ -f ".loki/config.yaml" ] && [ ! -L ".loki/config.yaml" ]; then config_file=".loki/config.yaml" elif [ -f ".loki/config.yml" ] && [ ! -L ".loki/config.yml" ]; then config_file=".loki/config.yml" # 2. User-global config (symlinks allowed in home dir - user controls it) elif [ -f "${HOME}/.config/loki-mode/config.yaml" ]; then config_file="${HOME}/.config/loki-mode/config.yaml" elif [ -f "${HOME}/.config/loki-mode/config.yml" ]; then config_file="${HOME}/.config/loki-mode/config.yml" fi # If no config file found, return silently if [ -z "$config_file" ]; then return 0 fi # Check for yq (YAML parser) if ! command -v yq &> /dev/null; then # Fallback: parse simple YAML with sed/grep parse_simple_yaml "$config_file" return 0 fi # Use yq for proper YAML parsing parse_yaml_with_yq "$config_file" } # Fallback YAML parser for simple key: value format. # #691: iterates the canonical LOKI_CONFIG_MAP (single source of truth) instead # of 64 hand-maintained set_from_yaml calls. override=0 -> ambient env still # wins (auto-discovery contract unchanged). Falls back to nothing if the lib is # absent (defensive; the lib ships alongside run.sh). parse_simple_yaml() { local file="$1" if ! declare -p LOKI_CONFIG_MAP >/dev/null 2>&1; then return 0 fi local mapping yaml_path env_var for mapping in "${LOKI_CONFIG_MAP[@]}"; do yaml_path="${mapping%%:*}" env_var="${mapping##*:}" set_from_yaml "$file" "$yaml_path" "$env_var" done } # Validate YAML value to prevent injection attacks validate_yaml_value() { local value="$1" local max_length="${2:-1000}" # Reject empty values if [ -z "$value" ]; then return 1 fi # Reject values with dangerous shell metacharacters. # SECURITY FIX (#691 wave): the previous [[ "$value" =~ [\$\`...] ]] # bracket-regex matched NOTHING -- backslash escapes inside a bash regex # bracket class are taken literally, so the guard ACCEPTED $(...), backticks, # pipes, etc. (verified behaviorally: it returned 0 for "$(touch /tmp/x)"). # A `case` glob class has no such ambiguity and actually rejects the metachars. # Allow alphanumeric, spaces, dots, dashes, underscores, slashes, colons, # commas, @. case "$value" in *'$'* | *'`'* | *'|'* | *';'* | *'&'* | *'>'* | *'<'* | *'('* | *')'* \ | *'{'* | *'}'* | *'['* | *']'* | *'\'* ) return 1 ;; esac # Reject values that are too long (DoS protection) if [ "${#value}" -gt "$max_length" ]; then return 1 fi # Reject values with newlines (could corrupt variables) if [[ "$value" == *$'\n'* ]]; then return 1 fi return 0 } # Escape regex metacharacters for safe grep usage escape_regex() { local input="$1" # Escape: . * ? + [ ] ^ $ { } | ( ) \ printf '%s' "$input" | sed 's/[.[\*?+^${}|()\\]/\\&/g' } # Helper: Extract value from YAML and set env var if not already set set_from_yaml() { local file="$1" local yaml_path="$2" local env_var="$3" # Skip if env var is already set (env-wins guard; the shared helper also # enforces this with override=0, but checking here avoids the extraction). if [ -n "${!env_var:-}" ]; then return 0 fi # Extract value using grep and sed (handles simple YAML) # Convert yaml path like "core.max_retries" to search pattern local value="" local key="${yaml_path##*.}" # Get last part of path # Escape regex metacharacters in key for safe grep local escaped_key escaped_key=$(escape_regex "$key") # Simple grep for the key (works for flat or indented YAML) # Use read to avoid xargs command execution risks value=$(grep -E "^\s*${escaped_key}:" "$file" 2>/dev/null | head -1 | sed -E 's/.*:\s*//' | sed 's/#.*//' | sed 's/^["\x27]//;s/["\x27]$//' | tr -d '\n' | sed 's/^[[:space:]]*//;s/[[:space:]]*$//') # #691: delegate the env-wins guard + ${VAR}-expand + validate + export to the # single shared helper (override=0 -> ambient env wins). Falls back to the # original inline export if the lib is unavailable, so behavior is identical # either way. if declare -f loki_config_export_key >/dev/null 2>&1; then loki_config_export_key "$env_var" "$value" 0 || true elif [ -n "$value" ] && [ "$value" != "null" ] && validate_yaml_value "$value"; then export "$env_var=$value" fi } # Parse YAML using yq (proper parser). # #691: iterates the canonical LOKI_CONFIG_MAP and delegates the env-wins guard + # expand + validate + export to the single shared helper (override=0 -> ambient # env wins; auto-discovery contract unchanged). The inline 61-entry table that # used to drift from parse_simple_yaml's 64 is gone. parse_yaml_with_yq() { local file="$1" if ! declare -p LOKI_CONFIG_MAP >/dev/null 2>&1; then return 0 fi local mapping yaml_path env_var value for mapping in "${LOKI_CONFIG_MAP[@]}"; do yaml_path="${mapping%%:*}" env_var="${mapping##*:}" # Extract value using yq (env-wins guard is enforced by the shared helper). value=$(yq eval ".$yaml_path // \"\"" "$file" 2>/dev/null) if declare -f loki_config_export_key >/dev/null 2>&1; then loki_config_export_key "$env_var" "$value" 0 || true elif [ -n "$value" ] && [ "$value" != "null" ] && [ "$value" != "" ] \ && [ -z "${!env_var:-}" ] && validate_yaml_value "$value"; then export "$env_var=$value" fi done } # Load config file before setting defaults load_config_file # Load JSON settings from loki config set (v6.0.0) # # SECURITY NOTE (v7.5.10, L12#2 audit): The eval below is intentional and safe. # The Python script's output is constrained to a fixed template: # [ -z "${VAR:-}" ] && export VAR= # where: # - VAR is a hardcoded env var name from the `mapping` dict (NOT user-controlled). # - is produced by shlex.quote(), which emits POSIX-shell-safe single- # quoted strings even for adversarial input (e.g. quotes, semicolons, $()). # - Non-string values from settings.json are skipped (isinstance check). # Therefore no user-controlled bytes can break out of the quoted value or alter # the surrounding shell syntax. Do NOT remove the shlex.quote() call or relax # the isinstance(val, str) guard without re-auditing this eval. _load_json_settings() { local settings_file="${TARGET_DIR:-.}/.loki/config/settings.json" [ -f "$settings_file" ] || return 0 eval "$(_LOKI_SETTINGS_FILE="$settings_file" python3 -c " import json, sys, os, shlex def get_nested(d, key): \"\"\"Resolve dotted keys through nested dicts (model.planning -> data['model']['planning'])\"\"\" parts = key.split('.') cur = d for p in parts: if isinstance(cur, dict): cur = cur.get(p) else: return None return cur try: with open(os.environ['_LOKI_SETTINGS_FILE']) as f: data = json.load(f) except Exception: sys.exit(0) mapping = { 'maxTier': 'LOKI_MAX_TIER', 'model.planning': 'LOKI_MODEL_PLANNING', 'model.development': 'LOKI_MODEL_DEVELOPMENT', 'model.fast': 'LOKI_MODEL_FAST', 'notify.slack': 'LOKI_SLACK_WEBHOOK', 'notify.discord': 'LOKI_DISCORD_WEBHOOK', 'provider': 'LOKI_PROVIDER', 'issue.provider': 'LOKI_ISSUE_PROVIDER', 'blind_validation': 'LOKI_BLIND_VALIDATION', 'adversarial_testing': 'LOKI_ADVERSARIAL_TESTING', 'spawn_timeout': 'LOKI_SPAWN_TIMEOUT', 'spawn_retries': 'LOKI_SPAWN_RETRIES', 'budget': 'LOKI_BUDGET_LIMIT', } for key, env_var in mapping.items(): # Try nested dict lookup first, then flat key, then underscore variant val = get_nested(data, key) or data.get(key) or data.get(key.replace('.', '_')) if val and isinstance(val, str): safe_val = shlex.quote(val) print(f'[ -z \"\${{{env_var}:-}}\" ] && export {env_var}={safe_val}') " 2>/dev/null)" 2>/dev/null || true } _LOKI_SETTINGS_FILE="${TARGET_DIR:-.}/.loki/config/settings.json" _load_json_settings # Configuration MAX_RETRIES=${LOKI_MAX_RETRIES:-50} BASE_WAIT=${LOKI_BASE_WAIT:-60} MAX_WAIT=${LOKI_MAX_WAIT:-3600} SKIP_PREREQS=${LOKI_SKIP_PREREQS:-false} ENABLE_DASHBOARD=${LOKI_DASHBOARD:-true} DASHBOARD_PORT=${LOKI_DASHBOARD_PORT:-57374} RESOURCE_CHECK_INTERVAL=${LOKI_RESOURCE_CHECK_INTERVAL:-300} # Check every 5 minutes RESOURCE_CPU_THRESHOLD=${LOKI_RESOURCE_CPU_THRESHOLD:-80} # CPU % threshold RESOURCE_MEM_THRESHOLD=${LOKI_RESOURCE_MEM_THRESHOLD:-80} # Memory % threshold # Budget / Cost Limit (opt-in, empty = unlimited) BUDGET_LIMIT=${LOKI_BUDGET_LIMIT:-""} # USD amount, e.g., "50.00" # Background Mode BACKGROUND_MODE=${LOKI_BACKGROUND:-false} # Run in background # Security & Autonomy Controls STAGED_AUTONOMY=${LOKI_STAGED_AUTONOMY:-false} # Require plan approval AUDIT_LOG_ENABLED=${LOKI_AUDIT_LOG:-true} # Enable audit logging (on by default) MAX_PARALLEL_AGENTS=${LOKI_MAX_PARALLEL_AGENTS:-10} # Limit concurrent agents SANDBOX_MODE=${LOKI_SANDBOX_MODE:-false} # Docker sandbox mode (informational; the real dispatch reads LOKI_SANDBOX_MODE at autonomy/loki:1965 and execs sandbox.sh -- this var is not consumed in run.sh) ALLOWED_PATHS=${LOKI_ALLOWED_PATHS:-""} # PARTIAL enforcement. When set, a sandbox custom --mount host path outside the allowlist is rejected in sandbox.sh (_sandbox_path_within_allowed), NOT in run.sh. Does NOT restrict provider-driven agent writes (run.sh never sees them); the sandbox container is the containment for those. Default empty = no restriction. BLOCKED_COMMANDS=${LOKI_BLOCKED_COMMANDS:-"rm -rf /,dd if=,mkfs,:(){ :|:& };:"} # LOKI_SESSION_ID is woven into many filesystem paths (.loki/sessions//..., # session locks, PID files, per-session state). It is operator/issue-derived # (trusted-ish), but a value like "../../tmp/x" would escape the .loki/ tree. # Sanitize ONCE here at intake: any char outside [A-Za-z0-9._-] is replaced with # "_" and a leading run of dots/dashes is neutralized, so every downstream # session path is contained. Unset stays unset (default behavior unchanged). if [ -n "${LOKI_SESSION_ID:-}" ]; then _loki_sid_raw="$LOKI_SESSION_ID" _loki_sid_safe="${_loki_sid_raw//[^A-Za-z0-9._-]/_}" # Strip leading dots/dashes so "../x" -> "x" cannot reference a parent dir # or look like an option; collapse a now-empty result to a safe literal. _loki_sid_safe="${_loki_sid_safe#"${_loki_sid_safe%%[!.-]*}"}" [ -n "$_loki_sid_safe" ] || _loki_sid_safe="session" if [ "$_loki_sid_safe" != "$_loki_sid_raw" ]; then printf 'loki: WARNING sanitized unsafe LOKI_SESSION_ID %s -> %s\n' "$_loki_sid_raw" "$_loki_sid_safe" >&2 fi export LOKI_SESSION_ID="$_loki_sid_safe" unset _loki_sid_raw _loki_sid_safe fi # Process Supervision (opt-in) WATCHDOG_ENABLED=${LOKI_WATCHDOG:-"false"} # Enable process health monitoring WATCHDOG_INTERVAL=${LOKI_WATCHDOG_INTERVAL:-30} # Check interval in seconds LAST_WATCHDOG_CHECK=0 STATUS_MONITOR_PID="" DASHBOARD_PID="" DASHBOARD_LAST_ALIVE=0 _DASHBOARD_RESTARTING=false RESOURCE_MONITOR_PID="" # SDLC Phase Controls (all enabled by default) PHASE_UNIT_TESTS=${LOKI_PHASE_UNIT_TESTS:-true} PHASE_API_TESTS=${LOKI_PHASE_API_TESTS:-true} PHASE_E2E_TESTS=${LOKI_PHASE_E2E_TESTS:-true} PHASE_SECURITY=${LOKI_PHASE_SECURITY:-true} PHASE_INTEGRATION=${LOKI_PHASE_INTEGRATION:-true} PHASE_CODE_REVIEW=${LOKI_PHASE_CODE_REVIEW:-true} PHASE_WEB_RESEARCH=${LOKI_PHASE_WEB_RESEARCH:-true} PHASE_PERFORMANCE=${LOKI_PHASE_PERFORMANCE:-true} PHASE_ACCESSIBILITY=${LOKI_PHASE_ACCESSIBILITY:-true} PHASE_REGRESSION=${LOKI_PHASE_REGRESSION:-true} PHASE_UAT=${LOKI_PHASE_UAT:-true} # Autonomous Loop Controls (Ralph Wiggum Mode) # Default: No auto-completion - runs until max iterations or explicit promise COMPLETION_PROMISE=${LOKI_COMPLETION_PROMISE:-""} MAX_ITERATIONS=${LOKI_MAX_ITERATIONS:-1000} ITERATION_COUNT=0 # If this is an auto-fix task, allow more iterations if [[ "${LOKI_AUTO_FIX:-}" == "true" ]]; then MAX_ITERATIONS="${LOKI_MAX_ITERATIONS:-5}" fi # Perpetual mode: never stop unless max iterations (ignores all completion signals) PERPETUAL_MODE=${LOKI_PERPETUAL_MODE:-false} # Enterprise background service PIDs (OTEL bridge, audit subscriber, integration sync) ENTERPRISE_PIDS=() # Portable lock helper (v7.5.12) -- mkdir-mutex replacement for flock(1). # Provides safe_acquire_lock / safe_release_lock / safe_with_lock so bash # callers no longer need a Linux-only flock binary. Macs do not ship # flock; pre-7.5.12 the fallback was a non-atomic PID check that emitted # "[WARN] flock not available - using non-atomic PID check ...". LOCK_LIB="$SCRIPT_DIR/lib/lock.sh" if [ -f "$LOCK_LIB" ]; then # shellcheck source=lib/lock.sh source "$LOCK_LIB" fi # Git PR advisory (shared print-only helper for create_session_pr and loki deploy) GIT_PR_ADVISORY_LIB="$SCRIPT_DIR/lib/git-pr-advisory.sh" if [ -f "$GIT_PR_ADVISORY_LIB" ]; then # shellcheck source=lib/git-pr-advisory.sh source "$GIT_PR_ADVISORY_LIB" fi # Proven PR (Loop 6): shared print-only Evidence Receipt renderer for PR bodies. # render_evidence_receipt_md prints the run's honest headline + facts + # verify-yourself block into the PR body. Pure, never pushes/PRs/mutates. PROOF_PR_LIB="$SCRIPT_DIR/lib/proof-pr.sh" if [ -f "$PROOF_PR_LIB" ]; then # shellcheck source=lib/proof-pr.sh source "$PROOF_PR_LIB" fi # Proven PR (Loop 6 / Slice B): optional advisory verified-completion check-run. # Owned by Slice B (autonomy/lib/proof-check.sh); sourced guarded so this slice # is correct whether or not the file is present in the tree, and the single call # site is itself guarded on declare -f + LOKI_PROVEN_PR_CHECK. PROOF_CHECK_LIB="$SCRIPT_DIR/lib/proof-check.sh" if [ -f "$PROOF_CHECK_LIB" ]; then # shellcheck source=lib/proof-check.sh source "$PROOF_CHECK_LIB" fi # Completion Council (v5.25.0) - Multi-agent completion verification # Source completion council module COUNCIL_SCRIPT="$SCRIPT_DIR/completion-council.sh" if [ -f "$COUNCIL_SCRIPT" ]; then # shellcheck source=completion-council.sh source "$COUNCIL_SCRIPT" fi # PRD Checklist module (v5.44.0) if [ -f "${SCRIPT_DIR}/prd-checklist.sh" ]; then # shellcheck source=prd-checklist.sh source "${SCRIPT_DIR}/prd-checklist.sh" fi # App Runner module (v5.45.0) if [ -f "${SCRIPT_DIR}/app-runner.sh" ]; then # shellcheck source=app-runner.sh source "${SCRIPT_DIR}/app-runner.sh" fi # Build-time HOME isolation (F49). # # When Loki executes/tests the GENERATED app during a build (the app-runner # server launch, restarts, and the project's own test suite in # enforce_test_coverage), the child process inherits Loki's environment -- # including the user's REAL $HOME. A generated app that defaults its state file # to a HOME-relative path (e.g. a todo CLI writing ~/.todo.json) would then # litter the user's home directory with Loki's in-build test data. These two # helpers give those in-build executions an isolated HOME/XDG/TMPDIR rooted # under .loki/ so the app can run normally but cannot write into the real home. # # Scope: ONLY Loki's own in-build test executions are sandboxed. The user's # later manual `npm start`/run of the app is unaffected -- they invoke it # themselves in their own shell with their own HOME. # Lazily create and echo a persistent isolated HOME directory under .loki. # Persistent (not a per-call mktemp) so an app launched in one iteration and # restarted in a later one keeps a stable home, and so its state survives # across the build the same way a real run would. _loki_app_sandbox_dir() { local _base="${TARGET_DIR:-.}/.loki/app-sandbox" if [ ! -d "$_base/home" ]; then mkdir -p "$_base/home" "$_base/config" "$_base/data" \ "$_base/cache" "$_base/state" "$_base/tmp" 2>/dev/null || return 1 fi printf '%s\n' "$_base" } # Run a command with the build-time app sandbox env applied, then restore the # previous environment. Works for both shell functions (app_runner_start) and # external commands because it only mutates env vars around the call. The # background app launched by app_runner_start captures the sandbox HOME at fork # time and keeps it for its lifetime; restoring here ensures the orchestrator # (and the next iteration's provider invocation, which needs the REAL HOME for # OAuth/credentials) is never left pointing at the sandbox. _loki_with_app_sandbox() { local _sb _sb=$(_loki_app_sandbox_dir 2>/dev/null) || _sb="" # If the sandbox could not be created, run unsandboxed rather than failing # the build -- correctness of the app run takes priority over isolation. if [ -z "$_sb" ]; then "$@" return $? fi # Resolve to an absolute path so child `cd` into the target dir cannot make # a relative HOME point somewhere unexpected. local _abs _abs=$(cd "$_sb" 2>/dev/null && pwd) || _abs="$_sb" # Save current values plus their set/unset state so restore is exact. local _had_home="${HOME+x}" _old_home="${HOME:-}" local _had_xch="${XDG_CONFIG_HOME+x}" _old_xch="${XDG_CONFIG_HOME:-}" local _had_xdh="${XDG_DATA_HOME+x}" _old_xdh="${XDG_DATA_HOME:-}" local _had_xcache="${XDG_CACHE_HOME+x}" _old_xcache="${XDG_CACHE_HOME:-}" local _had_xsh="${XDG_STATE_HOME+x}" _old_xsh="${XDG_STATE_HOME:-}" local _had_tmp="${TMPDIR+x}" _old_tmp="${TMPDIR:-}" export HOME="$_abs/home" export XDG_CONFIG_HOME="$_abs/config" export XDG_DATA_HOME="$_abs/data" export XDG_CACHE_HOME="$_abs/cache" export XDG_STATE_HOME="$_abs/state" export TMPDIR="$_abs/tmp" local _rc=0 "$@" || _rc=$? # Restore exactly (re-export prior value, or unset if it was unset before). if [ -n "$_had_home" ]; then export HOME="$_old_home"; else unset HOME; fi if [ -n "$_had_xch" ]; then export XDG_CONFIG_HOME="$_old_xch"; else unset XDG_CONFIG_HOME; fi if [ -n "$_had_xdh" ]; then export XDG_DATA_HOME="$_old_xdh"; else unset XDG_DATA_HOME; fi if [ -n "$_had_xcache" ]; then export XDG_CACHE_HOME="$_old_xcache"; else unset XDG_CACHE_HOME; fi if [ -n "$_had_xsh" ]; then export XDG_STATE_HOME="$_old_xsh"; else unset XDG_STATE_HOME; fi if [ -n "$_had_tmp" ]; then export TMPDIR="$_old_tmp"; else unset TMPDIR; fi return "$_rc" } # Playwright Smoke Test module (v5.46.0) if [ -f "${SCRIPT_DIR}/playwright-verify.sh" ]; then # shellcheck source=playwright-verify.sh source "${SCRIPT_DIR}/playwright-verify.sh" fi # Anonymous usage telemetry (opt-out: LOKI_TELEMETRY_DISABLED=true or DO_NOT_TRACK=1) # Also check persistent opt-out from ~/.loki/config (#77) if [ -f "${HOME}/.loki/config" ] && grep -q "^TELEMETRY_DISABLED=true" "${HOME}/.loki/config" 2>/dev/null; then LOKI_TELEMETRY_DISABLED=true export LOKI_TELEMETRY_DISABLED unset LOKI_OTEL_ENDPOINT fi TELEMETRY_SCRIPT="$SCRIPT_DIR/telemetry.sh" if [ -f "$TELEMETRY_SCRIPT" ]; then # shellcheck source=telemetry.sh source "$TELEMETRY_SCRIPT" fi # Crash-reporting helpers (Phase 0: local-only, zero egress). # Provides loki_collection_enabled (unified opt-out), loki_crash_capture, # loki_crash_friction, loki_show_disclosure_once. CRASH_SCRIPT="$SCRIPT_DIR/crash.sh" if [ -f "$CRASH_SCRIPT" ]; then # shellcheck source=crash.sh source "$CRASH_SCRIPT" fi # 2026 Research Enhancements (minimal additions) PROMPT_REPETITION=${LOKI_PROMPT_REPETITION:-true} CONFIDENCE_ROUTING=${LOKI_CONFIDENCE_ROUTING:-true} AUTONOMY_MODE=${LOKI_AUTONOMY_MODE:-perpetual} # perpetual|checkpoint|supervised # Session-pinned model (S0.1): pin a single tier for the whole main loop. # Default is "sonnet" -> resolved via the "development" tier in the abstract # tier map. Set LOKI_LEGACY_TIER_SWITCHING=true to restore the old # per-iteration RARV-driven tier rotation in the main loop. The # get_rarv_tier function is preserved for subagent dispatch regardless. LOKI_SESSION_MODEL="${LOKI_SESSION_MODEL:-sonnet}" LOKI_LEGACY_TIER_SWITCHING="${LOKI_LEGACY_TIER_SWITCHING:-false}" export LOKI_SESSION_MODEL LOKI_LEGACY_TIER_SWITCHING # Managed Agents (v6.83.0 Phase 1): opt-in integration with Claude Managed Agents # Memory store backend. Parent flag gates everything; child flags gate features. # Both off (default) => zero behavior change from v6.82.0. LOKI_MANAGED_AGENTS="${LOKI_MANAGED_AGENTS:-false}" LOKI_MANAGED_MEMORY="${LOKI_MANAGED_MEMORY:-false}" # v7.0.0 Phase 2: remote->local hydrate on session boot (grandchild of MEMORY). # Pulls semantic patterns + procedural skills once at init_loki_dir time. LOKI_MANAGED_MEMORY_HYDRATE="${LOKI_MANAGED_MEMORY_HYDRATE:-false}" # v7.0.0 Phase 3+4 foundation: umbrella flag for the multiagent-session path. # Gates every providers/managed.py entry point (run_council, # run_completion_council). Off by default because the Managed Agents # multiagent surface is a research preview. LOKI_EXPERIMENTAL_MANAGED_AGENTS="${LOKI_EXPERIMENTAL_MANAGED_AGENTS:-false}" # v7.0.0 Phase 3 (T5): managed code-review council. Routes run_code_review # through providers/managed.py::run_council when true. Requires parent + # umbrella. LOKI_EXPERIMENTAL_MANAGED_REVIEW="${LOKI_EXPERIMENTAL_MANAGED_REVIEW:-false}" # v7.0.0 Phase 4 (T6): managed completion council. Routes council_should_stop # through providers/managed.py::run_completion_council when true. Requires # parent + umbrella. LOKI_EXPERIMENTAL_MANAGED_COUNCIL="${LOKI_EXPERIMENTAL_MANAGED_COUNCIL:-false}" export LOKI_MANAGED_AGENTS LOKI_MANAGED_MEMORY LOKI_MANAGED_MEMORY_HYDRATE LOKI_EXPERIMENTAL_MANAGED_AGENTS LOKI_EXPERIMENTAL_MANAGED_REVIEW LOKI_EXPERIMENTAL_MANAGED_COUNCIL # Fail-fast: child on with parent off is a misconfiguration. if [ "$LOKI_MANAGED_MEMORY" = "true" ] && [ "$LOKI_MANAGED_AGENTS" != "true" ]; then echo "ERROR: LOKI_MANAGED_MEMORY=true requires LOKI_MANAGED_AGENTS=true" >&2 exit 2 fi # Phase 2 fail-fast: HYDRATE is a grandchild of MEMORY. if [ "$LOKI_MANAGED_MEMORY_HYDRATE" = "true" ] && [ "$LOKI_MANAGED_MEMORY" != "true" ]; then echo "ERROR: LOKI_MANAGED_MEMORY_HYDRATE=true requires LOKI_MANAGED_MEMORY=true" >&2 exit 2 fi # Same fail-fast for the experimental multiagent session path. if [ "$LOKI_EXPERIMENTAL_MANAGED_AGENTS" = "true" ] && [ "$LOKI_MANAGED_AGENTS" != "true" ]; then echo "ERROR: LOKI_EXPERIMENTAL_MANAGED_AGENTS=true requires LOKI_MANAGED_AGENTS=true" >&2 exit 2 fi # Phase 3 fail-fast: REVIEW requires parent AND umbrella. if [ "$LOKI_EXPERIMENTAL_MANAGED_REVIEW" = "true" ]; then if [ "$LOKI_MANAGED_AGENTS" != "true" ]; then echo "ERROR: LOKI_EXPERIMENTAL_MANAGED_REVIEW=true requires LOKI_MANAGED_AGENTS=true" >&2 exit 2 fi if [ "$LOKI_EXPERIMENTAL_MANAGED_AGENTS" != "true" ]; then echo "ERROR: LOKI_EXPERIMENTAL_MANAGED_REVIEW=true requires LOKI_EXPERIMENTAL_MANAGED_AGENTS=true" >&2 exit 2 fi fi # Phase 4 fail-fast: COUNCIL requires parent AND umbrella. if [ "$LOKI_EXPERIMENTAL_MANAGED_COUNCIL" = "true" ]; then if [ "$LOKI_MANAGED_AGENTS" != "true" ]; then echo "ERROR: LOKI_EXPERIMENTAL_MANAGED_COUNCIL=true requires LOKI_MANAGED_AGENTS=true" >&2 exit 2 fi if [ "$LOKI_EXPERIMENTAL_MANAGED_AGENTS" != "true" ]; then echo "ERROR: LOKI_EXPERIMENTAL_MANAGED_COUNCIL=true requires LOKI_EXPERIMENTAL_MANAGED_AGENTS=true" >&2 exit 2 fi fi # Research-preview warning banner. if [ "$LOKI_EXPERIMENTAL_MANAGED_AGENTS" = "true" ]; then echo "WARN: LOKI_EXPERIMENTAL_MANAGED_AGENTS uses Managed Agents research preview; expect beta churn." >&2 fi # Parallel Workflows (Git Worktrees) PARALLEL_MODE=${LOKI_PARALLEL_MODE:-false} MAX_WORKTREES=${LOKI_MAX_WORKTREES:-5} MAX_PARALLEL_SESSIONS=${LOKI_MAX_PARALLEL_SESSIONS:-3} PARALLEL_TESTING=${LOKI_PARALLEL_TESTING:-true} PARALLEL_DOCS=${LOKI_PARALLEL_DOCS:-true} # Dynamic resource-aware session concurrency (Release 3, slice 3). # DEFAULT OFF: when LOKI_DYNAMIC_CONCURRENCY is unset, effective_session_cap() # returns exactly MAX_PARALLEL_SESSIONS, so behavior is identical to before. # Opt in with LOKI_DYNAMIC_CONCURRENCY=1 to scale the session cap down when # system CPU or memory is under pressure (read from .loki/state/resources.json). DYNAMIC_CONCURRENCY=${LOKI_DYNAMIC_CONCURRENCY:-0} # Optional higher ceiling on capable machines. Only takes effect with dynamic # concurrency enabled; still resource-gated. Defaults to MAX_PARALLEL_SESSIONS. MAX_PARALLEL_SESSIONS_CEILING=${LOKI_MAX_PARALLEL_SESSIONS_CEILING:-$MAX_PARALLEL_SESSIONS} # Usage thresholds (percent). At/above CPU or MEM threshold the cap is halved. CONCURRENCY_CPU_THRESHOLD=${LOKI_CONCURRENCY_CPU_THRESHOLD:-85} CONCURRENCY_MEM_THRESHOLD=${LOKI_CONCURRENCY_MEM_THRESHOLD:-85} # Critical threshold (percent). At/above this the cap is forced to 1. CONCURRENCY_CRITICAL_THRESHOLD=${LOKI_CONCURRENCY_CRITICAL_THRESHOLD:-95} # Gate Escalation Ladder (v6.10.0) GATE_CLEAR_LIMIT=${LOKI_GATE_CLEAR_LIMIT:-3} GATE_ESCALATE_LIMIT=${LOKI_GATE_ESCALATE_LIMIT:-5} GATE_PAUSE_LIMIT=${LOKI_GATE_PAUSE_LIMIT:-10} # Workspace resolution: the build runs against TARGET_DIR, defaulting to the # launch cwd. A caller can pin a per-build workspace by exporting # LOKI_TARGET_DIR (and the matching LOKI_DIR=/.loki); the dashboard # /api/control/start `workspace` param (Track-1 S1) does exactly this so a # hosted build runs in its own dir instead of the engine's repo. Every # $TARGET_DIR/.loki reference below then resolves under that workspace. TARGET_DIR="${LOKI_TARGET_DIR:-$(pwd)}" PARALLEL_BLOG=${LOKI_PARALLEL_BLOG:-false} AUTO_MERGE=${LOKI_AUTO_MERGE:-true} # Multi-project registry (v7.7.29): register this running project in the # machine-global registry (~/.loki/dashboard/projects.json) so the dashboard # can list and switch between projects running in different folders. Records # the absolute path, pid, port, and status. Fully non-blocking and # failure-swallowed: registry problems must never affect a build. Marked # inactive again on exit via the trap below. loki_register_running_project() { local _status="${1:-running}" [ -n "${LOKI_SKIP_PROJECT_REGISTRY:-}" ] && return 0 command -v python3 >/dev/null 2>&1 || return 0 local _skill="${LOKI_SKILL_DIR:-${PROJECT_DIR:-$SCRIPT_DIR/..}}" LOKI_REG_TARGET="$TARGET_DIR" LOKI_REG_SKILL="$_skill" \ LOKI_REG_PID="$$" LOKI_REG_PORT="${LOKI_DASHBOARD_PORT:-57374}" \ LOKI_REG_STATUS="$_status" \ python3 - <<'PYREG' >/dev/null 2>&1 || true import os, sys sys.path.insert(0, os.environ.get("LOKI_REG_SKILL", ".")) try: from dashboard import registry target = os.path.abspath(os.environ["LOKI_REG_TARGET"]) entry = registry.register_project(target) # Enrich with runtime fields the dashboard switcher uses. reg = registry._load_registry() pid = entry.get("id") or registry._generate_project_id(target) if pid in reg.get("projects", {}): reg["projects"][pid]["pid"] = int(os.environ.get("LOKI_REG_PID", "0") or 0) reg["projects"][pid]["port"] = int(os.environ.get("LOKI_REG_PORT", "57374") or 57374) reg["projects"][pid]["status"] = os.environ.get("LOKI_REG_STATUS", "running") registry._save_registry(reg) except Exception: pass PYREG } # v7.7.30: deliberate-exit teardown for the shared dashboard + registry. # Marks THIS project (abspath of TARGET_DIR) stopped in the machine-global # registry, then decides whether the shared standalone dashboard at # ~/.loki/dashboard/dashboard.pid should be killed. The shared dashboard is # killed ONLY when no other registered project still has a live pid (CLEAR); # if any other project is still running (KEEP) it is left up. NEVER uses a # blanket pkill and NEVER touches another folder's pids. Best-effort and # failure-swallowed: teardown bookkeeping must never block a clean exit. loki_mark_project_stopped_and_maybe_kill_shared_dashboard() { local _skill="${LOKI_SKILL_DIR:-${PROJECT_DIR:-$SCRIPT_DIR/..}}" local _shared_pidfile="${HOME}/.loki/dashboard/dashboard.pid" local _decision="CLEAR" if [ -z "${LOKI_SKIP_PROJECT_REGISTRY:-}" ] && command -v python3 >/dev/null 2>&1; then # (a) Mark this project stopped in the shared registry. LOKI_REG_TARGET="$TARGET_DIR" LOKI_REG_SKILL="$_skill" \ python3 - <<'PYSTOP' >/dev/null 2>&1 || true import os, sys sys.path.insert(0, os.environ.get("LOKI_REG_SKILL", ".")) try: from dashboard import registry registry.mark_project_stopped(os.path.abspath(os.environ["LOKI_REG_TARGET"])) except Exception: pass PYSTOP # (b) CLEAR/KEEP check: any OTHER project still alive keeps the # shared dashboard up (this project is already marked stopped above). _decision="$(LOKI_REG_SKILL="$_skill" python3 - <<'PYCHECK' 2>/dev/null || echo CLEAR import os, sys sys.path.insert(0, os.environ.get("LOKI_REG_SKILL", ".")) try: from dashboard import registry alive = 0 for p in registry.list_projects(include_inactive=True): pid = p.get("pid") if isinstance(pid, int) and pid > 0: try: os.kill(pid, 0) alive += 1 except OSError: pass print("CLEAR" if alive == 0 else "KEEP") except Exception: print("CLEAR") PYCHECK )" fi # (c) Only tear down the SHARED dashboard when no other project remains # (CLEAR), or when python3 was unavailable (legacy fallback: avoid leaking # the shared dashboard on minimal systems). if [ "$_decision" = "CLEAR" ]; then if [ -f "$_shared_pidfile" ]; then local _shared_pid _shared_pid=$(cat "$_shared_pidfile" 2>/dev/null) if [ -n "$_shared_pid" ]; then kill "$_shared_pid" 2>/dev/null || true sleep 0.5 kill -9 "$_shared_pid" 2>/dev/null || true fi rm -f "$_shared_pidfile" 2>/dev/null || true fi # (d) Defense-in-depth: reclaim the dashboard port only in the CLEAR # case, so we never kill a shared dashboard another project owns. # BUT never kill a HEALTHY dashboard already serving on the port: that is # almost always the user's own live dashboard (open in their browser), and # killing it mid-use drops their session (ERR_CONNECTION_REFUSED, WS fail). # A healthy server is reusable by every project, so probe /api/status first # and only reclaim the port when nothing is answering (a genuinely stale # listener). Opt out of the probe with LOKI_DASHBOARD_FORCE_RECLAIM=1. if command -v lsof >/dev/null 2>&1; then local _dash_port="${DASHBOARD_PORT:-57374}" local _dash_alive="" if [ "${LOKI_DASHBOARD_FORCE_RECLAIM:-}" != "1" ] && command -v curl >/dev/null 2>&1; then _dash_alive=$(curl -s -o /dev/null -w '%{http_code}' --max-time 1 \ "http://127.0.0.1:${_dash_port}/api/status" 2>/dev/null || true) fi if [ "$_dash_alive" = "200" ]; then log_info "Reusing the healthy dashboard already serving on port ${_dash_port} (not reclaiming)." else lsof -ti:"${_dash_port}" -sTCP:LISTEN 2>/dev/null | xargs kill 2>/dev/null || true fi fi fi } # Register as running now. We deliberately do NOT install an EXIT trap to # flip it to idle: a top-level EXIT trap here would be clobbered by the # lock-release EXIT trap installed later in the main path (and could # interfere with it). Instead the dashboard determines live vs stale by # checking whether the recorded pid is still alive (registry stores pid), # which is robust even on hard kills where a trap would never fire. loki_register_running_project running # Complexity Tiers (Auto-Claude pattern) # auto = detect from PRD/codebase, simple = 3 phases, standard = 6 phases, complex = 8 phases COMPLEXITY_TIER=${LOKI_COMPLEXITY:-auto} DETECTED_COMPLEXITY="" # Multi-Provider Support (v5.0.0) # Provider: claude (default), codex, cline, aider LOKI_PROVIDER=${LOKI_PROVIDER:-claude} # Source provider configuration PROVIDERS_DIR="$PROJECT_DIR/providers" if [ -f "$PROVIDERS_DIR/loader.sh" ]; then # shellcheck source=/dev/null source "$PROVIDERS_DIR/loader.sh" # Validate provider if ! validate_provider "$LOKI_PROVIDER"; then echo "ERROR: Unknown provider: $LOKI_PROVIDER" >&2 echo "Supported providers: ${SUPPORTED_PROVIDERS[*]}" >&2 exit 1 fi # Load provider config if ! load_provider "$LOKI_PROVIDER"; then echo "ERROR: Failed to load provider config: $LOKI_PROVIDER" >&2 exit 1 fi # Save provider for future runs (if .loki dir exists or will be created) if [ -d ".loki/state" ] || mkdir -p ".loki/state" 2>/dev/null; then echo "$LOKI_PROVIDER" > ".loki/state/provider" fi else # Fallback: Claude-only mode (backwards compatibility) PROVIDER_NAME="claude" PROVIDER_CLI="claude" PROVIDER_AUTONOMOUS_FLAG="--dangerously-skip-permissions" PROVIDER_PROMPT_FLAG="-p" PROVIDER_DEGRADED=false PROVIDER_DISPLAY_NAME="Claude Code" PROVIDER_HAS_PARALLEL=true PROVIDER_HAS_SUBAGENTS=true PROVIDER_HAS_TASK_TOOL=true PROVIDER_HAS_MCP=true PROVIDER_PROMPT_POSITIONAL=false fi # Track worktree PIDs for cleanup (requires bash 4+ for associative arrays) # BASH_VERSION_MAJOR is defined at script startup if [ "$BASH_VERSION_MAJOR" -ge 4 ] 2>/dev/null; then declare -A WORKTREE_PIDS=() declare -A WORKTREE_PATHS=() else # Fallback: parallel mode will check and warn # shellcheck disable=SC2178 WORKTREE_PIDS="" # shellcheck disable=SC2178 WORKTREE_PATHS="" fi # Track background install PIDs for cleanup (indexed array, works on all bash versions) WORKTREE_INSTALL_PIDS=() # Colors RED='\033[0;31m' GREEN='\033[0;32m' YELLOW='\033[1;33m' BLUE='\033[0;34m' CYAN='\033[0;36m' BOLD='\033[1m' DIM='\033[2m' NC='\033[0m' #=============================================================================== # Logging Functions #=============================================================================== log_header() { echo "" echo -e "${BLUE}╔════════════════════════════════════════════════════════════════╗${NC}" echo -e "${BLUE}║${NC} ${BOLD}$1${NC}" echo -e "${BLUE}╚════════════════════════════════════════════════════════════════╝${NC}" } log_info() { echo -e "${GREEN}[INFO]${NC} $*"; } log_warn() { echo -e "${YELLOW}[WARN]${NC} $*"; } log_warning() { log_warn "$@"; } # Alias for backwards compatibility log_error() { echo -e "${RED}[ERROR]${NC} $*"; } log_step() { echo -e "${CYAN}[STEP]${NC} $*"; } log_debug() { [[ "${LOKI_DEBUG:-}" == "true" ]] && echo -e "${CYAN}[DEBUG]${NC} $*" >&2 || true; } #=============================================================================== # Failure diagnosis helpers (T2.4 / T2.5 / T2.6) # # These make a failing or crashed build self-explanatory: a copy-pasteable # "loki why" hint on any non-zero exit, a durable CLASSIFIED LAST_ERROR record # on a failed iteration, and a best-effort terminal record on an untrapped # death. Every one is best-effort and NEVER alters the build's exit code. #=============================================================================== # _loki_surface_why_hint (T2.4): print the "loki why" hint to stderr and write # it to .loki/NEXT_STEPS.txt. Called once from main() finalization when the run # failed (result != 0). Best-effort: never crashes, never changes exit code. _loki_surface_why_hint() { local loki_dir="${TARGET_DIR:-.}/.loki" local hint="For a plain-language diagnosis of what happened, run: loki why" printf '%s\n' "$hint" >&2 || true mkdir -p "$loki_dir" 2>/dev/null || true printf '%s\n' "$hint" > "$loki_dir/NEXT_STEPS.txt" 2>/dev/null || true return 0 } # _loki_write_last_error (T2.5): write a durable, classified failure record to # .loki/state/LAST_ERROR.json. Schema: # { # "iteration": , # "error_class": "provider_empty_output"|"build_timeout"|"rate_limited" # |"auth_error"|"unknown", # "brief": "", # "timestamp": "" # } # This is what `loki why` (in autonomy/loki, NOT owned here) can later read. # Built via python3 so the free-text brief can never break the JSON. Entirely # best-effort: any failure is swallowed and the build is never crashed. # Usage: _loki_write_last_error _loki_write_last_error() { local iteration="${1:-0}" local error_class="${2:-unknown}" local brief="${3:-An iteration failed.}" local loki_dir="${TARGET_DIR:-.}/.loki" local state_dir="$loki_dir/state" mkdir -p "$state_dir" 2>/dev/null || true LOKI_LE_ITER="$iteration" \ LOKI_LE_CLASS="$error_class" \ LOKI_LE_BRIEF="$brief" \ LOKI_LE_FILE="$state_dir/LAST_ERROR.json" \ python3 -c " import json, os, tempfile try: rec = { 'iteration': int(os.environ.get('LOKI_LE_ITER', '0') or 0), 'error_class': os.environ.get('LOKI_LE_CLASS', 'unknown'), 'brief': os.environ.get('LOKI_LE_BRIEF', ''), 'timestamp': __import__('datetime').datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%SZ'), } target = os.environ['LOKI_LE_FILE'] d = os.path.dirname(target) fd, tmp = tempfile.mkstemp(dir=d, suffix='.json') with os.fdopen(fd, 'w') as f: json.dump(rec, f) os.replace(tmp, target) except Exception: pass " 2>/dev/null || true return 0 } # _loki_classify_iteration_error (T2.5 helper): map an iteration's signals to one # of the LAST_ERROR error_class values. Conservative: only returns a specific # class when a signal confidently supports it, else "unknown". Never fabricates # build_timeout (no timeout signal is detected here, so it is reserved for a # caller that has one). Echoes the class on stdout. # Usage: _loki_classify_iteration_error _loki_classify_iteration_error() { local iter_output="${1:-}" local empty_flag="${2:-0}" if [ "$empty_flag" = "1" ]; then echo "provider_empty_output" return 0 fi # Rate limit: reuse the same detector the retry path uses. if [ -n "$iter_output" ] && [ -f "$iter_output" ] && detect_rate_limit "$iter_output" 2>/dev/null | grep -qE '^[1-9]'; then echo "rate_limited" return 0 fi # Auth error: a clear 401/403/unauthorized in the output tail. if [ -n "$iter_output" ] && [ -f "$iter_output" ]; then local _tail _tail="$(tail -n 40 "$iter_output" 2>/dev/null || true)" if printf '%s\n' "$_tail" | grep -qiE '(http[ /]?40[13]|status[: ]+40[13]|unauthorized|invalid api key|authentication[_ ]error|401 )' 2>/dev/null; then echo "auth_error" return 0 fi fi echo "unknown" return 0 } # _loki_terminal_record (T2.6, SAFE SUBSET): on an untrapped exit where the # persisted run status is still "running" (a true mid-provider-call crash on a # trappable signal -- SIGTERM/SIGINT/SIGHUP via the lock-release trap), leave a # best-effort, classified LAST_ERROR record so a post-crash `loki why` is not # stale. Piggybacks the existing lock-release EXIT trap (see main()) -- it does # NOT install a new broad EXIT trap. # # IMPORTANT (why this does NOT rewrite autonomy-state.json): the resume-detection # block in this file (search "Durable resume") keys the ENT-2 pod-loss resume on # prev_status == "running". Flipping the status to "exited" here would make a # crashed-but-resumable build (LOKI_DURABLE_STATE=1) reset to iteration 0 on the # next start, destroying durable progress. So this writes ONLY the LAST_ERROR # side-record (which is what `loki why` reads) and deliberately leaves the # status untouched. SIGKILL / power-loss are uncatchable (no trap fires); the # ENT-2 durable-resume path covers those. Never alters the exit code; best-effort. _loki_terminal_record() { local state_file state_file="$(_loki_state_file 2>/dev/null)" || return 0 [ -n "$state_file" ] || return 0 [ -f "$state_file" ] || return 0 local _status _status="$(LOKI_TR_FILE="$state_file" python3 -c " import json, os try: print(json.load(open(os.environ['LOKI_TR_FILE'])).get('status','unknown')) except Exception: print('unknown') " 2>/dev/null || echo "unknown")" # Only act on a genuinely mid-flight "running" status. Any settled status # (council_approved, failed, exited, paused, ...) is left untouched. [ "$_status" = "running" ] || return 0 # Leave a classified LAST_ERROR so `loki why` has something honest -- WITHOUT # touching autonomy-state.json (preserving the ENT-2 "running" resume signal). _loki_write_last_error "${ITERATION_COUNT:-0}" "unknown" \ "The build process exited unexpectedly before finishing (possible crash or kill)." 2>/dev/null || true return 0 } # _loki_write_rate_limit_signal (T2.7): write a best-effort # .loki/signals/RATE_LIMITED file. This is FORWARD-LAID infrastructure: no # consumer reads it yet (a future dashboard / external watcher could, to tell a # normal provider rate-limit wait apart from a hang). The user-visible signal # today is the log_info line at the wait site; this file is the durable record. Schema: # {"rate_limited": true, "wait_seconds": , "reset_time": ""} # Built via python3 so the reset-time string can never break the JSON. Entirely # best-effort: never crashes, never alters the build. # Usage: _loki_write_rate_limit_signal _loki_write_rate_limit_signal() { local wait_seconds="${1:-0}" local reset_time="${2:-}" local signals_dir="${TARGET_DIR:-.}/.loki/signals" mkdir -p "$signals_dir" 2>/dev/null || true LOKI_RL_WAIT="$wait_seconds" \ LOKI_RL_RESET="$reset_time" \ LOKI_RL_FILE="$signals_dir/RATE_LIMITED" \ python3 -c " import json, os, tempfile try: w = os.environ.get('LOKI_RL_WAIT', '0') try: w = int(w) except Exception: w = 0 rec = {'rate_limited': True, 'wait_seconds': w, 'reset_time': os.environ.get('LOKI_RL_RESET', '')} target = os.environ['LOKI_RL_FILE'] d = os.path.dirname(target) fd, tmp = tempfile.mkstemp(dir=d, suffix='.json') with os.fdopen(fd, 'w') as f: json.dump(rec, f) os.replace(tmp, target) except Exception: pass " 2>/dev/null || true return 0 } # Live Build HUD (v7.71.0): a single append-only per-iteration status line on the # interactive TTY path. Pure additive stdout decoration -- never piped into any # tee, so the dashboard agent.log and the stream-json parser are untouched. The # whole function is structured so any internal failure still returns 0; it can # never abort the iteration loop. Gated: TTY + not background + LOKI_HUD != 0. # Usage: render_build_hud render_build_hud() { # Gate first: emit nothing unless interactive TTY, not --bg, and not opted out. # Inverted into an early return so the off-TTY path is byte-identical (no output). if ! { [ -t 1 ] && [ "${BACKGROUND_MODE:-false}" != "true" ] && [ "${LOKI_HUD:-1}" != "0" ]; }; then return 0 fi local _iter="${1:-0}" _phase="${2:-?}" _dur="${3:-0}" [ -z "$_phase" ] && _phase="?" # Sanitize numerics so set -u arithmetic/format below can never error out. case "$_dur" in (*[!0-9]*|'') _dur=0 ;; esac local _max="${MAX_ITERATIONS:-0}" case "$_max" in (*[!0-9]*|'') _max=0 ;; esac # Field list: each field is appended only when its data is present. Missing # data => the field is omitted entirely (never a fabricated value). local _fields="$_phase" _fields="${_fields} | iter ${_iter}/${_max}" # Cost from the context tracker totals (the same field the dashboard shows). # NOTE: tracking.json totals accumulate across runs in the same dir (not reset # on a fresh `loki start`), so this is cumulative cost for the project dir, not # strictly this single run. Labeled plainly "$" / "cost" to avoid overclaiming. # OMIT entirely when empty/missing/non-Claude. local _cost="" if command -v python3 >/dev/null 2>&1; then _cost="$(python3 -c " import json try: t = json.load(open('.loki/context/tracking.json')) c = t.get('totals', {}).get('total_cost_usd', 0) c = float(c) if c > 0: print('%.2f' % c) except Exception: pass " 2>/dev/null || true)" fi [ -n "$_cost" ] && _fields="${_fields} | \$${_cost}" # Files changed (+ins/-del and file count) vs the run start SHA. Reuse the # build_completion_summary diff approach incl. the .loki/.git exclude pathspec. # OMIT when no start sha, not a git repo, or no diff data. local _start_sha="${_LOKI_RUN_START_SHA:-}" if [ -n "$_start_sha" ]; then local _shortstat _ins _del _files _shortstat="$( (cd "${TARGET_DIR:-.}" && git diff --shortstat "${_start_sha}..HEAD" -- . ':(exclude).loki/' ':(exclude).git/' ':(exclude)**/.loki/**') 2>/dev/null || true )" if [ -n "$_shortstat" ]; then _files="$(printf '%s\n' "$_shortstat" | grep -oE '[0-9]+ file' | grep -oE '[0-9]+' | head -1 2>/dev/null || true)" _ins="$(printf '%s\n' "$_shortstat" | grep -oE '[0-9]+ insertion' | grep -oE '[0-9]+' | head -1 2>/dev/null || true)" _del="$(printf '%s\n' "$_shortstat" | grep -oE '[0-9]+ deletion' | grep -oE '[0-9]+' | head -1 2>/dev/null || true)" [ -z "$_files" ] && _files=0 [ -z "$_ins" ] && _ins=0 [ -z "$_del" ] && _del=0 _fields="${_fields} | +${_ins}/-${_del} (${_files} files)" fi fi # Per-iteration time (the duration arg). Labeled "took" (not "iter") so it # does not collide with the "iter N/max" iteration-count field above. _fields="${_fields} | took $(_hud_fmt_secs "$_dur")" # Elapsed time for the whole run, from the once-captured run-start epoch. local _start_epoch="${_LOKI_RUN_START_EPOCH:-}" case "$_start_epoch" in (*[!0-9]*|'') _start_epoch="" ;; esac if [ -n "$_start_epoch" ]; then local _now _elapsed _now="$(date +%s 2>/dev/null || true)" case "$_now" in (*[!0-9]*|'') _now="" ;; esac if [ -n "$_now" ] && [ "$_now" -ge "$_start_epoch" ] 2>/dev/null; then _elapsed=$(( _now - _start_epoch )) _fields="${_fields} | elapsed $(_hud_fmt_secs "$_elapsed")" fi fi # ETA (PO lock #1): omit by default. Only a SMALL user-set LOKI_MAX_ITERATIONS # (not the 1000 default) yields a meaningful target, so that is the single ETA # trigger here. A LOKI_BUDGET_LIMIT cap is also an allowed trigger per the # plan, but a budget-derived ETA needs cost-rate math that is easy to get # wrong; per "keep it simple and safe, when unsure omit", budget ETA is left # out rather than rendered approximately. local _lmi="${LOKI_MAX_ITERATIONS:-}" case "$_lmi" in (*[!0-9]*|'') _lmi="" ;; esac if [ -n "$_lmi" ] && [ "$_lmi" -gt 0 ] 2>/dev/null && [ "$_lmi" -lt 1000 ] 2>/dev/null \ && [ "$_iter" -gt 0 ] 2>/dev/null && [ "$_iter" -lt "$_lmi" ] 2>/dev/null \ && [ -n "$_start_epoch" ]; then local _now2 _el2 _per _remain_iters _eta _now2="$(date +%s 2>/dev/null || true)" case "$_now2" in (*[!0-9]*|'') _now2="" ;; esac if [ -n "$_now2" ] && [ "$_now2" -ge "$_start_epoch" ] 2>/dev/null; then _el2=$(( _now2 - _start_epoch )) _per=$(( _el2 / _iter )) _remain_iters=$(( _lmi - _iter )) _eta=$(( _per * _remain_iters )) [ "$_eta" -gt 0 ] 2>/dev/null && _fields="${_fields} | eta ~$(_hud_fmt_secs "$_eta")" fi fi echo -e "${CYAN}[HUD]${NC} ${_fields}" return 0 } # Format a whole-seconds integer as a compact duration: 37s, 2m11s, 1h03m. # Best-effort and set -u safe; any odd input degrades to "0s". _hud_fmt_secs() { local _s="${1:-0}" case "$_s" in (*[!0-9]*|'') _s=0 ;; esac if [ "$_s" -lt 60 ] 2>/dev/null; then printf '%ds' "$_s" elif [ "$_s" -lt 3600 ] 2>/dev/null; then printf '%dm%02ds' "$(( _s / 60 ))" "$(( _s % 60 ))" else printf '%dh%02dm' "$(( _s / 3600 ))" "$(( (_s % 3600) / 60 ))" fi return 0 } #=============================================================================== # Process Registry (PID Supervisor) # Central registry of all spawned child processes for reliable cleanup #=============================================================================== PID_REGISTRY_DIR="" # Initialize the PID registry directory init_pid_registry() { PID_REGISTRY_DIR="${TARGET_DIR:-.}/.loki/pids" mkdir -p "$PID_REGISTRY_DIR" } # Parse a field from a JSON registry entry (python3 with shell fallback) # Usage: _parse_json_field _parse_json_field() { local file="$1" field="$2" if command -v python3 >/dev/null 2>&1; then python3 -c "import json,sys; print(json.load(open(sys.argv[1])).get(sys.argv[2],''))" "$file" "$field" 2>/dev/null else # Shell fallback (no python3): extract value for simple flat JSON. Handles # BOTH quoted string values ("kind":"wrapper") and bare numeric values # ("ppid":206). The prior impl stripped the leading quote's content to empty # for string fields -- broke "kind" parsing on python3-less hosts, which # would drop wrapper entries into the legacy child path (loki-mode #92). sed 's/.*"'"$field"'":[[:space:]]*//' "$file" 2>/dev/null \ | sed 's/^"//' \ | sed 's/[",}].*//' | head -1 fi } # Register a spawned process in the central registry # Usage: register_pid