#!/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 # v8.1: one-switch SDK activation. LOKI_SDK_MODE=off|judges|full (default off) # sets the default for the 8 per-site LOKI_SDK_* flags via a write-once resolver; # per-site flags still win. Sourced + resolved here, before any judge lib or the # main loop reads a flag. No-op (byte-identical) when the mode is unset. _LOKI_SDK_MODE_LIB="$SCRIPT_DIR/lib/sdk-mode.sh" if [ -f "$_LOKI_SDK_MODE_LIB" ]; then # shellcheck source=lib/sdk-mode.sh source "$_LOKI_SDK_MODE_LIB" loki_sdk_resolve_mode 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 # GENERIC TIER VOCABULARY (small|medium|high). A user should be able to ask for # a capability class without naming a vendor model, and get that provider's # latest model in the class. LOKI_SESSION_MODEL is the knob that already does # this -- it accepts the raw tier names planning|development|fast alongside the # Claude aliases -- so the generic words are normalized ONTO it here rather than # becoming a fourth spelling. LOKI_MAX_TIER (a cost CEILING) and LOKI_TIER (the # OSS/enterprise licensing seam) mean different things and are left alone. # # WHY NORMALIZE AT THE ENTRY POINT: the session-pin case block is byte-mirrored # in the estimator (autonomy/loki) and the dashboard (dashboard/server.py), and # every one of those mirrors is locked by a parity test. Translating here means # they keep seeing only the three canonical tier names and none of them change. # # The mapping is loki_tier_alias() in providers/models.sh -- the single source # of truth, not a second copy. Inlined as a case because run.sh must not source # a provider file this early in startup. Kept in lockstep by # tests/test-generic-tiers.sh. # # ONLY the three new words are translated. sonnet/haiku/opus/fable and the raw # tier names pass through untouched, so an unset LOKI_SESSION_MODEL still # defaults to sonnet and "medium" resolves to the same development-tier model # today's builds already use. This changes no existing run's model. # NORMALIZATION IS TRIM-ONLY + LOWERCASE, matching the estimator and dashboard # mirrors exactly. Interior whitespace is deliberately PRESERVED, so " med ium " # stays junk here just as it does there. Stripping interior spaces would make # this reader accept a value the other two reject, which is the precise kind of # divergence the session-pin parity tests exist to catch. _loki_generic_tier="${LOKI_SESSION_MODEL:-}" _loki_generic_tier="${_loki_generic_tier#"${_loki_generic_tier%%[![:space:]]*}"}" _loki_generic_tier="${_loki_generic_tier%"${_loki_generic_tier##*[![:space:]]}"}" case "$(printf '%s' "$_loki_generic_tier" | tr '[:upper:]' '[:lower:]')" in small) LOKI_SESSION_MODEL="fast" ; export LOKI_SESSION_MODEL ;; medium) LOKI_SESSION_MODEL="development" ; export LOKI_SESSION_MODEL ;; high) LOKI_SESSION_MODEL="planning" ; export LOKI_SESSION_MODEL ;; esac unset _loki_generic_tier # 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="" _LOKI_NODE_PROBE_STATUS="not_checked" _LOKI_NODE_PROBE_VERSION="" _LOKI_NPM_PROBE_STATUS="not_checked" _LOKI_NPM_PROBE_VERSION="" # Build-profile fast-path (v7.129+). LOKI_BUILD_PROFILE selects a gate profile. # Default unset = current full behavior (every phase runs). "simple-web" is a # fast profile for static marketing/landing builds: it drops the phases that # are irrelevant to a static frontend (API tests, SAML/OIDC/SSO integration, # load/performance, regression, UAT, competitor web research) while KEEPING the # gates that catch real defects on such a page: E2E/Playwright (catches the # broken-reveal / blank-page class of bug), CODE_REVIEW, SECURITY, and # ACCESSIBILITY (a landing page must be a11y-clean). The completion council and # the evidence/proof gate are NOT phases and are untouched -- the moat stays. # Pure env-defaulting: it only fills a LOKI_PHASE_* that the operator has NOT # already set, so an explicit operator LOKI_PHASE_* override always wins. loki_is_supervised_simple_web() { [ "${LOKI_SUPERVISED_BUILD:-0}" = "1" ] \ && [ "${LOKI_BUILD_PROFILE:-}" = "simple-web" ] } _loki_bind_supervised_spec_sha() { local spec_path="${1:-}" loki_is_supervised_simple_web || return 0 [ -n "$spec_path" ] && [ -f "$spec_path" ] && [ -r "$spec_path" ] || { log_error "Supervised build specification is missing or unreadable." return 1 } local computed_sha supplied_sha="${LOKI_SPEC_SHA256:-}" computed_sha=$(python3 - "$spec_path" <<'PY' import hashlib import sys with open(sys.argv[1], "rb") as handle: print(hashlib.sha256(handle.read()).hexdigest()) PY ) || return 1 [[ "$computed_sha" =~ ^[0-9a-f]{64}$ ]] || return 1 if [ -n "$supplied_sha" ] && [ "$supplied_sha" != "$computed_sha" ]; then log_error "Supervised build specification changed before execution." return 1 fi LOKI_SPEC_SHA256="$computed_sha" export LOKI_SPEC_SHA256 } # Scoped-change profile: a bug fix or a single feature in an EXISTING repo. # # Measured on a real user's run: a 322-word GitHub issue against an existing # codebase spent 25+ minutes still inside iteration 1. The work itself was # genuine, but the build was also running competitor web research, load and # performance testing, regression simulation and UAT -- all of which default to # true, and none of which a scoped issue fix needs. That is the difference # between a 5-minute fix and a 30-minute one. # # What this NEVER touches: code review, security, tests, E2E, and the # completion council all stay on. Speed here comes from not running phases that # are irrelevant to the change, never from skipping verification. A greenfield # build or a whole-repo refactor does not match this profile and keeps the full # suite. # # Auto-detected rather than another flag the user has to know: an existing git # repo with real history, plus a spec that reads as a scoped change. Set # LOKI_SCOPED_CHANGE=0 to force the full suite, or =1 to force this profile. loki_detect_scoped_change() { # Explicit operator intent always wins, in both directions. case "${LOKI_SCOPED_CHANGE:-}" in 0|false) return 1 ;; 1|true) return 0 ;; esac # Greenfield is not a scoped change: no repo, or a repo with almost no # history, means we are building something new. # # Ask git whether this is a work tree rather than testing for a .git # DIRECTORY: in a git worktree (and in a submodule) .git is a FILE, so the # old -d test rejected every worktree-based run -- including the parallel # workflow streams this project runs by default. rev-parse is true for a # plain clone, a worktree, and a submodule alike, and replaces two # subprocesses' worth of checking with one. local target="${TARGET_DIR:-.}" git -C "$target" rev-parse --is-inside-work-tree >/dev/null 2>&1 || return 1 local commits commits="$(git -C "$target" rev-list --count HEAD 2>/dev/null || echo 0)" [ "${commits:-0}" -ge 5 ] || return 1 # An issue-sourced spec is the canonical scoped change: someone filed a # discrete request against code that already exists. # # The spec path is passed in by the caller ($1). It used to be read only # from LOKI_PRD_FILE / LOKI_ISSUE_REF, but `loki start ` writes # .loki/prd-issue-N.md and hands run.sh that path as a POSITIONAL argument, # so neither variable was ever set and this check could not fire. local spec="${1:-${LOKI_PRD_FILE:-}}" [ -n "${LOKI_ISSUE_REF:-}" ] && return 0 case "$spec" in *prd-issue-*) return 0 ;; esac return 1 } loki_apply_scoped_change_profile() { loki_detect_scoped_change "${1:-}" || return 0 # Off: cannot affect the correctness of a scoped change to existing code. : "${LOKI_PHASE_WEB_RESEARCH:=false}" : "${LOKI_PHASE_PERFORMANCE:=false}" : "${LOKI_PHASE_REGRESSION:=false}" : "${LOKI_PHASE_UAT:=false}" # On: every trust gate, unchanged. These are the moat. : "${LOKI_PHASE_CODE_REVIEW:=true}" : "${LOKI_PHASE_SECURITY:=true}" : "${LOKI_PHASE_UNIT_TESTS:=true}" : "${LOKI_PHASE_E2E_TESTS:=true}" export LOKI_PHASE_WEB_RESEARCH LOKI_PHASE_PERFORMANCE LOKI_PHASE_REGRESSION export LOKI_PHASE_UAT LOKI_PHASE_CODE_REVIEW LOKI_PHASE_SECURITY export LOKI_PHASE_UNIT_TESTS LOKI_PHASE_E2E_TESTS export LOKI_SCOPED_CHANGE_ACTIVE=1 } loki_apply_build_profile() { [ "${LOKI_BUILD_PROFILE:-}" = "simple-web" ] || return 0 : "${LOKI_PHASE_API_TESTS:=false}" : "${LOKI_PHASE_INTEGRATION:=false}" : "${LOKI_PHASE_PERFORMANCE:=false}" : "${LOKI_PHASE_REGRESSION:=false}" : "${LOKI_PHASE_UAT:=false}" : "${LOKI_PHASE_WEB_RESEARCH:=false}" : "${LOKI_PHASE_E2E_TESTS:=true}" : "${LOKI_PHASE_CODE_REVIEW:=true}" : "${LOKI_PHASE_SECURITY:=true}" : "${LOKI_PHASE_ACCESSIBILITY:=true}" # The hosted simple-web path is a measured execution policy, not an # operator preset. It removes only orchestration that cannot affect the # generated app, pins every model-bearing subcall to the selected model, # and keeps all applicable verification and proof gates fail closed. loki_is_supervised_simple_web || return 0 local selected_model sdk_model selected_model="$(printf '%s' "${LOKI_SESSION_MODEL:-sonnet}" | tr '[:upper:]' '[:lower:]')" case "$selected_model" in haiku|sonnet|opus) ;; *) selected_model="sonnet" ;; esac sdk_model="$selected_model" if command -v python3 >/dev/null 2>&1 && [ -r "$PROJECT_DIR/providers/model_catalog.json" ]; then sdk_model="$(_LOKI_SELECTED_MODEL="$selected_model" _LOKI_MODEL_CATALOG="$PROJECT_DIR/providers/model_catalog.json" python3 -c ' import json, os with open(os.environ["_LOKI_MODEL_CATALOG"], encoding="utf-8") as f: catalog = json.load(f) print(catalog["providers"]["claude"]["cli_aliases"].get(os.environ["_LOKI_SELECTED_MODEL"], "")) ' 2>/dev/null)" || sdk_model="" [ -n "$sdk_model" ] || sdk_model="$selected_model" fi LOKI_PHASE_UNIT_TESTS=true LOKI_PHASE_E2E_TESTS=true LOKI_PHASE_CODE_REVIEW=true LOKI_PHASE_SECURITY=true LOKI_PHASE_ACCESSIBILITY=true LOKI_COUNCIL_ENABLED=true LOKI_EVIDENCE_GATE=1 LOKI_PROOF_GATE=1 LOKI_PROOF=1 LOKI_DASHBOARD=false LOKI_PARALLEL_MODE=false LOKI_MAX_PARALLEL_AGENTS=1 LOKI_MAX_ITERATIONS=2 # MAX_RETRIES is the loop attempt ceiling, so 2 means an initial attempt # plus one targeted repair attempt. LOKI_MAX_RETRIES=2 LOKI_BASE_WAIT=2 LOKI_MAX_WAIT=10 LOKI_PROVIDER_CALL_TIMEOUT=240 LOKI_PROVIDER_IDLE_TIMEOUT=60 LOKI_DRAFT_EFFORT=medium # One low-effort requirements review gets a hard 90 second ceiling. The # prior 75 second ceiling clipped valid Haiku responses, while a second # identical full review doubled latency without adding evidence. LOKI_REVIEW_CALL_TIMEOUT=90 LOKI_SDK_REVIEW_TIMEOUT=90 LOKI_COUNCIL_REVIEW_TIMEOUT=90 LOKI_COUNCIL_TIMEOUT_MS=90000 LOKI_REVIEW_EFFORT=low LOKI_GATE_TIMEOUT=60 LOKI_DEPENDENCY_SETUP_TIMEOUT=60 LOKI_COUNCIL_MIN_ITERATIONS=1 LOKI_COUNCIL_CHECK_INTERVAL=1 LOKI_SPEC_GRILL=0 LOKI_DONE_RECOGNITION=0 LOKI_INTELLIGENT_USAGE=0 LOKI_PRD_ENRICH=0 LOKI_AUTO_DOCS=false LOKI_GATE_DOC_COVERAGE=false LOKI_GATE_MAGIC_DEBATE=false LOKI_WIKI_AUTO=0 LOKI_AUTO_FALLBACK=off LOKI_CAVEMAN=0 LOKI_CAVEMAN_AUTO_BOOTSTRAP=0 CAVEMAN_DEFAULT_MODE=off LOKI_FABLE_ARCHITECT=0 LOKI_LEGACY_TIER_SWITCHING=false LOKI_REVIEW_RETRY=0 LOKI_REVIEW_JSON_SCHEMA=off LOKI_REVIEW_REQUIREMENTS_ONLY=1 LOKI_GATE_DEVILS_ADVOCATE=false LOKI_REVIEW_INCONCLUSIVE_BLOCK=1 LOKI_EXPERIMENTAL_MANAGED_AGENTS=false LOKI_EXPERIMENTAL_MANAGED_REVIEW=false LOKI_EXPERIMENTAL_MANAGED_COUNCIL=false LOKI_COUNCIL_MODEL_VOTERS=0 LOKI_OVERRIDE_COUNCIL=0 LOKI_BUILD_CHECK_BLOCK=1 LOKI_SESSION_MODEL="$selected_model" LOKI_MAX_TIER="$selected_model" LOKI_MODEL_OVERRIDE="$selected_model" [ "$selected_model" = "haiku" ] && LOKI_ALLOW_HAIKU=true LOKI_ADVISOR_MODEL="$selected_model" LOKI_GRILL_MODEL="$selected_model" LOKI_CLAUDE_MODEL_PLANNING="$selected_model" LOKI_CLAUDE_MODEL_DEVELOPMENT="$selected_model" LOKI_CLAUDE_MODEL_FAST="$selected_model" LOKI_SDK_COUNCIL_MODEL="$sdk_model" LOKI_SDK_GRILL_MODEL="$sdk_model" LOKI_SDK_JUDGE_MODEL="$sdk_model" LOKI_SDK_PRD_ENRICH_MODEL="$sdk_model" LOKI_SDK_REVIEW_MODEL="$sdk_model" MAX_RETRIES="$LOKI_MAX_RETRIES" BASE_WAIT="$LOKI_BASE_WAIT" MAX_WAIT="$LOKI_MAX_WAIT" ENABLE_DASHBOARD="$LOKI_DASHBOARD" MAX_PARALLEL_AGENTS="$LOKI_MAX_PARALLEL_AGENTS" export LOKI_PHASE_UNIT_TESTS LOKI_PHASE_E2E_TESTS export LOKI_PHASE_CODE_REVIEW LOKI_PHASE_SECURITY LOKI_PHASE_ACCESSIBILITY export LOKI_COUNCIL_ENABLED LOKI_EVIDENCE_GATE LOKI_PROOF_GATE LOKI_PROOF export LOKI_DASHBOARD LOKI_PARALLEL_MODE LOKI_MAX_PARALLEL_AGENTS export LOKI_MAX_ITERATIONS LOKI_MAX_RETRIES LOKI_BASE_WAIT LOKI_MAX_WAIT export LOKI_PROVIDER_CALL_TIMEOUT LOKI_PROVIDER_IDLE_TIMEOUT LOKI_DRAFT_EFFORT export LOKI_REVIEW_CALL_TIMEOUT LOKI_SDK_REVIEW_TIMEOUT LOKI_REVIEW_EFFORT export LOKI_COUNCIL_REVIEW_TIMEOUT LOKI_COUNCIL_TIMEOUT_MS LOKI_GATE_TIMEOUT export LOKI_DEPENDENCY_SETUP_TIMEOUT export LOKI_COUNCIL_MIN_ITERATIONS LOKI_COUNCIL_CHECK_INTERVAL export LOKI_SPEC_GRILL LOKI_DONE_RECOGNITION LOKI_INTELLIGENT_USAGE LOKI_PRD_ENRICH export LOKI_AUTO_DOCS LOKI_GATE_DOC_COVERAGE LOKI_GATE_MAGIC_DEBATE export LOKI_WIKI_AUTO LOKI_AUTO_FALLBACK LOKI_CAVEMAN export LOKI_CAVEMAN_AUTO_BOOTSTRAP CAVEMAN_DEFAULT_MODE export LOKI_FABLE_ARCHITECT LOKI_LEGACY_TIER_SWITCHING LOKI_REVIEW_RETRY export LOKI_REVIEW_JSON_SCHEMA LOKI_REVIEW_REQUIREMENTS_ONLY LOKI_GATE_DEVILS_ADVOCATE export LOKI_REVIEW_INCONCLUSIVE_BLOCK LOKI_EXPERIMENTAL_MANAGED_AGENTS export LOKI_EXPERIMENTAL_MANAGED_REVIEW LOKI_EXPERIMENTAL_MANAGED_COUNCIL export LOKI_COUNCIL_MODEL_VOTERS LOKI_OVERRIDE_COUNCIL LOKI_BUILD_CHECK_BLOCK export LOKI_SESSION_MODEL LOKI_MAX_TIER LOKI_MODEL_OVERRIDE LOKI_ALLOW_HAIKU export LOKI_ADVISOR_MODEL LOKI_GRILL_MODEL export LOKI_CLAUDE_MODEL_PLANNING LOKI_CLAUDE_MODEL_DEVELOPMENT export LOKI_CLAUDE_MODEL_FAST LOKI_SDK_COUNCIL_MODEL LOKI_SDK_GRILL_MODEL export LOKI_SDK_JUDGE_MODEL LOKI_SDK_PRD_ENRICH_MODEL LOKI_SDK_REVIEW_MODEL } loki_apply_build_profile loki_apply_scoped_change_profile # Default hang guard for EVERY build, not just simple-web. # # The two timeouts above are set inside loki_apply_build_profile(), which # returns immediately unless LOKI_BUILD_PROFILE=simple-web. So on a normal # build both resolved to 0, and 0 means no guard at all -- verified by running # the deadline helper directly: `deadline.py 0 0 3 -- sleep 5` runs to # completion unkilled. A provider that hung had nothing to stop it. # # IDLE only, and no retry. That is what keeps this compatible with the standing # objection recorded above (search: "former invoke_with_timeout"), whose two # reasons remain correct: # # 1. "No safe generous default" applies to a fixed TOTAL timeout, which # cannot tell a long legitimate iteration from a hang. An idle timeout # can: it measures silence, not duration. Verified both directions -- # `sleep 600` under a 120s idle cap dies, while a process emitting output # every second survives indefinitely. A coding agent streams constantly; # one silent for two minutes is not working. # 2. "Wrong retry semantics" stands, so nothing here retries. The call is # killed, and the existing failure path handles it. Re-running an agent # that may have already edited files remains off the table. # # 7200s hard ceiling is a backstop against a process that streams forever # without converging; the idle cap is the load-bearing guard. Both are # overridable, and setting either to 0 restores the old unguarded behaviour. : "${LOKI_PROVIDER_IDLE_TIMEOUT:=120}" : "${LOKI_PROVIDER_CALL_TIMEOUT:=7200}" export LOKI_PROVIDER_IDLE_TIMEOUT LOKI_PROVIDER_CALL_TIMEOUT loki_background_services_enabled() { ! loki_is_supervised_simple_web } _loki_with_deadline() { local seconds="${1:-0}" local kill_grace="${LOKI_DEADLINE_KILL_GRACE:-2}" local idle_seconds="${LOKI_DEADLINE_IDLE_TIMEOUT:-0}" shift case "$seconds" in ''|*[!0-9]*) seconds=0 ;; esac case "$kill_grace" in ''|*[!0-9]*) kill_grace=2 ;; esac case "$idle_seconds" in ''|*[!0-9]*) idle_seconds=0 ;; esac [ "$kill_grace" -gt 0 ] 2>/dev/null || kill_grace=2 [ "$idle_seconds" -ge 0 ] 2>/dev/null || idle_seconds=0 if [ "$seconds" -le 0 ] 2>/dev/null; then "$@" elif command -v python3 >/dev/null 2>&1 \ && [ -r "${SCRIPT_DIR}/lib/deadline.py" ]; then python3 "${SCRIPT_DIR}/lib/deadline.py" \ "$seconds" "$kill_grace" "$idle_seconds" -- "$@" else log_error "Required command deadline cannot be enforced: deadline helper is unavailable" return 125 fi } _loki_with_deadline_stdin_text() { local seconds="${1:-0}" local input_text="${2:-}" local input_file rc=0 shift 2 input_file="$(mktemp "${TMPDIR:-/tmp}/loki-review-input.XXXXXX")" || return 125 chmod 600 "$input_file" 2>/dev/null || { rm -f "$input_file" 2>/dev/null || true return 125 } if ! printf '%s' "$input_text" > "$input_file"; then rm -f "$input_file" 2>/dev/null || true return 125 fi _loki_with_deadline "$seconds" "$@" < "$input_file" || rc=$? rm -f "$input_file" 2>/dev/null || true return "$rc" } _loki_snapshot_workspace_tree() { local tree="${1:-${TARGET_DIR:-.}}" local snapshot_dir snapshot_index index_tree snapshot_tree rc=0 snapshot_dir="$(mktemp -d "${TMPDIR:-/tmp}/loki-iter-index.XXXXXX")" || return 1 snapshot_index="$snapshot_dir/index" index_tree=$(git -C "$tree" write-tree 2>/dev/null) || rc=$? if [ "$rc" -eq 0 ]; then GIT_INDEX_FILE="$snapshot_index" git -C "$tree" read-tree "$index_tree" \ >/dev/null 2>&1 || rc=$? fi if [ "$rc" -eq 0 ]; then GIT_INDEX_FILE="$snapshot_index" git -C "$tree" add -A -- . ':(exclude).loki/' \ >/dev/null 2>&1 || rc=$? fi if [ "$rc" -eq 0 ]; then snapshot_tree=$(GIT_INDEX_FILE="$snapshot_index" git -C "$tree" write-tree 2>/dev/null) || rc=$? fi rm -f "$snapshot_index" "$snapshot_index.lock" 2>/dev/null || true rmdir "$snapshot_dir" 2>/dev/null || true [ "$rc" -eq 0 ] && [ -n "${snapshot_tree:-}" ] || return 1 printf '%s\n' "$snapshot_tree" } _loki_provider_pipeline_exit_code() { local provider_rc="${1:-125}" local tee_rc="${2:-125}" local parser_rc="${3:-0}" if [ "$provider_rc" -ne 0 ]; then printf '%s\n' "$provider_rc" elif [ "$tee_rc" -ne 0 ]; then printf '%s\n' "$tee_rc" else printf '%s\n' "$parser_rc" fi } _LOKI_DEPENDENCY_SETUP_LIB="${SCRIPT_DIR}/lib/dependency-setup.sh" if [ -r "$_LOKI_DEPENDENCY_SETUP_LIB" ]; then # shellcheck source=lib/dependency-setup.sh source "$_LOKI_DEPENDENCY_SETUP_LIB" fi _loki_workspace_changed_since_iteration() { local start_sha="$1" local tree="${TARGET_DIR:-.}" [ -n "$start_sha" ] || return 0 git -C "$tree" rev-parse --verify "$start_sha" >/dev/null 2>&1 || return 0 git -C "$tree" diff --quiet "$start_sha" -- >/dev/null 2>&1 case "$?" in 1) return 0 ;; 0) ;; *) return 0 ;; esac local untracked path untracked=$(git -C "$tree" ls-files --others --exclude-standard 2>/dev/null) || return 0 while IFS= read -r path; do [ -n "$path" ] || continue case "$path" in .loki|.loki/*) continue ;; *) return 0 ;; esac done << UNTRACKED_EOF $untracked UNTRACKED_EOF return 1 } _loki_supervised_claude_isolation_ready() { loki_is_supervised_simple_web || return 1 type loki_claude_flag_supported >/dev/null 2>&1 || return 1 loki_claude_flag_supported "--setting-sources" || return 1 loki_claude_flag_supported "--disallowedTools" || return 1 loki_claude_flag_supported "--tools" || return 1 loki_claude_flag_supported "--mcp-config" || return 1 loki_claude_flag_supported "--strict-mcp-config" || return 1 loki_claude_flag_supported "--disable-slash-commands" || return 1 } _loki_write_supervised_simple_web_policy() { loki_is_supervised_simple_web || return 0 local loki_dir="${LOKI_DIR:-${TARGET_DIR:-.}/.loki}" local policy_file="$loki_dir/state/execution-policy.json" mkdir -p "$(dirname "$policy_file")" || return 1 _LOKI_POLICY_FILE="$policy_file" \ _LOKI_POLICY_MODEL="${LOKI_SESSION_MODEL:-}" \ _LOKI_POLICY_MODEL_ID="${LOKI_SDK_REVIEW_MODEL:-}" \ _LOKI_POLICY_LEARNINGS="$loki_dir" \ _LOKI_POLICY_GIT_CONFIG="${GIT_CONFIG_GLOBAL:-}" \ _LOKI_POLICY_NODE_STATUS="$_LOKI_NODE_PROBE_STATUS" \ _LOKI_POLICY_NODE_VERSION="$_LOKI_NODE_PROBE_VERSION" \ _LOKI_POLICY_NPM_STATUS="$_LOKI_NPM_PROBE_STATUS" \ _LOKI_POLICY_NPM_VERSION="$_LOKI_NPM_PROBE_VERSION" \ python3 -c ' import json, os def number(name): try: return int(os.environ.get(name, "0")) except ValueError: return 0 target = os.environ["_LOKI_POLICY_FILE"] policy = { "schema_version": 1, "policy": "supervised-simple-web", "active": True, "fail_closed": True, "build_profile": "simple-web", "verification_status": "required_not_yet_proven", "model": { "alias": os.environ.get("_LOKI_POLICY_MODEL", ""), "sdk_id": os.environ.get("_LOKI_POLICY_MODEL_ID", ""), "max_tier": os.environ.get("LOKI_MAX_TIER", ""), "nested_task_tool": False, "fallback": False, }, "limits": { "iterations": number("LOKI_MAX_ITERATIONS"), "attempts": number("LOKI_MAX_RETRIES"), "provider_hard_seconds": number("LOKI_PROVIDER_CALL_TIMEOUT"), "provider_idle_seconds": number("LOKI_PROVIDER_IDLE_TIMEOUT"), "review_seconds": number("LOKI_REVIEW_CALL_TIMEOUT"), "council_seconds": number("LOKI_COUNCIL_REVIEW_TIMEOUT"), "gate_seconds": number("LOKI_GATE_TIMEOUT"), }, "skipped": [ "dashboard", "status_monitor", "resource_monitor", "enterprise_services", "spec_grill", "done_recognition", "prd_model_enrichment", "auto_docs", "auto_wiki", "caveman", "completion_model_voters", ], "required_gates": [ "production_build", "unit_tests", "browser_e2e", "accessibility", "security", "code_review", "completion_checklist", "completion_heldout", "completion_evidence", "completion_assumptions", "proof", ], "state": { "learnings_root": os.environ.get("_LOKI_POLICY_LEARNINGS", ""), "git_config_global": os.environ.get("_LOKI_POLICY_GIT_CONFIG", ""), "git_baseline_required": True, }, "runtime_probes": { "node": {"status": os.environ.get("_LOKI_POLICY_NODE_STATUS", ""), "version": os.environ.get("_LOKI_POLICY_NODE_VERSION", "")}, "npm": {"status": os.environ.get("_LOKI_POLICY_NPM_STATUS", ""), "version": os.environ.get("_LOKI_POLICY_NPM_VERSION", "")}, }, } tmp = target + ".tmp." + str(os.getpid()) with open(tmp, "w", encoding="utf-8") as f: json.dump(policy, f, indent=2, sort_keys=True) f.write("\n") os.replace(tmp, target) ' || return 1 log_info "Execution policy: $policy_file" } # 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} # F4: bound the runaway ceiling for ORDINARY runs. # # MEASURED, not chosen. Real per-iteration wall clock across every recorded run # on this machine: median 718s, max 1746s. So the 1000 default is an 8.3-DAY # ceiling -- and it is the ONLY backstop, because the other two valves ship # disabled: LOKI_BUDGET_LIMIT defaults to "" (check_budget_limit returns # immediately) and LOKI_MAX_DURATION defaults to 0 (check_max_duration returns # "never stop"). # # It also contradicts our own documentation. SETUP.md tells users to RAISE the # budget for large work with LOKI_MAX_ITERATIONS=40, and the demo uses 10 -- so # the shipped default is 25x the documented "large" setting. # # What real runs actually use: 1, 1, 3, 4. Every one terminated `completed` via # council approval or a completion promise; NONE hit a cap. Those are the # evidence-driven terminals, and they are unaffected by this -- the cap is a # backstop, not the mechanism. # # 25 is deliberately generous against that evidence (6x the observed maximum), # because the research is explicit that a too-small cap fails runs whose # approach was sound: 1-2 caps fail even when the agent was on track, and the # recommended range is 5-10. This is not a first-pass target; F0 (v8.45.0) # already stops a doomed run at its CAUSE, which is the better instrument. # # TWO GUARDS, both load-bearing: # - an explicit LOKI_MAX_ITERATIONS always wins, so nobody's setting changes # - PERPETUAL_MODE is untouched: it deliberately ignores every completion # signal and relies on max-iterations as its ONLY stop, so lowering the cap # there would silently truncate exactly the runs that opted out of stopping if [ -z "${LOKI_MAX_ITERATIONS:-}" ] \ && [ "$PERPETUAL_MODE" != "true" ] \ && [ "${LOKI_AUTO_FIX:-}" != "true" ]; then MAX_ITERATIONS="${LOKI_MAX_ITERATIONS_DEFAULT:-25}" fi # 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} # Nested-agent guard: the fixed testing/docs sub-streams each spawn a FURTHER # nested `claude` session in a NON-namespaced worktree (`-testing`, # `-docs`). When Loki itself runs inside another agent session (Claude # Code sets CLAUDECODE; the Loki Mode skill, or a user driving the CLI as a # background process from an agent), those nested spawns fight over the shared # checkout/worktree paths and flood the log -- the reported "N issues in one dir" # failure. So default the sub-streams OFF when nested; the core issue work still # runs. Explicit LOKI_PARALLEL_TESTING/DOCS=true overrides (opt back in). This # does NOT disable the user's own --parallel/--pr issue work, only the auxiliary # testing/docs fan-out that is unsafe to nest. _loki_nested_agent=false if [ -n "${CLAUDECODE:-}" ] || [ -n "${LOKI_NESTED_AGENT:-}" ]; then _loki_nested_agent=true fi if [ "$_loki_nested_agent" = "true" ]; then PARALLEL_TESTING=${LOKI_PARALLEL_TESTING:-false} PARALLEL_DOCS=${LOKI_PARALLEL_DOCS:-false} else PARALLEL_TESTING=${LOKI_PARALLEL_TESTING:-true} PARALLEL_DOCS=${LOKI_PARALLEL_DOCS:-true} fi # 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). LOKI_GATE_CLEAR_LIMIT is retained for # compatibility, but it is now the repeated-blocker escalation threshold. # A blocking gate is never cleared into a pass merely because it repeated. 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} # Tier-aware harness policy (model-equivalence experiment, Planned/Stage-3). # Given the resolved tier, export the steering-lever env vars UNLESS the operator # already set them (operator override ALWAYS wins). Gated on # LOKI_TIER_HARNESS_POLICY (default 0 = off) until Stage-2 ablation data justifies # the numbers. Pure env-export, no control flow. The table below is a STUB -- # replace with Stage-2 ablation-derived numbers (see # docs/MODEL-EQUIVALENCE-HARNESS-PLAN.md section 3). loki_apply_tier_harness_policy() { [ "${LOKI_TIER_HARNESS_POLICY:-0}" = "1" ] || return 0 local tier="$1" _iters _council _heal # STUB - replace with Stage-2 ablation-derived numbers. case "$tier" in haiku|fast) _iters=8; _council=true; _heal=1 ;; sonnet|development) _iters=5; _council=true; _heal=1 ;; opus|planning) _iters=3; _council=true; _heal=0 ;; *) return 0 ;; esac [ -z "${LOKI_MAX_ITERATIONS:-}" ] && export LOKI_MAX_ITERATIONS="$_iters" [ -z "${LOKI_COUNCIL_ENABLED:-}" ] && export LOKI_COUNCIL_ENABLED="$_council" [ -z "${LOKI_SELF_HEAL:-}" ] && export LOKI_SELF_HEAL="$_heal" } # 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. # Is this pid plausibly OUR dashboard, or a recycled number now naming something # else? Fails OPEN (returns 0) whenever ps cannot tell us, so the only behavior # change is refusing to kill a process that is positively identified as NOT a # dashboard. See the call site for the measured stale-file evidence. _loki_pid_looks_like_dashboard() { local _p="$1" _cmd case "$_p" in ''|*[!0-9]*) return 1 ;; esac [ "$_p" -gt 1 ] 2>/dev/null || return 1 # never signal pid 0/1 _cmd="$(ps -o command= -p "$_p" 2>/dev/null)" [ -n "$_cmd" ] || return 0 # ps unavailable: behave as before case "$_cmd" in *dashboard*|*uvicorn*|*loki*) return 0 ;; esac return 1 } 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) # Identity check before signalling. dashboard.pid is removed only on # the explicit stop paths (:16608, :16658, :17399) -- nothing covers # a crash, so the file outlives its dashboard. Measured in this very # checkout: .loki/dashboard/dashboard.pid held a DEAD 87992 with an # 8-day-old mtime. PIDs recycle, so a stale number eventually names # an unrelated LIVE process and this `kill -9` hits it. # # kill -0 is NOT sufficient: a recycled pid is alive by definition, # which is exactly the insufficiency the loki.pgid self-check had. # Mirrors _app_runner_pid_is_ours (app-runner.sh:242) and fails OPEN # the same way -- if `ps` says nothing we signal as before, so a # legitimate dashboard is never left running by this check. if [ -n "$_shared_pid" ] && _loki_pid_looks_like_dashboard "$_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: auto-detected when unset; claude > cline > codex > aider > opencode. # # WHY NOT `:-claude`. That default was a hard failure for anyone who has Codex # but not Claude: run.sh would select a provider that is not installed and die, # even though auto_detect_provider() has existed in providers/loader.sh -- with # the right priority order and its own passing test -- since v5.0.0. Nothing in # production ever called it. Detection was built, tested, and never wired. # # An EXPLICIT choice still wins: this only fills an unset value, so # LOKI_PROVIDER=codex and --provider codex are untouched. _LOKI_PROVIDER_WAS_EXPLICIT=1 [ -z "${LOKI_PROVIDER:-}" ] && _LOKI_PROVIDER_WAS_EXPLICIT=0 # Source provider configuration PROVIDERS_DIR="$PROJECT_DIR/providers" if [ -f "$PROVIDERS_DIR/loader.sh" ]; then # shellcheck source=/dev/null source "$PROVIDERS_DIR/loader.sh" # Detect only when the operator expressed no preference. Sourcing the # loader first is required -- auto_detect_provider() is defined there. if [ "$_LOKI_PROVIDER_WAS_EXPLICIT" -eq 0 ]; then _detected="$(auto_detect_provider 2>/dev/null || true)" if [ -n "$_detected" ]; then LOKI_PROVIDER="$_detected" echo "[loki] provider: $LOKI_PROVIDER (auto-detected)" >&2 else # Nothing installed. Keep the historical default so the existing # "not installed" error path reports claude, which is the actionable # message -- rather than an empty provider name. LOKI_PROVIDER=claude fi fi # 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=() declare -A WORKTREE_BASE_SHAS=() else # Fallback: parallel mode will check and warn # shellcheck disable=SC2178 WORKTREE_PIDS="" # shellcheck disable=SC2178 WORKTREE_PATHS="" # shellcheck disable=SC2178 WORKTREE_BASE_SHAS="" 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}" } # VERBOSITY. LOKI_LOG_LEVEL is one of debug|info|warn|error (default info); # LOKI_QUIET=1 is shorthand for warn. # # Implemented at these five functions rather than at 527 call sites, which is # both the smaller diff and the only version that cannot drift -- a new # log_info added next year is covered without anyone remembering to gate it. # # WHY THIS IS NEEDED DESPITE GOOD TTY DETECTION. The heavy decoration (HUD, # completion card, start headline) is already `[ -t 1 ]`-guarded and vanishes # off a TTY, so CI output was never the wall of banners it might have been. # But 527 log_info/log_step calls are unguarded and print regardless, and a # pipeline that wants only warnings had no way to ask. log_debug already # honored LOKI_DEBUG; the other levels honored nothing. # # ERRORS ARE NEVER SUPPRESSED. `error` is the floor: the quietest setting still # prints failures. A verbosity flag that can hide the reason a build failed is # a footgun, not a feature. _loki_log_threshold() { case "${LOKI_LOG_LEVEL:-$([ "${LOKI_QUIET:-0}" = "1" ] && echo warn || echo info)}" in debug) echo 0 ;; info) echo 1 ;; warn) echo 2 ;; error) echo 3 ;; *) echo 1 ;; # unrecognized value behaves as the default, never silences esac } _loki_log_enabled() { [ "$1" -ge "$(_loki_log_threshold)" ]; } log_info() { _loki_log_enabled 1 && echo -e "${GREEN}[INFO]${NC} $*" || true; } log_warn() { _loki_log_enabled 2 && echo -e "${YELLOW}[WARN]${NC} $*" || true; } log_warning() { log_warn "$@"; } # Alias for backwards compatibility log_error() { echo -e "${RED}[ERROR]${NC} $*"; } log_step() { _loki_log_enabled 1 && echo -e "${CYAN}[STEP]${NC} $*" || true; } 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_archive_last_error # LEARN-FORWARD: append a prior run's LAST_ERROR record to an append-only, # bounded failure-history so the next run can detect a REPEATED failure signature # (same error_class recurring) even though the single LAST_ERROR.json is cleared # each run. No-op when there is no prior error. Bounded to the most recent 50 # entries so it never grows unbounded. Best-effort; never fails the run. _loki_archive_last_error() { local src="${1:-}" local hist="${2:-}" [ -n "$src" ] && [ -n "$hist" ] || return 0 [ -f "$src" ] || return 0 LOKI_AE_SRC="$src" LOKI_AE_HIST="$hist" python3 -c " import json, os, tempfile src = os.environ['LOKI_AE_SRC'] hist = os.environ['LOKI_AE_HIST'] try: with open(src) as f: rec = json.load(f) if not isinstance(rec, dict): raise ValueError('bad record') lines = [] if os.path.exists(hist): try: with open(hist) as hf: lines = [ln for ln in hf.read().splitlines() if ln.strip()] except Exception: lines = [] lines.append(json.dumps(rec, separators=(',', ':'))) lines = lines[-50:] d = os.path.dirname(hist) or '.' fd, tmp = tempfile.mkstemp(dir=d, suffix='.jsonl') with os.fdopen(fd, 'w') as f: f.write('\n'.join(lines) + '\n') os.replace(tmp, hist) 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_build_self_heal_hint (SLICE 6c): route the PRIOR iteration's classified # error signature into the NEXT iteration's prompt so the loop fixes forward. # Reads .loki/state/LAST_ERROR.json (written by _loki_write_last_error on a # failed iteration), emits a concise structured heal hint naming the error_class # + brief on stdout, then ARCHIVES-then-CLEARS the record so the hint injects # exactly ONCE (reuses the existing archive-then-clear pattern; it does not # repeat forever). Best-effort: any failure emits nothing and never crashes the # build. # # Gated by the caller on LOKI_SELF_HEAL (default 0 -- opt-in, stock runs # unaffected). "unknown" is treated as NOT actionable (no specific class to # target), so an unclassified failure produces no hint. # Usage: _loki_build_self_heal_hint (echoes hint or nothing) _loki_build_self_heal_hint() { local loki_dir="${TARGET_DIR:-.}/.loki" local src="$loki_dir/state/LAST_ERROR.json" [ -f "$src" ] || return 0 local hint hint="$(_LOKI_SH_SRC="$src" python3 -c " import json, os try: with open(os.environ['_LOKI_SH_SRC']) as f: rec = json.load(f) if not isinstance(rec, dict): raise SystemExit ec = str(rec.get('error_class', '') or '').strip() if ec in ('', 'unknown'): raise SystemExit brief = str(rec.get('brief', '') or '').strip() it = rec.get('iteration', '?') print('SELF_HEAL_HINT: the previous iteration (#%s) failed with error_class=%s. %s Address this specific failure FIRST before any new work.' % (it, ec, brief)) except SystemExit: pass except Exception: pass " 2>/dev/null || true)" [ -n "$hint" ] || return 0 # Archive-then-clear so it injects once (LEARN-FORWARD: the lesson still # lands in failure-history.jsonl before the single record is removed). _loki_archive_last_error "$src" "$loki_dir/state/failure-history.jsonl" 2>/dev/null || true rm -f "$src" 2>/dev/null || true printf '%s' "$hint" 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