justfile

# A3S Code - Justfile

default:
    @just --list

# ============================================================================
# Build
# ============================================================================

# Build the project
build:
    cargo build --workspace

# Build release
release:
    cargo build --workspace --release

# ============================================================================
# Test (unified command with progress display)
# ============================================================================

# Run all tests with progress display and module breakdown
test:
    #!/usr/bin/env bash
    set -e

    # Colors
    BOLD='\033[1m'
    GREEN='\033[0;32m'
    BLUE='\033[0;34m'
    CYAN='\033[0;36m'
    YELLOW='\033[0;33m'
    RED='\033[0;31m'
    DIM='\033[2m'
    RESET='\033[0m'

    # Counters
    TOTAL_PASSED=0
    TOTAL_FAILED=0
    TOTAL_IGNORED=0

    print_header() {
        echo ""
        echo -e "${BOLD}${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
        echo -e "${BOLD}  $1${RESET}"
        echo -e "${BOLD}${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
    }

    # Extract module test counts from cargo test output
    extract_module_counts() {
        local output="$1"
        echo "$output" | grep -E "^test .+::.+ \.\.\. ok$" | \
            sed 's/^test \([^:]*\)::.*/\1/' | \
            sort | uniq -c | sort -rn | \
            while read count module; do
                printf "      ${DIM}%-20s %3d tests${RESET}\n" "$module" "$count"
            done
    }

    run_crate_tests() {
        local crate_name="$1"
        local display_name="$2"

        echo -ne "${CYAN}▶${RESET} ${BOLD}${display_name}${RESET} "

        if OUTPUT=$(cargo test -p "$crate_name" 2>&1); then
            TEST_EXIT=0
        else
            TEST_EXIT=1
        fi

        RESULT_LINES=$(echo "$OUTPUT" | grep -E "^test result:" || true)
        if [ -n "$RESULT_LINES" ]; then
            PASSED=$(echo "$RESULT_LINES" | grep -oE '[0-9]+ passed' | grep -oE '[0-9]+' | awk '{ total += $1 } END { print total + 0 }')
            FAILED=$(echo "$RESULT_LINES" | grep -oE '[0-9]+ failed' | grep -oE '[0-9]+' | awk '{ total += $1 } END { print total + 0 }')
            IGNORED=$(echo "$RESULT_LINES" | grep -oE '[0-9]+ ignored' | grep -oE '[0-9]+' | awk '{ total += $1 } END { print total + 0 }')

            TOTAL_PASSED=$((TOTAL_PASSED + PASSED))
            TOTAL_FAILED=$((TOTAL_FAILED + FAILED))
            TOTAL_IGNORED=$((TOTAL_IGNORED + IGNORED))

            if [ "$FAILED" -gt 0 ]; then
                echo -e "${RED}✗${RESET} ${DIM}$PASSED passed, $FAILED failed${RESET}"
                echo "$OUTPUT" | grep -E "^test .* FAILED$" | sed 's/^/    /'
            else
                echo -e "${GREEN}✓${RESET} ${DIM}$PASSED passed${RESET}"
                if [ "$PASSED" -gt 10 ]; then
                    extract_module_counts "$OUTPUT"
                fi
            fi
        else
            if echo "$OUTPUT" | grep -q "error\[E"; then
                echo -e "${RED}✗${RESET} ${DIM}compile error${RESET}"
                echo "$OUTPUT" | grep -E "^error" | head -3 | sed 's/^/    /'
            elif [ "$TEST_EXIT" -ne 0 ]; then
                echo -e "${RED}✗${RESET} ${DIM}failed${RESET}"
            else
                echo -e "${YELLOW}○${RESET} ${DIM}no tests${RESET}"
            fi
        fi
    }

    print_header "🧪 A3S Code Test Suite"
    echo ""

    run_crate_tests "a3s-code-core" "a3s-code-core"

    # Summary
    echo ""
    echo -e "${BOLD}${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"

    if [ "$TOTAL_FAILED" -gt 0 ]; then
        echo -e "  ${RED}${BOLD}✗ FAILED${RESET}  ${GREEN}$TOTAL_PASSED passed${RESET}  ${RED}$TOTAL_FAILED failed${RESET}  ${YELLOW}$TOTAL_IGNORED ignored${RESET}"
        echo -e "${BOLD}${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
        exit 1
    else
        echo -e "  ${GREEN}${BOLD}✓ PASSED${RESET}  ${GREEN}$TOTAL_PASSED passed${RESET}  ${YELLOW}$TOTAL_IGNORED ignored${RESET}"
        echo -e "${BOLD}${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
    fi
    echo ""

# Run tests without progress (raw cargo output)
test-raw:
    cargo test --workspace

# Run tests with verbose output
test-v:
    cargo test --workspace -- --nocapture

# ============================================================================
# Test Subsets
# ============================================================================

# Run core tests only
test-core:
    cargo test -p a3s-code-core --lib

# Run queue and HITL tests
test-queue:
    cargo test -p a3s-code-core --lib -- queue::tests hitl::tests

# Run queue tests only
test-queue-only:
    cargo test -p a3s-code-core --lib -- queue::tests

# Run HITL tests only (hitl module)
test-hitl:
    cargo test -p a3s-code-core --lib -- hitl::tests

# Run HITL tests in agent loop (agent module)
test-agent-hitl:
    cargo test -p a3s-code-core --lib -- agent::tests::test_agent_hitl

# Run all HITL-related tests (hitl + agent)
test-hitl-all:
    cargo test -p a3s-code-core --lib -- hitl::tests agent::tests::test_agent_hitl

# Run session tests (includes queue/HITL integration)
test-session:
    cargo test -p a3s-code-core --lib -- session::tests

# Run agent tests
test-agent:
    cargo test -p a3s-code-core --lib -- agent::tests

# Run context provider tests
test-context:
    cargo test -p a3s-code-core --lib -- test_context test_agent_context test_session_context

# ============================================================================
# Coverage (requires: cargo install cargo-llvm-cov, brew install lcov)

# F-table kernel line coverage (integration-bearing). Default gate ≥95%.
# Evidence: $A3S_F_TABLE_EVIDENCE/FINAL.txt → ALL_F_TABLE_KERNELS_GE_95
f-table-cov:
    #!/usr/bin/env bash
    set -euo pipefail
    export A3S_F_TABLE_MIN_LINE_PCT="${A3S_F_TABLE_MIN_LINE_PCT:-95}"
    export A3S_F_TABLE_EVIDENCE="${A3S_F_TABLE_EVIDENCE:-/tmp/a3s-llvm-cov-f${A3S_F_TABLE_MIN_LINE_PCT}}"
    scripts/f_table_coverage.sh

# ============================================================================

# Test with coverage - shows real-time test progress + module coverage
test-cov:
    #!/usr/bin/env bash
    set -e

    # Colors
    BOLD='\033[1m'
    GREEN='\033[0;32m'
    BLUE='\033[0;34m'
    CYAN='\033[0;36m'
    YELLOW='\033[0;33m'
    RED='\033[0;31m'
    DIM='\033[2m'
    RESET='\033[0m'

    CLEAR_LINE='\033[2K'

    print_header() {
        echo ""
        echo -e "${BOLD}${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
        echo -e "${BOLD}  $1${RESET}"
        echo -e "${BOLD}${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
    }

    print_header "🧪 A3S Code Test Suite with Coverage"
    echo ""
    echo -e "${CYAN}▶${RESET} ${BOLD}a3s-code-core${RESET}"
    echo ""

    tmp_dir="/tmp/test_cov_code_$$"
    mkdir -p "$tmp_dir"
    touch "$tmp_dir/module_counts"

    {
        cargo llvm-cov --workspace --lib 2>&1
    } | {
        total_passed=0
        total_failed=0

        while IFS= read -r line; do
            if [[ "$line" =~ ^test\ ([a-z_]+)::.*\.\.\.\ (ok|FAILED)$ ]]; then
                module="${BASH_REMATCH[1]}"
                result="${BASH_REMATCH[2]}"

                if [ "$result" = "ok" ]; then
                    total_passed=$((total_passed + 1))
                    count=$(grep "^${module} " "$tmp_dir/module_counts" 2>/dev/null | awk '{print $2}' || echo "0")
                    count=$((count + 1))
                    grep -v "^${module} " "$tmp_dir/module_counts" > "$tmp_dir/module_counts.tmp" 2>/dev/null || true
                    echo "$module $count" >> "$tmp_dir/module_counts.tmp"
                    mv "$tmp_dir/module_counts.tmp" "$tmp_dir/module_counts"
                else
                    total_failed=$((total_failed + 1))
                fi

                echo -ne "\r${CLEAR_LINE}      ${DIM}Running:${RESET} ${module}::... ${GREEN}${total_passed}${RESET} passed"
                [ "$total_failed" -gt 0 ] && echo -ne " ${RED}${total_failed}${RESET} failed"

            elif [[ "$line" =~ ^[[:space:]]*Compiling ]]; then
                echo -ne "\r${CLEAR_LINE}      ${DIM}Compiling...${RESET}"
            elif [[ "$line" =~ ^[[:space:]]*Running ]]; then
                echo -ne "\r${CLEAR_LINE}      ${DIM}Running tests...${RESET}"
            elif [[ "$line" =~ ^[a-z_]+.*\.rs[[:space:]] ]]; then
                echo "$line" >> "$tmp_dir/coverage_lines"
            elif [[ "$line" =~ ^TOTAL ]]; then
                echo "$line" >> "$tmp_dir/total_line"
            fi
        done

        echo "$total_passed" > "$tmp_dir/total_passed"
        echo "$total_failed" > "$tmp_dir/total_failed"
    }

    echo -ne "\r${CLEAR_LINE}"

    total_passed=$(cat "$tmp_dir/total_passed" 2>/dev/null || echo "0")
    total_failed=$(cat "$tmp_dir/total_failed" 2>/dev/null || echo "0")

    if [ "$total_failed" -gt 0 ]; then
        echo -e "      ${RED}✗${RESET} ${total_passed} passed, ${RED}${total_failed} failed${RESET}"
    else
        echo -e "      ${GREEN}✓${RESET} ${total_passed} tests passed"
    fi
    echo ""

    if [ -f "$tmp_dir/coverage_lines" ]; then
        awk '
        {
            file=$1; lines=$8; missed=$9
            n = split(file, parts, "/")
            if (n > 1) {
                module = parts[1]
            } else {
                gsub(/\.rs$/, "", file)
                module = file
            }
            total_lines[module] += lines
            total_missed[module] += missed
        }
        END {
            for (m in total_lines) {
                if (total_lines[m] > 0) {
                    covered = total_lines[m] - total_missed[m]
                    pct = (covered / total_lines[m]) * 100
                    printf "%s %.1f %d\n", m, pct, total_lines[m]
                }
            }
        }' "$tmp_dir/coverage_lines" | sort -t' ' -k2 -rn > "$tmp_dir/cov_agg"

        echo -e "      ${BOLD}Module               Tests   Coverage${RESET}"
        echo -e "      ${DIM}──────────────────────────────────────────────${RESET}"

        while read module pct lines; do
            tests=$(grep "^${module} " "$tmp_dir/module_counts" 2>/dev/null | awk '{print $2}' || echo "0")
            [ -z "$tests" ] && tests=0

            num=${pct%.*}
            if [ "$num" -ge 90 ]; then
                cov_color="${GREEN}${pct}%${RESET}"
            elif [ "$num" -ge 70 ]; then
                cov_color="${YELLOW}${pct}%${RESET}"
            else
                cov_color="${RED}${pct}%${RESET}"
            fi
            echo -e "      $(printf '%-18s' "$module") $(printf '%4d' "$tests")   ${cov_color} ${DIM}($lines lines)${RESET}"
        done < "$tmp_dir/cov_agg"

        if [ -f "$tmp_dir/total_line" ]; then
            total_cov=$(cat "$tmp_dir/total_line" | awk '{print $4}' | tr -d '%')
            total_lines=$(cat "$tmp_dir/total_line" | awk '{print $8}')
            echo -e "      ${DIM}──────────────────────────────────────────────${RESET}"

            num=${total_cov%.*}
            if [ "$num" -ge 90 ]; then
                cov_color="${GREEN}${BOLD}${total_cov}%${RESET}"
            elif [ "$num" -ge 70 ]; then
                cov_color="${YELLOW}${BOLD}${total_cov}%${RESET}"
            else
                cov_color="${RED}${BOLD}${total_cov}%${RESET}"
            fi
            echo -e "      ${BOLD}$(printf '%-18s' "TOTAL") $(printf '%4d' "$total_passed")${RESET}   ${cov_color} ${DIM}($total_lines lines)${RESET}"
        fi
    fi

    rm -rf "$tmp_dir"
    echo ""
    echo -e "${BOLD}${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
    echo ""

# Coverage with pretty terminal output
cov:
    #!/usr/bin/env bash
    set -e
    COV_FILE="/tmp/a3s-code-coverage.lcov"
    echo "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓"
    echo "┃                    🧪 Running Tests with Coverage                     ┃"
    echo "┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛"
    cargo llvm-cov --workspace --lib --lcov --output-path "$COV_FILE" 2>&1 | grep -E "^test result"
    echo ""
    echo "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓"
    echo "┃                         📊 Coverage Report                            ┃"
    echo "┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛"
    lcov --summary "$COV_FILE" 2>&1
    rm -f "$COV_FILE"

# Coverage for specific module
cov-module MOD:
    cargo llvm-cov -p a3s-code-core --lib -- {{MOD}}::

# Coverage with HTML report (opens in browser)
cov-html:
    cargo llvm-cov --workspace --lib --html --open

# Coverage with detailed file-by-file table
cov-table:
    cargo llvm-cov --workspace --lib

# Coverage for CI (generates lcov.info)
cov-ci:
    cargo llvm-cov --workspace --lib --lcov --output-path lcov.info

# ============================================================================
# Code Quality
# ============================================================================

# Format code
fmt:
    cargo fmt --all

# Lint (clippy)
lint:
    cargo clippy --workspace --all-targets -- -D warnings

# CI checks (fmt + lint + test)
ci:
    cargo fmt --all -- --check
    cargo clippy --workspace --all-targets -- -D warnings
    cargo test --workspace
    cargo test --workspace --all-features --lib

# ============================================================================
# Utilities
# ============================================================================

# Clean build artifacts
clean:
    cargo clean

# Check project (fast compile check)
check:
    cargo check --workspace

# Watch and rebuild
watch:
    cargo watch -x 'build --workspace'

# Generate docs
doc:
    cargo doc --workspace --no-deps --open

# ============================================================================
# Publish
# ============================================================================

# Publish a3s-code-core to crates.io
publish:
    #!/usr/bin/env bash
    set -e

    BOLD='\033[1m'
    GREEN='\033[0;32m'
    BLUE='\033[0;34m'
    RED='\033[0;31m'
    DIM='\033[2m'
    RESET='\033[0m'

    print_step() { echo -e "${BLUE}▶${RESET} ${BOLD}$1${RESET}"; }
    print_success() { echo -e "${GREEN}✓${RESET} $1"; }
    print_error() { echo -e "${RED}✗${RESET} $1"; exit 1; }

    echo ""
    echo -e "${BOLD}${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
    echo -e "${BOLD}  📦 Publishing a3s-code-core to crates.io${RESET}"
    echo -e "${BOLD}${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
    echo ""

    CORE_VERSION=$(grep '^version' core/Cargo.toml | head -1 | sed 's/.*"\(.*\)".*/\1/')
    echo -e "  ${DIM}a3s-code-core:${RESET} ${BOLD}${CORE_VERSION}${RESET}"
    echo ""

    print_step "Checking version sync..."
    just check-versions || { print_error "Version mismatch. Run 'just bump-version <version>' to fix."; }

    print_step "Checking formatting..."
    cargo fmt --all -- --check && print_success "Formatting OK" || print_error "Run 'just fmt' first."

    print_step "Running clippy..."
    cargo clippy --workspace --all-targets -- -D warnings && print_success "Clippy OK" || print_error "Fix warnings first."

    print_step "Running tests..."
    cargo test --workspace --lib && print_success "Tests OK" || print_error "Tests failed."

    print_step "Publishing a3s-code-core..."
    cargo publish -p a3s-code-core && print_success "a3s-code-core published" || print_error "Failed to publish core."

    echo ""
    echo -e "${BOLD}${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
    echo -e "  ${GREEN}${BOLD}✓ Published a3s-code-core v${CORE_VERSION}${RESET}"
    echo -e "${BOLD}${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
    echo ""

# Publish dry-run (verify without publishing)
publish-dry:
    cargo publish -p a3s-code-core --dry-run

# Show current version of all packages
version:
    #!/usr/bin/env bash
    CANONICAL=$(grep '^version' core/Cargo.toml | head -1 | sed 's/.*"\(.*\)".*/\1/')
    echo "core/Cargo.toml           ${CANONICAL}"
    echo "sdk/node/Cargo.toml       $(grep '^version' sdk/node/Cargo.toml | head -1 | sed 's/.*"\(.*\)".*/\1/')"
    echo "sdk/node/package.json     $(grep '"version"' sdk/node/package.json | head -1 | sed 's/.*"\([0-9.]*\)".*/\1/')"
    echo "sdk/python/Cargo.toml     $(grep '^version' sdk/python/Cargo.toml | head -1 | sed 's/.*"\(.*\)".*/\1/')"
    echo "sdk/python/pyproject.toml $(grep '^version' sdk/python/pyproject.toml | head -1 | sed 's/.*"\(.*\)".*/\1/')"

# Check all package version files are in sync with core/Cargo.toml
check-versions:
    #!/usr/bin/env bash
    set -e

    GREEN='\033[0;32m'
    RED='\033[0;31m'
    BOLD='\033[1m'
    DIM='\033[2m'
    RESET='\033[0m'

    CANONICAL=$(grep '^version' core/Cargo.toml | head -1 | sed 's/.*"\(.*\)".*/\1/')

    echo ""
    echo -e "${BOLD}Version sync check — canonical: ${CANONICAL}${RESET}"
    echo ""

    FAIL=0
    check() {
        local label="$1"
        local actual="$2"
        if [ "$actual" = "$CANONICAL" ]; then
            echo -e "  ${GREEN}✓${RESET}  $(printf '%-35s' "$label") ${DIM}${actual}${RESET}"
        else
            echo -e "  ${RED}✗${RESET}  $(printf '%-35s' "$label") ${RED}${actual}${RESET}  ← expected ${CANONICAL}"
            FAIL=1
        fi
    }

    check "core/Cargo.toml"           "$(grep '^version' core/Cargo.toml           | head -1 | sed 's/.*"\(.*\)".*/\1/')"
    check "sdk/node/Cargo.toml"       "$(grep '^version' sdk/node/Cargo.toml       | head -1 | sed 's/.*"\(.*\)".*/\1/')"
    check "sdk/node/package.json"     "$(grep '"version"' sdk/node/package.json    | head -1 | sed 's/.*"\([0-9.]*\)".*/\1/')"
    check "sdk/python/Cargo.toml"     "$(grep '^version' sdk/python/Cargo.toml     | head -1 | sed 's/.*"\(.*\)".*/\1/')"
    check "sdk/python/pyproject.toml" "$(grep '^version' sdk/python/pyproject.toml | head -1 | sed 's/.*"\(.*\)".*/\1/')"

    echo ""
    if [ "$FAIL" -ne 0 ]; then
        echo -e "  ${RED}${BOLD}Version mismatch detected. Run 'just bump-version <version>' to sync all files.${RESET}"
        echo ""
        exit 1
    else
        echo -e "  ${GREEN}${BOLD}All versions in sync ✓${RESET}"
        echo ""
    fi

# Bump version across all package files atomically
bump-version VERSION:
    #!/usr/bin/env bash
    set -e

    GREEN='\033[0;32m'
    BOLD='\033[1m'
    DIM='\033[2m'
    RESET='\033[0m'

    V="{{VERSION}}"

    echo ""
    echo -e "${BOLD}Bumping all packages to ${V}${RESET}"
    echo ""

    bump_toml() {
        local file="$1"
        sed -i.bak "s/^version = \".*\"/version = \"${V}\"/" "$file" && rm -f "${file}.bak"
        echo -e "  ${GREEN}✓${RESET}  ${DIM}${file}${RESET}"
    }
    bump_json() {
        local file="$1"
        sed -i.bak "s/\"version\": \".*\"/\"version\": \"${V}\"/" "$file" && rm -f "${file}.bak"
        echo -e "  ${GREEN}✓${RESET}  ${DIM}${file}${RESET}"
    }

    bump_toml core/Cargo.toml
    bump_toml sdk/node/Cargo.toml
    bump_json sdk/node/package.json
    bump_toml sdk/python/Cargo.toml
    bump_toml sdk/python/pyproject.toml

    echo ""
    just check-versions

# ============================================================================
# Harness convergence wrap-up
# ============================================================================

# Thin default + local-code CI matrix used by HARNESS-CONV5/CONV7 wrap-up
harness-convergence-check:
    #!/usr/bin/env bash
    set -euo pipefail
    cargo check -p a3s-code-core
    if cargo tree -p a3s-code-core -e normal | rg -i 'evaluation|research|chromiumoxide|aws-sdk-s3'; then
      echo "default Core tree must not pull Advanced/server stacks" >&2
      exit 1
    fi
    cargo check -p a3s-code-core --no-default-features --features local-code
    cargo test -p a3s-code-core --no-default-features --features local-code --lib
    cargo test -p a3s-code-core --lib parallel_task -- --nocapture
    cargo test -p a3s-code-core --lib candidate_write_stays_inactive -- --nocapture
    node scripts/sdk_api_alignment_check.mjs

# Full Layer C live E2E against monorepo `.a3s/config.acl` (serial; quota + network).
# Evidence dir: set A3S_LAYER_C_EVIDENCE or defaults to /tmp/a3s-layer-c-live.
# Pins A3S_TEST_MODEL to boyue/deepseek-v4-flash unless already set.
layer-c-live-e2e:
    #!/usr/bin/env bash
    set -euo pipefail
    ROOT="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"
    # Prefer monorepo root config when invoked from crates/code submodule.
    if [[ -f "${ROOT}/../../.a3s/config.acl" ]]; then
      CONFIG="$(cd "${ROOT}/../.." && pwd)/.a3s/config.acl"
    elif [[ -f "${ROOT}/.a3s/config.acl" ]]; then
      CONFIG="${ROOT}/.a3s/config.acl"
    else
      CONFIG="${A3S_CONFIG_FILE:?set A3S_CONFIG_FILE to an ACL with boyue Flash}"
    fi
    EVIDENCE="${A3S_LAYER_C_EVIDENCE:-/tmp/a3s-layer-c-live}"
    mkdir -p "${EVIDENCE}"
    : >"${EVIDENCE}/summary.txt"
    export A3S_CONFIG_FILE="${CONFIG}"
    export A3S_TEST_MODEL="${A3S_TEST_MODEL:-boyue/deepseek-v4-flash}"
    # Linux native sandbox masks $HOME; nvm/fnm toolchains must be re-allowed
    # via NVM_DIR/FNM_DIR (see a3s-sandbox readable_tool_paths) or `node` is
    # invisible inside bwrap and long-horizon bash verification stays exit 1.
    if [[ -z "${NVM_DIR:-}" && -d "${HOME}/.nvm" ]]; then
      export NVM_DIR="${HOME}/.nvm"
    fi
    if [[ -n "${NVM_DIR:-}" && -d "${NVM_DIR}/versions/node" ]]; then
      node_bin="$(ls -d "${NVM_DIR}"/versions/node/*/bin 2>/dev/null | sort -V | tail -n1 || true)"
      if [[ -n "${node_bin}" ]]; then
        export PATH="${node_bin}:${PATH}"
      fi
    fi
    echo "A3S_CONFIG_FILE=${A3S_CONFIG_FILE}" | tee "${EVIDENCE}/env.txt"
    echo "A3S_TEST_MODEL=${A3S_TEST_MODEL}" | tee -a "${EVIDENCE}/env.txt"
    echo "NVM_DIR=${NVM_DIR:-}" | tee -a "${EVIDENCE}/env.txt"
    rg -n '^default_model' "${A3S_CONFIG_FILE}" | tee -a "${EVIDENCE}/env.txt"
    rg -n 'deepseek-v4-flash' "${A3S_CONFIG_FILE}" | head -5 | tee -a "${EVIDENCE}/env.txt"
    suites=(
      test_native_sandbox_live_e2e
      test_issue_fix_live_e2e
      test_agent_protocol_live_e2e
      test_harness_loop_live_e2e
      test_fact_log_real_llm
      test_complex_capability_live_e2e
      test_harness_capabilities_live_e2e
      test_meta_harness_compose_live_e2e
      test_deepseek_adversarial_e2e
      test_update_plan_live_e2e
      test_prompt_capability_real_llm
      test_orchestration_real_llm
      test_long_horizon_real_llm
      test_structured_json_real_llm
      test_run_control_real_llm
      test_workspace_search_real_llm
      test_workspace_retrieval_real_llm
      test_context_tools_real_llm
      test_workflow_facade_real_llm
      test_auto_delegation_real_parallel
      test_ultracode_discretion_real_llm
      test_real_config_env_integration
      test_real_llm_cluster_features
      test_memory_store_real_llm
    )
    fail=0
    run_suite() {
      local suite="$1" features="$2"
      local feature_flags=()
      if [[ -n "${features}" ]]; then
        feature_flags=(--features "${features}")
      fi
      echo "=== ${suite} ===" | tee -a "${EVIDENCE}/summary.txt"
      if cargo test -p a3s-code-core ${feature_flags[@]+"${feature_flags[@]}"} --test "${suite}" -- --ignored --test-threads=1 --nocapture \
          >"${EVIDENCE}/${suite}.log" 2>&1; then
        echo "PASS ${suite}" | tee -a "${EVIDENCE}/summary.txt"
        return 0
      fi
      echo "FAIL ${suite}" | tee -a "${EVIDENCE}/summary.txt"
      # One bounded retry: a single live-model turn may answer outside the
      # shape a suite pins (temperature 0 does not fix model variance). A
      # suite that fails twice is a real regression, not variance.
      echo "RETRY ${suite} (attempt 2 of 2)" | tee -a "${EVIDENCE}/summary.txt"
      if cargo test -p a3s-code-core ${feature_flags[@]+"${feature_flags[@]}"} --test "${suite}" -- --ignored --test-threads=1 --nocapture \
          >>"${EVIDENCE}/${suite}.log" 2>&1; then
        echo "PASS ${suite} (rerun)" | tee -a "${EVIDENCE}/summary.txt"
        return 0
      fi
      echo "FAIL ${suite} (rerun)" | tee -a "${EVIDENCE}/summary.txt"
      return 1
    }
    for suite in "${suites[@]}"; do
      run_suite "${suite}" "" || fail=1
      rg -n 'test result:|using default_model=|pinning default_model|RETRY ' "${EVIDENCE}/${suite}.log" | tail -8 | tee -a "${EVIDENCE}/summary.txt" || true
    done
    # Feature-gated live suites (optional when features compile).
    if cargo test -p a3s-code-core --features advanced-harness --test test_extensibility_real_llm -- --list >/dev/null 2>&1; then
      run_suite test_extensibility_real_llm advanced-harness || fail=1
      rg -n 'test result:|using default_model=|RETRY ' "${EVIDENCE}/test_extensibility_real_llm.log" | tail -8 | tee -a "${EVIDENCE}/summary.txt" || true
    fi
    if [[ "${fail}" -eq 0 ]]; then
      echo "LAYER_C_PASS model=${A3S_TEST_MODEL}" | tee "${EVIDENCE}/FINAL.txt"
    else
      echo "LAYER_C_FAIL model=${A3S_TEST_MODEL}" | tee "${EVIDENCE}/FINAL.txt"
    fi
    exit "${fail}"