diff --git a/test-apps/android-test-app/alarm-test-lib.sh b/test-apps/android-test-app/alarm-test-lib.sh
index ae590c3..7f59ccf 100644
--- a/test-apps/android-test-app/alarm-test-lib.sh
+++ b/test-apps/android-test-app/alarm-test-lib.sh
@@ -12,6 +12,12 @@
 #
 # Configuration can be overridden before sourcing:
 #   APP_ID="custom.package" source "${SCRIPT_DIR}/alarm-test-lib.sh"
+#
+# STRICT MODE NOTE:
+# This library does NOT set strict mode itself (set -euo pipefail) because
+# it's a library file. Scripts that source this library SHOULD set strict mode:
+#   set -euo pipefail
+#   IFS=$'\n\t'
 
 # --- Config Defaults (can be overridden before sourcing) ---
 
@@ -27,6 +33,13 @@
 : "${SCREENSHOT_ROOT:=screenshots}"
 : "${ENABLE_SCREENSHOTS:=1}"
 
+# Run folder configuration (P1)
+: "${RUN_ID:=$(date '+%Y%m%d_%H%M%S' 2>/dev/null || echo 'unknown')}"
+: "${RUN_DIR:=runs/${RUN_ID}}"
+
+# Release gating configuration (P4)
+: "${RELEASE_GATE_PHASE3:=0}"
+
 # Derived config (for backward compatibility with Phase 1)
 PACKAGE="${APP_ID}"
 ACTIVITY="${APP_ID}/.MainActivity"
@@ -38,7 +51,11 @@ YELLOW='\033[1;33m'
 BLUE='\033[0;34m'
 NC='\033[0m' # No Color
 
-# --- UI/Log Helpers ---
+# ========================================
+# PUBLIC API - UI/Log Helpers
+# ========================================
+# These are the primary functions that all scripts should use.
+# Deprecated functions (print_*, wait_for_*) are kept for backward compatibility.
 
 section() {
   echo
@@ -84,8 +101,54 @@ ui_prompt() {
   echo
 }
 
-# Phase 1 compatibility aliases (print_* functions)
+# ========================================
+# PUBLIC API - Command Execution Helpers
+# ========================================
+
+run_cmd() {
+  # Execute a command and capture output
+  # Usage: run_cmd "description" command [args...]
+  # Returns: exit code of command
+  local desc="$1"
+  shift
+  local cmd=("$@")
+  
+  info "Running: $desc"
+  if "${cmd[@]}"; then
+    ok "$desc completed"
+    return 0
+  else
+    local exit_code=$?
+    error "$desc failed (exit code: $exit_code)"
+    return $exit_code
+  fi
+}
+
+require_cmd() {
+  # Execute a command and exit on failure
+  # Usage: require_cmd "description" command [args...]
+  # Exits script if command fails
+  local desc="$1"
+  shift
+  local cmd=("$@")
+  
+  info "Required: $desc"
+  if ! "${cmd[@]}"; then
+    local exit_code=$?
+    error "$desc failed (exit code: $exit_code)"
+    exit $exit_code
+  fi
+  ok "$desc completed"
+}
+
+# ========================================
+# DEPRECATED - Phase 1 Compatibility Aliases
+# ========================================
+# These functions are kept for backward compatibility but should not be used
+# in new code. Use the public API functions above instead.
+
 print_header() {
+  # DEPRECATED: Use section() instead
   echo ""
   echo -e "${BLUE}========================================${NC}"
   echo -e "${BLUE}$1${NC}"
@@ -94,36 +157,44 @@ print_header() {
 }
 
 print_step() {
+  # DEPRECATED: Use substep() instead
   echo -e "${GREEN}→ Step $1:${NC} $2"
 }
 
 print_wait() {
+  # DEPRECATED: Use info() or warn() instead
   echo -e "${YELLOW}⏳ $1${NC}"
 }
 
 print_success() {
+  # DEPRECATED: Use ok() instead
   echo -e "${GREEN}✅ $1${NC}"
 }
 
 print_error() {
+  # DEPRECATED: Use error() instead
   echo -e "${RED}❌ $1${NC}"
 }
 
 print_info() {
+  # DEPRECATED: Use info() instead
   echo -e "${BLUE}ℹ️  $1${NC}"
 }
 
 print_warn() {
+  # DEPRECATED: Use warn() instead
   echo -e "${YELLOW}⚠️  $1${NC}"
 }
 
 wait_for_user() {
+  # DEPRECATED: Use pause() instead
   echo ""
   read -p "Press Enter when ready to continue..."
   echo ""
 }
 
 wait_for_ui_action() {
+  # DEPRECATED: Use ui_prompt() instead
   ui_prompt "$1"
 }
 
@@ -611,3 +682,257 @@ should_run_test() {
   return 1
 }
 
+# ========================================
+# PUBLIC API - Run Folder & Evidence Helpers (P1)
+# ========================================
+
+ensure_run_dir() {
+  # Create run directory structure if it doesn't exist
+  # Creates: RUN_DIR/logs, RUN_DIR/alarms, RUN_DIR/screens, RUN_DIR/notes
+  # Returns: 0 on success, 1 on failure
+  local base_dir
+  if [ -n "$SCRIPT_DIR" ] && [ -d "$SCRIPT_DIR" ]; then
+    base_dir="${SCRIPT_DIR}/${RUN_DIR}"
+  elif [ -n "${BASH_SOURCE[0]}" ]; then
+    local lib_dir
+    lib_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd 2>/dev/null)" || lib_dir=""
+    if [ -n "$lib_dir" ]; then
+      base_dir="${lib_dir}/${RUN_DIR}"
+    else
+      base_dir="${RUN_DIR}"
+    fi
+  else
+    base_dir="${RUN_DIR}"
+  fi
+  
+  mkdir -p "${base_dir}/logs" "${base_dir}/alarms" "${base_dir}/screens" "${base_dir}/notes" 2>/dev/null || {
+    error "Failed to create run directory: ${base_dir}"
+    return 1
+  }
+  
+  # Export for use by capture functions
+  export RUN_DIR_ABS="${base_dir}"
+  return 0
+}
+
+get_run_dir() {
+  # Get absolute path to current run directory
+  # Returns: absolute path, or empty string if not initialized
+  echo "${RUN_DIR_ABS:-}"
+}
+
+capture_alarms() {
+  # Capture AlarmManager dump to run folder
+  # Usage: capture_alarms "<label>"
+  # Saves to: RUN_DIR/alarms/<label>_alarms.txt
+  local label="$1"
+  local run_dir
+  run_dir="$(get_run_dir)"
+  
+  if [ -z "$run_dir" ]; then
+    warn "Run directory not initialized, skipping alarm capture: $label"
+    return 0
+  fi
+  
+  local safe_label="${label//[^a-zA-Z0-9_-]/_}"
+  local file="${run_dir}/alarms/${safe_label}_alarms.txt"
+  
+  info "Capturing alarms: $label → $file"
+  if $ADB_BIN shell dumpsys alarm > "$file" 2>/dev/null; then
+    ok "Alarms captured: $file"
+    return 0
+  else
+    warn "Failed to capture alarms: $label"
+    return 1
+  fi
+}
+
+capture_logcat() {
+  # Capture logcat output to run folder
+  # Usage: capture_logcat "<label>" "<grep_pattern>" "<lines>"
+  # Saves to: RUN_DIR/logs/<label>_logcat.txt
+  # If grep_pattern is empty, captures all recent logs
+  local label="$1"
+  local pattern="${2:-}"
+  local lines="${3:-250}"
+  local run_dir
+  run_dir="$(get_run_dir)"
+  
+  if [ -z "$run_dir" ]; then
+    warn "Run directory not initialized, skipping logcat capture: $label"
+    return 0
+  fi
+  
+  local safe_label="${label//[^a-zA-Z0-9_-]/_}"
+  local file="${run_dir}/logs/${safe_label}_logcat.txt"
+  
+  info "Capturing logcat: $label → $file"
+  
+  if [ -n "$pattern" ]; then
+    if $ADB_BIN logcat -d -t "$lines" | grep -E "$pattern" > "$file" 2>/dev/null; then
+      ok "Logcat captured (filtered): $file"
+      return 0
+    else
+      # Even if grep finds nothing, create empty file to indicate attempt
+      touch "$file"
+      warn "No logcat matches for pattern: $pattern"
+      return 0
+    fi
+  else
+    if $ADB_BIN logcat -d -t "$lines" > "$file" 2>/dev/null; then
+      ok "Logcat captured: $file"
+      return 0
+    else
+      warn "Failed to capture logcat: $label"
+      return 1
+    fi
+  fi
+}
+
+capture_screenshot() {
+  # Capture device screenshot to run folder
+  # Usage: capture_screenshot "<label>"
+  # Saves to: RUN_DIR/screens/<label>_screenshot.png
+  # Falls back to existing take_screenshot() if screenshots enabled
+  local label="$1"
+  local run_dir
+  run_dir="$(get_run_dir)"
+  
+  if [ -z "$run_dir" ]; then
+    warn "Run directory not initialized, skipping screenshot: $label"
+    return 0
+  fi
+  
+  if [ "$ENABLE_SCREENSHOTS" != "1" ]; then
+    warn "Screenshots disabled, skipping: $label"
+    return 0
+  fi
+  
+  local safe_label="${label//[^a-zA-Z0-9_-]/_}"
+  local file="${run_dir}/screens/${safe_label}_screenshot.png"
+  
+  info "Capturing screenshot: $label → $file"
+  if "$ADB_BIN" exec-out screencap -p > "$file" 2>/dev/null; then
+    if [ -s "$file" ]; then
+      ok "Screenshot captured: $file"
+      return 0
+    else
+      warn "Screenshot file is empty: $file"
+      rm -f "$file" 2>/dev/null || true
+      return 1
+    fi
+  else
+    warn "Failed to capture screenshot: $label"
+    return 1
+  fi
+}
+
+evidence_block() {
+  # Print evidence location block for a test
+  # Usage: evidence_block "<test_id>"
+  # Prints formatted block showing where artifacts are saved
+  local test_id="$1"
+  local run_dir
+  run_dir="$(get_run_dir)"
+  
+  if [ -z "$run_dir" ]; then
+    warn "Run directory not initialized, cannot show evidence block"
+    return 1
+  fi
+  
+  echo
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo "📦 EVIDENCE: $test_id"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo "Run ID: $RUN_ID"
+  echo "Evidence directory: $run_dir"
+  echo
+  echo "Artifacts:"
+  echo "  • Alarms:    $run_dir/alarms/"
+  echo "  • Logs:      $run_dir/logs/"
+  echo "  • Screens:   $run_dir/screens/"
+  echo "  • Notes:     $run_dir/notes/"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo
+}
+
+# ========================================
+# PUBLIC API - Verdict Functions (P1)
+# ========================================
+
+verdict_pass() {
+  # Emit a PASS verdict for a test
+  # Usage: verdict_pass "<test_id>" "<message>"
+  local test_id="$1"
+  local message="$2"
+  local run_dir
+  run_dir="$(get_run_dir)"
+  
+  echo
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo "✅ VERDICT: PASS"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo "Test ID: $test_id"
+  echo "Status:  PASS"
+  echo "Message: $message"
+  if [ -n "$run_dir" ]; then
+    echo "Evidence: $run_dir"
+  fi
+  echo "Next:    Continue to next test"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo
+}
+
+verdict_warn() {
+  # Emit a WARN verdict for a test
+  # Usage: verdict_warn "<test_id>" "<message>"
+  local test_id="$1"
+  local message="$2"
+  local run_dir
+  run_dir="$(get_run_dir)"
+  
+  echo
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo "⚠️  VERDICT: WARN"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo "Test ID: $test_id"
+  echo "Status:  WARN"
+  echo "Message: $message"
+  if [ -n "$run_dir" ]; then
+    echo "Evidence: $run_dir"
+  fi
+  echo "Next:    Review evidence and continue"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo
+}
+
+verdict_fail() {
+  # Emit a FAIL verdict for a test
+  # Usage: verdict_fail "<test_id>" "<message>"
+  # If RELEASE_GATE_PHASE3=1, this will cause script to exit with non-zero
+  local test_id="$1"
+  local message="$2"
+  local run_dir
+  run_dir="$(get_run_dir)"
+  
+  echo
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo "❌ VERDICT: FAIL"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo "Test ID: $test_id"
+  echo "Status:  FAIL"
+  echo "Message: $message"
+  if [ -n "$run_dir" ]; then
+    echo "Evidence: $run_dir"
+  fi
+  echo "Next:    Review evidence and investigate"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo
+  
+  # If release gating is enabled, exit with failure
+  if [ "${RELEASE_GATE_PHASE3:-0}" = "1" ]; then
+    error "Release gating enabled: exiting due to test failure"
+    exit 1
+  fi
+}
+
diff --git a/test-apps/android-test-app/docs/RUNBOOK-TESTING.md b/test-apps/android-test-app/docs/RUNBOOK-TESTING.md
new file mode 100644
index 0000000..8443f46
--- /dev/null
+++ b/test-apps/android-test-app/docs/RUNBOOK-TESTING.md
@@ -0,0 +1,669 @@
+# Daily Notification Plugin — Test Operator Runbook
+
+**Last Updated:** 2025-01-XX  
+**Purpose:** Complete guide for operators running Phase 1, 2, and 3 test suites  
+**Audience:** Test operators, QA engineers, developers running manual tests
+
+---
+
+## Table of Contents
+
+1. [Prerequisites](#prerequisites)
+2. [Quick Start](#quick-start)
+3. [Phase 1: Daily Rollover & Recovery](#phase-1-daily-rollover--recovery)
+4. [Phase 2: Force Stop Recovery](#phase-2-force-stop-recovery)
+5. [Phase 3: Boot Recovery](#phase-3-boot-recovery)
+6. [Evidence & Artifacts](#evidence--artifacts)
+7. [Interpreting Verdicts](#interpreting-verdicts)
+8. [Common Failures & Fixes](#common-failures--fixes)
+9. [Troubleshooting](#troubleshooting)
+
+---
+
+## Prerequisites
+
+### Required Tools
+
+- **ADB (Android Debug Bridge)** — Must be in PATH
+  ```bash
+  which adb
+  adb version
+  ```
+- **Android Emulator or Physical Device** — Connected and accessible
+  ```bash
+  adb devices
+  ```
+- **Bash 4.0+** — For script execution
+  ```bash
+  bash --version
+  ```
+- **Gradle** — For building test app (included via `gradlew`)
+- **Java JDK 11+** — For Android builds
+
+### Environment Setup
+
+1. **Navigate to test directory:**
+   ```bash
+   cd test-apps/android-test-app
+   ```
+
+2. **Verify scripts are executable:**
+   ```bash
+   ls -la test-phase*.sh
+   chmod +x test-phase*.sh alarm-test-lib.sh
+   ```
+
+3. **Check ADB connection:**
+   ```bash
+   adb devices
+   # Should show your device/emulator
+   ```
+
+### Pre-Flight Checks
+
+Before running any test phase, verify:
+
+- [ ] ADB device is connected (`adb devices` shows device)
+- [ ] Emulator/device is unlocked and responsive
+- [ ] Test app can be built (`./gradlew assembleDebug` succeeds)
+- [ ] Previous test runs cleaned up (optional but recommended)
+
+---
+
+## Quick Start
+
+### Run All Phases (Advisory Mode)
+
+```bash
+# Phase 1: Daily rollover and recovery
+./test-phase1.sh --all
+
+# Phase 2: Force stop recovery
+./test-phase2.sh
+
+# Phase 3: Boot recovery
+./test-phase3.sh
+```
+
+### Run Specific Tests
+
+```bash
+# Phase 1: Run only TEST 0 (Daily Rollover)
+./test-phase1.sh 0
+
+# Phase 2: Run TEST 1 and TEST 3
+./test-phase2.sh 1 3
+
+# Phase 3: Run only TEST 4 (Silent Boot Recovery)
+./test-phase3.sh 4
+```
+
+### Run in Release-Gating Mode
+
+```bash
+# Phase 3: Fail fast on any test failure
+./test-phase3.sh --gate-phase3
+
+# Or via environment variable
+RELEASE_GATE_PHASE3=1 ./test-phase3.sh
+```
+
+---
+
+## Phase 1: Daily Rollover & Recovery
+
+**Purpose:** Verify daily rollover behavior, force-stop recovery, schedule updates, and error handling.
+
+**Expected Duration:** 30-45 minutes (all tests)
+
+### Test Modes
+
+```bash
+# Setup only (pre-flight checks, app install, permissions)
+./test-phase1.sh --setup
+
+# Run all tests
+./test-phase1.sh --all
+
+# Smoke test (minimal verification)
+./test-phase1.sh --smoke
+
+# CI mode (non-interactive, fail fast)
+./test-phase1.sh --ci
+
+# Run specific test
+./test-phase1.sh 0  # TEST 0: Daily Rollover
+./test-phase1.sh 1  # TEST 1: Force-Stop Recovery
+./test-phase1.sh 2  # TEST 2: Schedule Update
+./test-phase1.sh 3  # TEST 3: Recovery Timeout
+./test-phase1.sh 4  # TEST 4: Invalid Data Handling
+```
+
+### Test Descriptions
+
+**TEST 0: Daily Rollover Verification**
+- **Time:** 5-8 minutes
+- **Automatable:** Partial (requires manual verification)
+- **What it tests:** Daily rollover at midnight, schedule advancement
+- **Key steps:**
+  1. Schedule notification for future
+  2. Advance system time past midnight
+  3. Verify rollover occurred and next day scheduled
+
+**TEST 1: Force-Stop Recovery - Database Restoration**
+- **Time:** 8-12 minutes
+- **Automatable:** Partial (requires manual force-stop)
+- **What it tests:** Recovery after force-stop, database restoration
+- **Key steps:**
+  1. Schedule notification
+  2. Force-stop app
+  3. Relaunch and verify recovery
+
+**TEST 2: Schedule Update Verification**
+- **Time:** 5-8 minutes
+- **Automatable:** Partial
+- **What it tests:** Schedule updates, one-per-day semantics
+- **Key steps:**
+  1. Schedule notification
+  2. Update schedule
+  3. Verify only one alarm exists
+
+**TEST 3: Recovery Timeout**
+- **Time:** 3-5 minutes
+- **Automatable:** Yes (code verification)
+- **What it tests:** Recovery timeout handling
+- **Key steps:**
+  1. Verify timeout logic in code
+  2. Check timeout behavior
+
+**TEST 4: Invalid Data Handling**
+- **Time:** 5-8 minutes
+- **Automatable:** Partial
+- **What it tests:** Graceful handling of invalid data
+- **Key steps:**
+  1. Inject invalid data
+  2. Verify graceful recovery
+
+### Phase 1 Evidence Location
+
+All evidence is saved to: `runs/<RUN_ID>/`
+
+- **Alarms:** `runs/<RUN_ID>/alarms/phase1_*.txt`
+- **Logs:** `runs/<RUN_ID>/logs/phase1_*.txt`
+- **Screenshots:** `runs/<RUN_ID>/screens/phase1_*.png`
+
+---
+
+## Phase 2: Force Stop Recovery
+
+**Purpose:** Verify force-stop detection, alarm rescheduling, and recovery scenarios.
+
+**Expected Duration:** 15-20 minutes (all tests)
+
+### Test Modes
+
+```bash
+# Run all tests (default)
+./test-phase2.sh
+
+# Run specific tests
+./test-phase2.sh 1      # TEST 1: Force Stop with Cleared Alarms
+./test-phase2.sh 2      # TEST 2: Force Stop with Intact Alarms
+./test-phase2.sh 3      # TEST 3: First Launch / No Schedules
+
+# With strictness policy
+STRICTNESS=soft ./test-phase2.sh   # Default: minor quirks = warn
+STRICTNESS=hard ./test-phase2.sh    # Any issue = fail
+```
+
+### Test Descriptions
+
+**TEST 1: Force Stop – Alarms Cleared**
+- **Time:** 5-8 minutes
+- **Automatable:** Partial (requires manual force-stop)
+- **What it tests:** Force-stop detection when alarms are cleared
+- **Key steps:**
+  1. Schedule notification
+  2. Force-stop app (clears alarms on many devices)
+  3. Relaunch and verify FORCE_STOP scenario detected
+  4. Verify alarms rescheduled
+
+**TEST 2: Force Stop / Process Stop – Alarms Intact**
+- **Time:** 4-6 minutes
+- **Automatable:** Partial
+- **What it tests:** Recovery when alarms remain intact
+- **Key steps:**
+  1. Schedule notification
+  2. Soft-kill app (alarms remain)
+  3. Relaunch and verify FORCE_STOP scenario did NOT run
+
+**TEST 3: First Launch / No Schedules Safeguard**
+- **Time:** 3-5 minutes
+- **Automatable:** Yes
+- **What it tests:** No recovery on empty database
+- **Key steps:**
+  1. Uninstall app
+  2. Reinstall app
+  3. Reboot (without scheduling)
+  4. Verify no recovery logs or NONE scenario
+
+### Strictness Policy
+
+**`STRICTNESS=soft` (default):**
+- Minor device quirks = `verdict_warn`
+- Alarms still present after force-stop = warn
+- FORCE_STOP scenario not detected = warn
+
+**`STRICTNESS=hard`:**
+- Any unexpected behavior = `verdict_fail`
+- Alarms still present after force-stop = fail
+- FORCE_STOP scenario not detected = fail
+- Recovery errors = fail
+
+### Phase 2 Evidence Location
+
+- **Alarms:** `runs/<RUN_ID>/alarms/phase2_*.txt`
+- **Logs:** `runs/<RUN_ID>/logs/phase2_*.txt`
+- **Screenshots:** `runs/<RUN_ID>/screens/phase2_*.png`
+
+---
+
+## Phase 3: Boot Recovery
+
+**Purpose:** Verify boot recovery, missed alarm detection, and silent recovery.
+
+**Expected Duration:** 12-18 minutes (all tests)
+
+### Test Modes
+
+```bash
+# Run all tests (advisory mode, default)
+./test-phase3.sh
+
+# Run specific tests
+./test-phase3.sh 1      # TEST 1: Boot with Future Alarms
+./test-phase3.sh 2      # TEST 2: Boot with Past Alarms
+./test-phase3.sh 3      # TEST 3: Boot with No Schedules
+./test-phase3.sh 4      # TEST 4: Silent Boot Recovery
+
+# Release-gating mode (failures exit with non-zero)
+./test-phase3.sh --gate-phase3
+RELEASE_GATE_PHASE3=1 ./test-phase3.sh
+```
+
+### Test Descriptions
+
+**TEST 1: Boot with Future Alarms**
+- **Time:** 2-3 minutes (includes 30-60s reboot)
+- **Automatable:** Partial (requires manual reboot confirmation)
+- **What it tests:** Boot recovery with future alarms
+- **Key steps:**
+  1. Schedule notification for future
+  2. Reboot emulator
+  3. Verify BOOT scenario detected
+  4. Verify alarms rescheduled
+
+**TEST 2: Boot with Past Alarms**
+- **Time:** 5-6 minutes (includes 3min wait + 30-60s reboot)
+- **Automatable:** Partial (requires manual time advancement or wait)
+- **What it tests:** Missed alarm detection and rescheduling
+- **Key steps:**
+  1. Schedule notification for 2 minutes future
+  2. Wait 3 minutes (alarm time passes)
+  3. Reboot emulator
+  4. Verify missed alarms detected
+  5. Verify next occurrence scheduled
+
+**TEST 3: Boot with No Schedules**
+- **Time:** 2-3 minutes (includes 30-60s reboot)
+- **Automatable:** Yes
+- **What it tests:** Graceful handling of empty database
+- **Key steps:**
+  1. Uninstall app
+  2. Reinstall app
+  3. Reboot (without scheduling)
+  4. Verify no recovery logs or NONE scenario
+
+**TEST 4: Silent Boot Recovery (App Never Opened)**
+- **Time:** 2-3 minutes (includes 30-60s reboot)
+- **Automatable:** Partial (requires manual verification app not opened)
+- **What it tests:** Boot recovery without app launch
+- **Key steps:**
+  1. Schedule notification
+  2. Reboot emulator
+  3. **DO NOT open app** after reboot
+  4. Verify boot recovery occurred silently
+  5. Verify alarms recreated
+
+### Release Gating
+
+**Advisory Mode (default):**
+- Failures become warnings
+- Script continues to next test
+- Use for development/testing
+
+**Release-Blocking Mode (`--gate-phase3` or `RELEASE_GATE_PHASE3=1`):**
+- Failures cause script to exit with non-zero
+- Use for CI/CD or release validation
+- First failure stops execution
+
+### Phase 3 Evidence Location
+
+- **Alarms:** `runs/<RUN_ID>/alarms/phase3_*.txt`
+- **Logs:** `runs/<RUN_ID>/logs/phase3_*.txt`
+- **Screenshots:** `runs/<RUN_ID>/screens/phase3_*.png`
+
+---
+
+## Evidence & Artifacts
+
+### Run Directory Structure
+
+Each test run creates a timestamped directory:
+
+```
+runs/
+  └── 20250124_143022_abc123/
+      ├── alarms/
+      │   ├── phase1_test0_initial.txt
+      │   ├── phase1_test0_before_schedule.txt
+      │   └── ...
+      ├── logs/
+      │   ├── phase1_test0_initial.txt
+      │   ├── phase1_test0_after_schedule.txt
+      │   └── ...
+      ├── screens/
+      │   ├── phase1_test0_after_schedule_screenshot.png
+      │   └── ...
+      └── notes/
+          └── (manual notes can be added here)
+```
+
+### Evidence Types
+
+**Alarm Dumps:**
+- Captured via `adb shell dumpsys alarm`
+- Shows all scheduled alarms
+- Used to verify plugin alarms exist
+
+**Logcat Logs:**
+- Captured via `adb logcat`
+- Filtered by tag (e.g., `DNP`, `DNP-REACTIVATION`)
+- Used to verify recovery scenarios and errors
+
+**Screenshots:**
+- Captured via `adb exec-out screencap`
+- Shows app state at key points
+- Used for visual verification
+
+### Accessing Evidence
+
+```bash
+# Get current run directory
+cd test-apps/android-test-app
+ls -la runs/
+
+# View latest run
+ls -la runs/$(ls -t runs/ | head -1)
+
+# View specific evidence
+cat runs/<RUN_ID>/alarms/phase1_test0_initial.txt
+cat runs/<RUN_ID>/logs/phase1_test0_after_schedule.txt
+```
+
+---
+
+## Interpreting Verdicts
+
+### Verdict Types
+
+**✅ PASS (`verdict_pass`):**
+- Test passed all checks
+- Continue to next test
+- Evidence saved for reference
+
+**⚠️ WARN (`verdict_warn`):**
+- Test had minor issues or device quirks
+- May be acceptable depending on context
+- Review evidence and decide if action needed
+- Script continues
+
+**❌ FAIL (`verdict_fail`):**
+- Test failed critical checks
+- Review evidence immediately
+- In advisory mode: script continues
+- In release-gating mode: script exits with non-zero
+
+### Verdict Format
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+✅ VERDICT: PASS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Test ID: phase1_test0_daily_rollover
+Status:  PASS
+Message: Daily rollover verified successfully
+Evidence: runs/20250124_143022_abc123
+Next:    Continue to next test
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+### Evidence Block Format
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+📦 EVIDENCE: phase1_test0_daily_rollover
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Run ID: 20250124_143022_abc123
+Evidence directory: runs/20250124_143022_abc123
+
+Artifacts:
+  • Alarms:    runs/20250124_143022_abc123/alarms/
+  • Logs:      runs/20250124_143022_abc123/logs/
+  • Screens:   runs/20250124_143022_abc123/screens/
+  • Notes:     runs/20250124_143022_abc123/notes/
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+---
+
+## Common Failures & Fixes
+
+### Phase 1 Failures
+
+**"No plugin alarms found before rollover"**
+- **Cause:** Notification not scheduled correctly
+- **Fix:** Verify plugin is configured, check app UI shows scheduled notification
+- **Evidence:** Check `alarms/phase1_test0_before_schedule.txt`
+
+**"Rollover did not occur"**
+- **Cause:** System time not advanced correctly, or rollover logic issue
+- **Fix:** Verify system time was advanced past midnight, check logs for rollover activity
+- **Evidence:** Check `logs/phase1_test0_after_rollover.txt`
+
+**"Recovery did not restore database"**
+- **Cause:** Force-stop recovery not triggered, or database restoration failed
+- **Fix:** Verify force-stop actually cleared alarms, check recovery logs
+- **Evidence:** Check `logs/phase1_test1_after_recovery.txt`
+
+### Phase 2 Failures
+
+**"FORCE_STOP scenario not detected"**
+- **Cause:** Device/emulator didn't clear alarms on force-stop, or scenario detection logic issue
+- **Fix:** Check if device clears alarms on force-stop (device-specific), verify boot flag cleared
+- **Evidence:** Check `logs/phase2_test1_after_recovery.txt`, verify `scenario=FORCE_STOP`
+
+**"Alarms still present after force-stop"**
+- **Cause:** Device/emulator doesn't clear alarms on force-stop (common on some devices)
+- **Fix:** This is device-specific behavior. In `STRICTNESS=soft` mode, this is a warning. In `STRICTNESS=hard` mode, this is a failure.
+- **Evidence:** Check `alarms/phase2_test1_after_force_stop.txt`
+
+**"rescheduled>0 on first launch"**
+- **Cause:** Boot recovery misfiring on empty database
+- **Fix:** Check recovery logic, verify database is actually empty
+- **Evidence:** Check `logs/phase2_test3_after_reboot.txt`
+
+### Phase 3 Failures
+
+**"Boot recovery not detected"**
+- **Cause:** Boot receiver not registered, or BOOT_COMPLETED permission missing
+- **Fix:** Verify `AndroidManifest.xml` has boot receiver and permission
+- **Evidence:** Check `logs/phase3_test1_after_reboot.txt`, verify boot receiver logs
+
+**"No missed alarms detected"**
+- **Cause:** Alarm time didn't actually pass before reboot
+- **Fix:** Verify system time was advanced, or wait longer before reboot
+- **Evidence:** Check `alarms/phase3_test2_after_wait.txt`, verify alarm time is in past
+
+**"Boot recovery ran but alarms not recreated"**
+- **Cause:** Recovery succeeded but alarm scheduling failed
+- **Fix:** Check alarm scheduling logic, verify permissions
+- **Evidence:** Check `logs/phase3_test4_after_reboot.txt`, verify `rescheduled>0` but `after_count=0`
+
+### General Failures
+
+**"ADB device not found"**
+- **Cause:** Device disconnected, ADB not in PATH, or device not authorized
+- **Fix:** Run `adb devices`, verify device shows as "device" (not "unauthorized"), reconnect if needed
+
+**"App build failed"**
+- **Cause:** Gradle issues, missing dependencies, or Java version mismatch
+- **Fix:** Run `./gradlew clean`, verify Java version, check `build.gradle` dependencies
+
+**"Permission denied"**
+- **Cause:** App doesn't have required permissions
+- **Fix:** Grant permissions via app UI or `adb shell pm grant`
+
+---
+
+## Troubleshooting
+
+### Script Won't Run
+
+**"Permission denied: ./test-phase1.sh"**
+```bash
+chmod +x test-phase1.sh test-phase2.sh test-phase3.sh alarm-test-lib.sh
+```
+
+**"Command not found: adb"**
+```bash
+# Add Android SDK platform-tools to PATH
+export PATH="$PATH:$ANDROID_HOME/platform-tools"
+```
+
+**"Syntax error near unexpected token"**
+```bash
+# Verify bash version
+bash --version  # Should be 4.0+
+
+# Check script syntax
+bash -n test-phase1.sh
+```
+
+### Evidence Not Captured
+
+**"Run directory not initialized"**
+- **Cause:** `ensure_run_dir()` failed
+- **Fix:** Check write permissions in test directory, verify `runs/` directory can be created
+
+**"Screenshot capture failed"**
+- **Cause:** `ENABLE_SCREENSHOTS=0` or device doesn't support screencap
+- **Fix:** Set `ENABLE_SCREENSHOTS=1` (default), verify device supports `adb exec-out screencap`
+
+**"Logcat capture empty"**
+- **Cause:** Logs cleared before capture, or filter pattern doesn't match
+- **Fix:** Verify log tag matches filter pattern, check logs weren't cleared
+
+### Device/Emulator Issues
+
+**"Emulator not responding"**
+```bash
+# Restart emulator
+adb kill-server
+adb start-server
+adb devices
+```
+
+**"Device unauthorized"**
+- **Cause:** USB debugging authorization not granted
+- **Fix:** Check device screen for authorization prompt, click "Allow"
+
+**"Alarms not clearing on force-stop"**
+- **Cause:** Device-specific behavior (some devices don't clear alarms)
+- **Fix:** This is expected on some devices. Use `STRICTNESS=soft` mode to treat as warning.
+
+### Test-Specific Issues
+
+**"Phase 3 reboot takes too long"**
+- **Cause:** Emulator is slow or hung
+- **Fix:** Wait longer (60-90 seconds), or restart emulator if completely hung
+
+**"Time advancement not working"**
+- **Cause:** System time can't be advanced (requires root or emulator)
+- **Fix:** Use emulator with root, or manually advance time via emulator settings
+
+**"Plugin not configured"**
+- **Cause:** Plugin setup not completed
+- **Fix:** Run `./test-phase1.sh --setup` to configure plugin, or manually configure in app UI
+
+---
+
+## Quick Reference
+
+### Command Cheat Sheet
+
+```bash
+# Phase 1
+./test-phase1.sh --setup          # Setup only
+./test-phase1.sh --all            # All tests
+./test-phase1.sh --smoke          # Smoke test
+./test-phase1.sh 0                # TEST 0 only
+
+# Phase 2
+./test-phase2.sh                  # All tests (soft mode)
+STRICTNESS=hard ./test-phase2.sh  # All tests (hard mode)
+./test-phase2.sh 1 3              # TEST 1 and 3
+
+# Phase 3
+./test-phase3.sh                  # All tests (advisory)
+./test-phase3.sh --gate-phase3    # All tests (release-blocking)
+./test-phase3.sh 2                # TEST 2 only
+```
+
+### Evidence Locations
+
+```bash
+# Latest run
+ls -la runs/$(ls -t runs/ | head -1)
+
+# Specific evidence
+cat runs/<RUN_ID>/alarms/phase1_test0_initial.txt
+cat runs/<RUN_ID>/logs/phase1_test0_after_schedule.txt
+```
+
+### Verdict Meanings
+
+- **✅ PASS:** Test passed, continue
+- **⚠️ WARN:** Minor issue, review evidence, continue
+- **❌ FAIL:** Critical failure, review evidence, may exit (if gating enabled)
+
+---
+
+## Support & Feedback
+
+**Issues or Questions?**
+- Check evidence files in `runs/<RUN_ID>/`
+- Review test logs for detailed error messages
+- Consult platform-specific documentation in `docs/platform/android/`
+
+**Improving This Runbook:**
+- Document new failure patterns as they're discovered
+- Update time estimates based on actual test runs
+- Add automation hints for new test scenarios
+
+---
+
+**Last Updated:** 2025-01-XX  
+**Version:** 1.0  
+**Maintainer:** Test Engineering Team
+
diff --git a/test-apps/android-test-app/test-phase1.sh b/test-apps/android-test-app/test-phase1.sh
index c2c9efc..918941d 100755
--- a/test-apps/android-test-app/test-phase1.sh
+++ b/test-apps/android-test-app/test-phase1.sh
@@ -1,14 +1,22 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
 # Phase 1 Testing Script - Interactive Test Runner
 # Guides through all Phase 1 tests with clear prompts for UI interaction
 
-set -e  # Exit on error
+# Strict mode (P0.2)
+set -euo pipefail
+IFS=$'\n\t'
 
 # Source shared library
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "${SCRIPT_DIR}/alarm-test-lib.sh"
 
+# Initialize run directory (P1)
+ensure_run_dir || {
+  error "Failed to initialize run directory"
+  exit 1
+}
+
 # Phase 1 specific configuration
 VERIFY_FIRE=${VERIFY_FIRE:-false}  # Set VERIFY_FIRE=true to enable alarm fire verification
 APP_DIR="${SCRIPT_DIR}"
@@ -162,1008 +170,1123 @@ get_current_time() {
     $ADB_BIN shell date +%s
 }
 
-# Main test execution
+# ========================================
+# CLI Mode Parsing (P2.1)
+# ========================================
+
+parse_cli_args() {
+  local mode="all"
+  SELECTED_TESTS=()
+  
+  while [[ $# -gt 0 ]]; do
+    case "$1" in
+      --setup)
+        mode="setup"
+        shift
+        ;;
+      --run)
+        mode="run"
+        shift
+        ;;
+      --smoke)
+        mode="smoke"
+        shift
+        ;;
+      --all)
+        mode="all"
+        shift
+        ;;
+      --ci)
+        mode="ci"
+        shift
+        ;;
+      -h|--help)
+        show_help
+        exit 0
+        ;;
+      [0-9]*)
+        SELECTED_TESTS+=("$1")
+        shift
+        ;;
+      *)
+        error "Unknown option: $1"
+        show_help
+        exit 1
+        ;;
+    esac
+  done
+  
+  echo "$mode"
+}
+
+show_help() {
+  cat <<EOF
+Usage: $0 [MODE] [TEST_IDS...]
+
+Modes:
+  --setup    Run setup only (permissions, app install, plugin config checks)
+  --run      Run actual Phase 1 tests (requires setup first)
+  --smoke    Minimal test: schedule one notification + verify pending
+  --all      Run setup + all tests (default)
+  --ci       Non-interactive: automated checks only, fail fast
+
+Test Selection:
+  [TEST_IDS] Optional test numbers to run (e.g., 0 1 2)
+             If omitted, all tests run
+
+Examples:
+  $0                    # Run all (setup + tests)
+  $0 --setup            # Setup only
+  $0 --run              # Run tests only
+  $0 --smoke            # Quick smoke test
+  $0 --ci               # CI mode (non-interactive)
+  $0 --run 1 2          # Run only tests 1 and 2
+  $0 --smoke 0          # Run smoke test for test 0
+
+EOF
+}
+
+# ========================================
+# Setup Mode (P2.1)
+# ========================================
+
+run_setup() {
+  section "Phase 1 Setup"
+  
+  info "This mode performs pre-flight checks and setup:"
+  echo "  • ADB device connection"
+  echo "  • Emulator readiness"
+  echo "  • App build and installation"
+  echo "  • Permission checks"
+  echo "  • Plugin configuration checks"
+  echo ""
+  
+  if [ "${MODE}" != "ci" ]; then
+    pause
+  fi
+  
+  # Pre-flight checks
+  section "Pre-Flight Checks"
+  require_adb_device
+  
+  # Build and install
+  build_app
+  install_app
+  
+  # Clear logs
+  clear_logs
+  
+  # Launch app for setup checks
+  launch_app
+  sleep 2
+  
+  # Check permissions
+  section "Permission Checks"
+  if check_permissions; then
+    ok "Notification permissions already granted"
+  else
+    if [ "${MODE}" = "ci" ]; then
+      error "Permissions not granted - cannot proceed in CI mode"
+      exit 1
+    fi
+    ensure_permissions
+  fi
+  
+  # Check plugin configuration
+  section "Plugin Configuration"
+  if check_plugin_configured; then
+    ok "Plugin appears to be configured"
+    if [ "${MODE}" != "ci" ]; then
+      ui_prompt "Please verify in the app UI that you see:
+      
+      1) ⚙️ Plugin Settings: ✅ Configured
+      2) 🔌 Native Fetcher: ✅ Configured
+      3) 🔔 Notifications: ✅ Granted
+      
+      If all show ✅, press Enter to continue.
+      If any show ❌, click 'Configure Plugin' first."
+    fi
+  else
+    if [ "${MODE}" = "ci" ]; then
+      error "Plugin not configured - cannot proceed in CI mode"
+      exit 1
+    fi
+    ensure_plugin_configured
+  fi
+  
+  ok "Setup complete!"
+  
+  # Capture initial state
+  capture_alarms "setup_initial"
+  capture_logcat "setup_initial" "DNP" 100
+  
+  evidence_block "phase1_setup"
+}
+
+# ========================================
+# Smoke Test Mode (P2.1)
+# ========================================
+
+run_smoke_test() {
+  section "Phase 1 Smoke Test"
+  
+  info "Minimal test: schedule one notification + verify pending"
+  echo "Expected time: 2-4 minutes"
+  echo ""
+  
+  if [ "${MODE}" != "ci" ]; then
+    pause
+  fi
+  
+  # Ensure setup is done
+  if ! check_permissions >/dev/null 2>&1; then
+    warn "Setup not complete - running setup first..."
+    run_setup
+  fi
+  
+  # Capture before state
+  capture_alarms "smoke_before"
+  
+  # Schedule notification
+  section "Smoke Test: Schedule Notification"
+  launch_app
+  
+  if [ "${MODE}" != "ci" ]; then
+    ui_prompt "1) In the app UI, click 'Test Notification' to schedule a notification for 4 minutes in the future."
+  else
+    info "CI mode: Assuming notification is scheduled manually or via automation"
+    sleep 3
+  fi
+  
+  # Wait for alarm to be registered
+  sleep 3
+  
+  # Capture after state
+  capture_alarms "smoke_after"
+  capture_logcat "smoke_after" "DNP-SCHEDULE|DNP-NOTIFY" 50
+  
+  # Verify alarm exists
+  local alarm_count
+  alarm_count="$(get_plugin_alarm_count)"
+  
+  if [ "${alarm_count}" -eq "1" ]; then
+    verdict_pass "phase1_smoke" "Smoke test passed: 1 alarm scheduled"
+  elif [ "${alarm_count}" -gt "1" ]; then
+    verdict_fail "phase1_smoke" "Smoke test failed: ${alarm_count} alarms found (expected: 1)"
+  else
+    verdict_warn "phase1_smoke" "Smoke test inconclusive: ${alarm_count} alarms found (expected: 1, may be race condition)"
+  fi
+  
+  evidence_block "phase1_smoke"
+}
+
+# ========================================
+# Main Test Execution
+# ========================================
+
 main() {
-    # Allow selecting specific tests: e.g. `./test-phase1.sh 1 2`
-    if [[ "$#" -gt 0 && ( "$1" == "-h" || "$1" == "--help" ) ]]; then
-        echo "Usage: $0 [TEST_IDS...]"
-        echo ""
-        echo "If no TEST_IDS are given, all tests (1, 2, 3, 4) will run."
-        echo "Examples:"
-        echo "  $0          # run all tests"
-        echo "  $0 1        # run only TEST 1"
-        echo "  $0 2 3      # run only TEST 2 and TEST 3"
-        echo "  $0 4        # run only TEST 4"
-        return 0
+  # Parse CLI arguments
+  MODE="$(parse_cli_args "$@")"
+  
+  section "Phase 1 Testing Script"
+  echo "Mode: ${MODE}"
+  echo "Run ID: ${RUN_ID}"
+  echo "Evidence directory: $(get_run_dir)"
+  echo ""
+  
+  if [ "${MODE}" = "setup" ]; then
+    run_setup
+    return 0
+  elif [ "${MODE}" = "smoke" ]; then
+    run_smoke_test
+    return 0
+  elif [ "${MODE}" = "ci" ]; then
+    info "CI mode: Non-interactive, automated checks only"
+    run_setup
+    # In CI mode, we might want to run a subset of tests
+    # For now, just run smoke test
+    run_smoke_test
+    return 0
+  fi
+  
+  # For --run and --all modes, continue with full test suite
+  if [ "${MODE}" = "all" ]; then
+    info "Running full test suite (setup + tests)"
+    if [ "${MODE}" != "ci" ]; then
+      pause
+    fi
+    run_setup
+  elif [ "${MODE}" = "run" ]; then
+    info "Running tests only (assuming setup already done)"
+    if [ "${MODE}" != "ci" ]; then
+      pause
+    fi
+  fi
+  
+  # ============================================
+  # TEST 0: Daily Rollover (Core Contract Verification)
+  # ============================================
+  if should_run_test "0" SELECTED_TESTS; then
+    section "TEST 0: Daily Rollover Verification"
+    
+    info "Purpose: Verify that after a notification fires, the next day's"
+    info "         schedule is correctly computed and only ONE alarm exists."
+    info ""
+    info "Expected time: 5-10 minutes"
+    info "Automatable: Partial (requires manual clock manipulation or waiting)"
+    echo ""
+    
+    if [ "${MODE}" != "ci" ]; then
+      pause
     fi
     
-    SELECTED_TESTS=("$@")
+    # Capture initial state
+    capture_alarms "test0_initial"
+    capture_logcat "test0_initial" "DNP" 50
     
-    print_header "Phase 1 Testing Script"
-    echo "This script will guide you through Phase 1 tests."
-    echo "You'll be prompted when UI interaction is needed."
-    echo ""
-    wait_for_user
-    
-    # Pre-flight checks
-    print_header "Pre-Flight Checks"
-    check_adb_connection
-    check_emulator_ready
-    
-    # Build and install
-    build_app
-    install_app
-    
-    # Clear logs
-    clear_logs
-    
-    # ============================================
-    # TEST 0: Daily Rollover (Core Contract Verification)
-    # ============================================
-    # Note: This test verifies the core "one notification per day" contract
-    # by checking that after a notification fires, the next day's schedule
-    # is correctly computed and scheduled. This is a manual/semi-automated test
-    # as it requires either waiting for the alarm to fire or manipulating time.
-    #
-    # To run: Use test ID "0" or enable manually
-    # ============================================
-    if should_run_test "0" SELECTED_TESTS; then
-    print_header "TEST 0: Daily Rollover Verification"
-    echo "Purpose: Verify that after a notification fires, the next day's"
-    echo "         schedule is correctly computed and only ONE alarm exists."
-    echo ""
-    echo "Note: This test verifies the core 'one notification per day' contract."
-    echo "      It requires either:"
-    echo "      1. Scheduling a notification for 'now + N seconds' and waiting, OR"
-    echo "      2. Manipulating the emulator clock to cross the fire boundary."
-    echo ""
-    echo "      For now, this is a MANUAL test - you'll need to verify the"
-    echo "      behavior by checking logs and AlarmManager after a notification fires."
-    echo ""
-    wait_for_user
-    
-    print_step "1" "Schedule a test notification for near-future (or use existing)..."
+    substep "Step 1: Schedule a test notification"
     launch_app
     ensure_plugin_configured
     
-    # Capture pre-schedule UI state
-    take_screenshot "phase1_test0_daily_rollover" "before_scheduling"
+    # Capture pre-schedule state
+    capture_alarms "test0_before_schedule"
+    capture_screenshot "test0_before_schedule"
     
-    INITIAL_COUNT=$(get_plugin_alarm_count)
-    SYSTEM_COUNT=$(get_system_alarm_count)
-    print_info "Current notification alarms: ${INITIAL_COUNT} (expected before scheduling: 0)"
-    print_info "System/other alarms: ${SYSTEM_COUNT} (for context)"
-    print_info "Note: Prefetch uses WorkManager (not AlarmManager), so it won't appear in alarm count"
+    local initial_count system_count
+    initial_count="$(get_plugin_alarm_count)"
+    system_count="$(get_system_alarm_count)"
+    info "Current notification alarms: ${initial_count} (expected before scheduling: 0)"
+    info "System/other alarms: ${system_count} (for context)"
     
-    if [ "${INITIAL_COUNT}" -eq "0" ] 2>/dev/null; then
-        print_success "✅ No existing notification alarms (clean state)"
-        wait_for_ui_action "In the app UI, schedule a daily notification.
+    if [ "${initial_count}" -eq "0" ] 2>/dev/null; then
+        ok "No existing notification alarms (clean state)"
         
-        For this test, you may want to schedule it for a time very soon
-        (e.g., 1-2 minutes from now) to observe the rollover behavior.
-        
-        This will schedule:
-        - 1 notification alarm (AlarmManager) for the specified time
-        - 1 prefetch job (WorkManager) for 2 minutes before that time"
-        sleep 3  # Give alarm time to be registered in AlarmManager
-        
-        # Capture post-schedule UI state
-        take_screenshot "phase1_test0_daily_rollover" "after_scheduling"
-        
-        POST_SCHEDULE_COUNT=$(get_plugin_alarm_count)
-        
-        # Check alarm count after scheduling
-        # Note: This is a PRELIMINARY sanity check only - final verdict comes after rollover
-        # 0 alarms is likely a race condition (alarm may not be visible yet in dumpsys)
-        # Only treat >1 alarms as a real failure (duplicates)
-        if [ "${POST_SCHEDULE_COUNT}" -eq "0" ] 2>/dev/null; then
-            print_warn "⚠️  Found 0 plugin alarms right after scheduling."
-            print_info "ℹ️  Pre-schedule check not reliable; will rely on rollover assertions."
-            print_info "ℹ️  The alarm may not be visible in dumpsys yet. Continuing to verify after rollover."
-        elif [ "${POST_SCHEDULE_COUNT}" -eq "1" ] 2>/dev/null; then
-            print_success "✅ Found 1 notification alarm (expected: 1) – preliminary check passed."
-            print_info "ℹ️  This is preliminary check only; final verdict after rollover."
+        if [ "${MODE}" != "ci" ]; then
+          ui_prompt "1) In the app UI, schedule a daily notification.
+          
+          For this test, schedule it for a time very soon (e.g., 1-2 minutes from now)
+          to observe the rollover behavior.
+          
+          This will schedule:
+          • 1 notification alarm (AlarmManager) for the specified time
+          • 1 prefetch job (WorkManager) for 2 minutes before that time"
         else
-            # count > 1 - this is a real duplicate bug
-            print_warn "⚠️  ⚠️  Found ${POST_SCHEDULE_COUNT} notification alarms (expected: 1) – DUPLICATES DETECTED right after scheduling!"
-            print_warn "This indicates duplicate NOTIFICATION alarms were created (BUG DETECTED)"
-            print_info "Showing alarm blocks for debugging:"
-            show_plugin_alarms_compact
-            print_info "For more details, run:"
-            print_info "  adb shell dumpsys alarm | grep -A 5 'com.timesafari.dailynotification' | sed -n '1,80p'"
+          info "CI mode: Assuming notification is scheduled manually"
+          sleep 3
         fi
-        INITIAL_COUNT="${POST_SCHEDULE_COUNT}"
-    fi
-    
-    # Only show alarm details if we found exactly 1 alarm (skip if 0 due to race condition)
-    if [ "${INITIAL_COUNT}" -eq "1" ] 2>/dev/null; then
-        print_success "✅ Single notification alarm scheduled (one per day)"
-        print_info "Note: Prefetch uses WorkManager (not AlarmManager), so it won't appear in alarm count"
         
-        # Show alarm details
-        ALARM_DETAILS=$($ADB_BIN shell dumpsys alarm | grep -A 3 "com.timesafari.dailynotification" | grep -A 3 "com.timesafari.daily.NOTIFICATION" | head -10)
-        if [ -n "${ALARM_DETAILS}" ]; then
-            print_info "Notification alarm details:"
-            echo "${ALARM_DETAILS}" | head -5
-            echo ""
-            
-            # Extract trigger time
-            ALARM_TRIGGER_MS=$(echo "${ALARM_DETAILS}" | grep -oE "origWhen [0-9]+" | head -1 | awk '{print $2}')
-            if [ -n "${ALARM_TRIGGER_MS}" ]; then
-                ALARM_TRIGGER_SEC=$((ALARM_TRIGGER_MS / 1000))
-                ALARM_READABLE=$(date -d "@${ALARM_TRIGGER_SEC}" 2>/dev/null || echo "${ALARM_TRIGGER_MS} ms")
-                print_info "Notification alarm scheduled for: ${ALARM_READABLE}"
-                
-                # Calculate prefetch time (2 minutes before)
-                PREFETCH_SEC=$((ALARM_TRIGGER_SEC - 120))
-                PREFETCH_READABLE=$(date -d "@${PREFETCH_SEC}" 2>/dev/null || echo "${PREFETCH_SEC}")
-                print_info "Prefetch should be scheduled for: ${PREFETCH_READABLE} (2 minutes before, via WorkManager)"
-                
-                # Calculate next day
-                NEXT_DAY_SEC=$((ALARM_TRIGGER_SEC + 86400))
-                NEXT_DAY_READABLE=$(date -d "@${NEXT_DAY_SEC}" 2>/dev/null || echo "${NEXT_DAY_SEC}")
-                print_info "Expected next day notification: ${NEXT_DAY_READABLE} (24 hours later)"
-            fi
+        sleep 3  # Give alarm time to be registered
+        
+        # Capture post-schedule state
+        capture_alarms "test0_after_schedule"
+        capture_screenshot "test0_after_schedule"
+        
+        local post_schedule_count
+        post_schedule_count="$(get_plugin_alarm_count)"
+        
+        # Preliminary check (final verdict comes after rollover)
+        if [ "${post_schedule_count}" -eq "0" ] 2>/dev/null; then
+            warn "Found 0 plugin alarms right after scheduling (may be race condition)"
+            info "Alarm may not be visible in dumpsys yet - will verify after rollover"
+        elif [ "${post_schedule_count}" -eq "1" ] 2>/dev/null; then
+            ok "Found 1 notification alarm (expected: 1) - preliminary check passed"
+        else
+            warn "Found ${post_schedule_count} notification alarms (expected: 1) - DUPLICATES DETECTED!"
+            error "This indicates duplicate NOTIFICATION alarms were created (BUG)"
+            show_plugin_alarms_compact
         fi
-    elif [ "${INITIAL_COUNT}" -gt "1" ] 2>/dev/null; then
-        print_warn "⚠️  Found ${INITIAL_COUNT} notification alarms (expected: 1) - DUPLICATES DETECTED!"
-        print_warn "This indicates the duplicate alarm bug - multiple alarms for the same notification"
+        initial_count="${post_schedule_count}"
     fi
-    # Note: We intentionally don't print anything for INITIAL_COUNT == 0 here
-    # because we already handled it above with the race condition message
     
-    print_step "2" "Manual verification steps..."
-    echo ""
-    echo "To complete this test, you need to:"
-    echo "  1. Wait for the notification to fire (or advance emulator clock)"
-    echo "  2. Check that the plugin:"
-    echo "     - Computed the next day's time (24 hours later)"
-    echo "     - Scheduled exactly ONE notification alarm (AlarmManager) for tomorrow"
-    echo "     - Scheduled exactly ONE prefetch job (WorkManager) for 2 minutes before tomorrow's notification"
-    echo "     - Did NOT create duplicate notification alarms"
-    echo "  3. Verify in logs:"
-    echo "     - Next run time calculation shows tomorrow's time"
-    echo "     - Only one notification alarm scheduled in AlarmManager"
-    echo "     - Prefetch job scheduled in WorkManager"
-    echo ""
-    echo "Expected log patterns:"
-    echo "  DNP-SCHEDULE: Scheduling next daily alarm: ... source=ROLLOVER_ON_FIRE"
-    echo "  DNP-NOTIFY: Scheduling alarm: triggerTime=<tomorrow's time>"
-    echo "  DNP-SCHEDULE: Scheduling OS alarm: variant=ALARM_CLOCK, action=com.timesafari.daily.NOTIFICATION, ..."
-    echo ""
-    echo "When scheduling the test notification, expect:"
-    echo "  DNP-SCHEDULE: ... source=TEST_NOTIFICATION"
-    echo ""
-    echo "Alarm shape in dumpsys:"
-    echo "  RTC_WAKEUP, ALARM_CLOCK, tag=*walarm*:com.timesafari.daily.NOTIFICATION"
-    echo ""
-    echo "After notification fires, run:"
-    echo "  adb shell dumpsys alarm | grep -A 3 'com.timesafari.dailynotification'"
-    echo "  adb logcat -d | grep -E 'DNP-SCHEDULE|DNP-NOTIFY' | tail -20"
+    # Show alarm details if we found exactly 1 alarm
+    if [ "${initial_count}" -eq "1" ] 2>/dev/null; then
+        ok "Single notification alarm scheduled (one per day)"
+        
+        local alarm_details
+        alarm_details="$($ADB_BIN shell dumpsys alarm | grep -A 3 "com.timesafari.dailynotification" | grep -A 3 "com.timesafari.daily.NOTIFICATION" | head -10)"
+        if [ -n "${alarm_details}" ]; then
+            info "Notification alarm details:"
+            echo "${alarm_details}" | head -5
+            echo ""
+        fi
+    elif [ "${initial_count}" -gt "1" ] 2>/dev/null; then
+        warn "Found ${initial_count} notification alarms (expected: 1) - DUPLICATES DETECTED!"
+    fi
+    
+    substep "Step 2: Wait for notification to fire"
+    info "To complete this test:"
+    echo "  1. Wait for notification to fire (or advance emulator clock)"
+    echo "  2. Verify plugin computed next day's time (24 hours later)"
+    echo "  3. Verify exactly ONE notification alarm exists for tomorrow"
+    echo "  4. Verify no duplicate alarms were created"
     echo ""
     
-    wait_for_ui_action "After the notification fires (or you advance the clock),
-    check the logs and AlarmManager to verify:
-    
-    1. Only ONE alarm exists (one per day)
-    2. The alarm time is for tomorrow (24 hours later)
-    3. No duplicate alarms were created
-    
-    Press Enter when you've verified this (or to skip this test)."
-    
-    print_info "Polling for stable alarm count (allowing up to ~10 seconds for Android to settle)..."
-    POST_ROLLOVER_COUNT=$(wait_for_stable_plugin_alarm_count 5 2)
-    SYSTEM_FINAL=$(get_system_alarm_count)
-    print_info "Notification alarms after rollover: ${POST_ROLLOVER_COUNT} (expected: 1)"
-    print_info "System/other alarms: ${SYSTEM_FINAL} (for context)"
-    print_info "Note: Prefetch is scheduled via WorkManager (not AlarmManager), so it won't appear in alarm count"
-    
-    # Capture post-rollover UI state
-    take_screenshot "phase1_test0_daily_rollover" "after_rollover_check"
-    
-    # After rollover, the state should be stable - this is the real assertion point
-    if [ "${POST_ROLLOVER_COUNT}" -eq "1" ] 2>/dev/null; then
-        print_success "✅ TEST 0 PASSED: Daily rollover created exactly one NOTIFICATION alarm for tomorrow."
-        print_info "Expected state after rollover:"
-        echo "  ✅ 1 notification alarm (AlarmManager) for tomorrow"
-        echo "  ✅ 1 prefetch job (WorkManager) for 2 minutes before tomorrow's notification"
-    elif [ "${POST_ROLLOVER_COUNT}" -gt "1" ] 2>/dev/null; then
-        print_warn "⚠️  ⚠️  TEST 0 FAILED: Daily rollover created ${POST_ROLLOVER_COUNT} NOTIFICATION alarms (duplicates)."
-        print_warn "This indicates duplicate NOTIFICATION alarms were created (BUG DETECTED)"
-        take_failure_screenshot "phase1_test0_daily_rollover" "duplicate_alarms"
-        echo ""
-        print_info "Showing alarm blocks for debugging:"
-        show_plugin_alarms_compact
-        echo ""
-        print_info "Check scheduling logs for multiple DNP-SCHEDULE entries:"
-        print_info "  adb logcat -d | grep 'DNP-SCHEDULE\|DNP-NOTIFY' | tail -20"
-        echo ""
-        print_info "Possible causes:"
-        echo "  - Multiple scheduling paths racing (rollover + recovery)"
-        echo "  - Old alarm wasn't canceled before scheduling new one"
-        echo "  - Different scheduleIds used for same trigger time"
-        echo "  - Idempotence check not working correctly"
+    if [ "${MODE}" != "ci" ]; then
+      ui_prompt "2) After the notification fires (or you advance the clock), verify:
+      
+      • Only ONE alarm exists (one per day)
+      • Alarm time is for tomorrow (24 hours later)
+      • No duplicate alarms were created
+      
+      Press Enter when you've verified this (or to skip this test)."
     else
-        # count is 0 or invalid - rollover may have failed
-        print_warn "⚠️  TEST 0 INCONCLUSIVE: No NOTIFICATION alarm found after rollover (expected 1, got 0)"
-        print_warn "This indicates the rollover did not schedule tomorrow's alarm correctly"
-        take_failure_screenshot "phase1_test0_daily_rollover" "no_alarm_after_rollover"
-        echo ""
-        print_info "Showing alarm blocks for debugging:"
+      info "CI mode: Skipping manual verification step"
+      sleep 5  # Give time for rollover if automated
+    fi
+    
+    substep "Step 3: Verify rollover state"
+    info "Polling for stable alarm count (allowing up to ~10 seconds for Android to settle)..."
+    
+    local post_rollover_count system_final
+    post_rollover_count="$(wait_for_stable_plugin_alarm_count 5 2)"
+    system_final="$(get_system_alarm_count)"
+    
+    # Capture post-rollover state
+    capture_alarms "test0_after_rollover"
+    capture_logcat "test0_after_rollover" "DNP-SCHEDULE|DNP-NOTIFY|ROLLOVER" 100
+    capture_screenshot "test0_after_rollover"
+    
+    info "Notification alarms after rollover: ${post_rollover_count} (expected: 1)"
+    info "System/other alarms: ${system_final} (for context)"
+    
+    # Final verdict
+    if [ "${post_rollover_count}" -eq "1" ] 2>/dev/null; then
+        verdict_pass "test0_daily_rollover" "Daily rollover created exactly one NOTIFICATION alarm for tomorrow"
+    elif [ "${post_rollover_count}" -gt "1" ] 2>/dev/null; then
+        error "Daily rollover created ${post_rollover_count} NOTIFICATION alarms (duplicates)"
         show_plugin_alarms_compact
-        echo ""
-        print_info "Expected log pattern after fire:"
-        echo "  DNP-SCHEDULE: Scheduling next daily alarm: ... source=ROLLOVER_ON_FIRE"
-        echo "  DNP-NOTIFY: Scheduling alarm: triggerTime=<tomorrow>"
-        echo "  DNP-SCHEDULE: Scheduling OS alarm: variant=ALARM_CLOCK, action=com.timesafari.daily.NOTIFICATION, ..."
-        echo ""
-        print_info "Check logs for rollover scheduling errors:"
-        print_info "  adb logcat -d | grep 'DNP-SCHEDULE\|DNP-NOTIFY' | tail -20"
-        echo ""
-        print_info "Manual verification:"
-        echo "  If dumpsys shows a single RTC_WAKEUP alarm with"
-        echo "  tag=*walarm*:com.timesafari.daily.NOTIFICATION for tomorrow,"
-        echo "  treat TEST 0 as manually PASSED and update the script expectations later."
+        verdict_fail "test0_daily_rollover" "Duplicate alarms detected after rollover (expected: 1, got: ${post_rollover_count})"
+    else
+        warn "No NOTIFICATION alarm found after rollover (expected: 1, got: 0)"
+        show_plugin_alarms_compact
+        verdict_warn "test0_daily_rollover" "Rollover may have failed - no alarm found (expected: 1, got: 0)"
     fi
     
-    wait_for_user
+    evidence_block "test0_daily_rollover"
+    
+    if [ "${MODE}" != "ci" ]; then
+      pause
+    fi
+  fi  # End of "if should_run_test 0" block
+  
+  # ============================================
+  # TEST 1: Force-Stop Recovery - Database Restoration
+  # ============================================
+  if should_run_test "1" SELECTED_TESTS; then
+    section "TEST 1: Force-Stop Recovery - Database Restoration"
+    
+    info "Purpose: Verify that after force-stop (which clears alarms), recovery"
+    info "        uses the database to rebuild alarms on app relaunch."
+    info ""
+    info "Expected time: 5-8 minutes"
+    info "Automatable: Partial (requires manual force-stop verification)"
+    echo ""
+    
+    if [ "${MODE}" != "ci" ]; then
+      pause
     fi
     
-    # ============================================
-    # TEST 1: Force-Stop Recovery - Database Restoration
-    # ============================================
-    if should_run_test "1" SELECTED_TESTS; then
-    print_header "TEST 1: Force-Stop Recovery - Database Restoration"
-    echo "Purpose: Verify that after force-stop (which clears alarms), recovery"
-    echo "        uses the database to rebuild alarms on app relaunch."
-    echo ""
-    echo "Note: App supports one alarm per day."
-    echo ""
-    echo "Test sequence:"
-    echo "  1. Clean start - verify no lingering alarms"
-    echo "  2. Schedule one alarm → Verify it exists in AlarmManager"
-    echo "  3. Force-stop app → Verify alarm is cleared (count = 0)"
-    echo "  4. Relaunch app → Verify recovery rebuilds alarm from database"
-    echo "  5. Verify alarm actually fires at scheduled time (optional)"
-    echo ""
-    wait_for_user
+    # Capture initial state
+    capture_alarms "test1_initial"
+    capture_logcat "test1_initial" "DNP" 50
     
-    # ============================================
-    # Step 1: Clean start - verify no lingering alarms
-    # ============================================
-    print_step "1" "Clean start - checking for lingering alarms..."
-    LINGERING_COUNT=$(get_plugin_alarm_count)
-    SYSTEM_COUNT=$(get_system_alarm_count)
-    print_info "Current plugin notification alarms: ${LINGERING_COUNT}"
-    print_info "System/other alarms: ${SYSTEM_COUNT} (for context)"
+    substep "Step 1: Clean start - verify no lingering alarms"
+    local lingering_count system_count
+    lingering_count="$(get_plugin_alarm_count)"
+    system_count="$(get_system_alarm_count)"
+    info "Current plugin notification alarms: ${lingering_count}"
+    info "System/other alarms: ${system_count} (for context)"
     
-    if [ "${LINGERING_COUNT}" -gt "0" ] 2>/dev/null; then
-        print_warn "Found ${LINGERING_COUNT} lingering plugin alarm(s) - these will interfere with TEST 1."
-        print_info "TEST 1 needs a clean state (no existing plugin alarms)."
-        print_info "Resetting app state via uninstall + reinstall..."
+    local goto_test1_end=false
+    
+    if [ "${lingering_count}" -gt "0" ] 2>/dev/null; then
+        warn "Found ${lingering_count} lingering plugin alarm(s) - these will interfere with TEST 1"
+        info "TEST 1 needs a clean state (no existing plugin alarms)"
+        info "Resetting app state via uninstall + reinstall..."
         
         # Uninstall existing app
-        print_info "Uninstalling existing app..."
+        info "Uninstalling existing app..."
         set +e
+        local uninstall_output uninstall_status
         uninstall_output="$($ADB_BIN uninstall "$APP_ID" 2>&1)"
         uninstall_status=$?
         set -e
         
         if [ $uninstall_status -eq 0 ]; then
-            print_success "App uninstall succeeded (clean slate)."
+            ok "App uninstall succeeded (clean slate)"
         else
             if grep -q "DELETE_FAILED_INTERNAL_ERROR" <<<"$uninstall_output"; then
-                print_info "No existing app to uninstall (continuing)"
+                info "No existing app to uninstall (continuing)"
             else
-                print_warn "App uninstall reported an error: $uninstall_output (continuing anyway)"
+                warn "App uninstall reported an error: $uninstall_output (continuing anyway)"
             fi
         fi
         
         # Reinstall APK
-        print_info "Reinstalling APK..."
+        info "Reinstalling APK..."
         if $ADB_BIN install -r "$APK_PATH" >/dev/null 2>&1; then
-            print_success "App reinstall succeeded."
+            ok "App reinstall succeeded"
         else
-            print_error "App reinstall FAILED - cannot proceed with TEST 1."
-            print_warn "Marking TEST 1 as INCONCLUSIVE due to dirty starting state."
-            take_failure_screenshot "phase1_test1_force_stop" "dirty_state_reinstall_failed"
-            wait_for_user
-            # Skip to end of TEST 1 block
+            error "App reinstall FAILED - cannot proceed with TEST 1"
+            warn "Marking TEST 1 as INCONCLUSIVE due to dirty starting state"
+            capture_screenshot "test1_dirty_state_reinstall_failed"
+            if [ "${MODE}" != "ci" ]; then
+              pause
+            fi
             goto_test1_end=true
         fi
         
-        if [ "${goto_test1_end:-false}" != "true" ]; then
+        if [ "${goto_test1_end}" != "true" ]; then
             # Verify install
             if ! $ADB_BIN shell pm list packages | grep -q "$APP_ID"; then
-                print_error "App not found in package list after reinstall - aborting TEST 1."
-                take_failure_screenshot "phase1_test1_force_stop" "dirty_state_verify_failed"
-                wait_for_user
+                error "App not found in package list after reinstall - aborting TEST 1"
+                capture_screenshot "test1_dirty_state_verify_failed"
+                if [ "${MODE}" != "ci" ]; then
+                  pause
+                fi
                 goto_test1_end=true
             fi
         fi
         
-        if [ "${goto_test1_end:-false}" != "true" ]; then
+        if [ "${goto_test1_end}" != "true" ]; then
             # Clear logs
-            print_info "Clearing logcat buffer after reinstall..."
+            info "Clearing logcat buffer after reinstall..."
             $ADB_BIN logcat -c || true
             
             # Re-check plugin alarms
-            print_info "Rechecking plugin alarms after reset..."
-            sleep 2  # Give system time to clear alarms
-            LINGERING_COUNT=$(get_plugin_alarm_count)
-            print_info "Plugin alarms after reset: ${LINGERING_COUNT} (expected: 0)"
+            info "Rechecking plugin alarms after reset..."
+            sleep 2
+            lingering_count="$(get_plugin_alarm_count)"
+            info "Plugin alarms after reset: ${lingering_count} (expected: 0)"
             
-            if [ "${LINGERING_COUNT}" -ne "0" ] 2>/dev/null; then
-                print_warn "TEST 1 starting with non-zero alarm count even after reset; treating as INCONCLUSIVE."
-                print_info "This may indicate device-specific behavior where alarms persist across uninstall."
-                take_failure_screenshot "phase1_test1_force_stop" "unexpected_alarms_after_reset"
-                wait_for_user
+            if [ "${lingering_count}" -ne "0" ] 2>/dev/null; then
+                warn "TEST 1 starting with non-zero alarm count even after reset; treating as INCONCLUSIVE"
+                info "This may indicate device-specific behavior where alarms persist across uninstall"
+                capture_screenshot "test1_unexpected_alarms_after_reset"
+                if [ "${MODE}" != "ci" ]; then
+                  pause
+                fi
                 goto_test1_end=true
             fi
         fi
         
-        if [ "${goto_test1_end:-false}" = "true" ]; then
-            print_warn "TEST 1 skipped due to inability to achieve clean starting state."
-            wait_for_user
+        if [ "${goto_test1_end}" = "true" ]; then
+            warn "TEST 1 skipped due to inability to achieve clean starting state"
+            if [ "${MODE}" != "ci" ]; then
+              pause
+            fi
         else
-            print_success "App state reset complete. TEST 1 starting from clean state."
+            ok "App state reset complete. TEST 1 starting from clean state"
         fi
     else
-        print_success "No lingering plugin alarms found (clean state)"
+        ok "No lingering plugin alarms found (clean state)"
     fi
     
     # Skip remaining TEST 1 steps if we couldn't achieve clean state
-    if [ "${goto_test1_end:-false}" != "true" ]; then
+    if [ "${goto_test1_end}" != "true" ]; then
     
-    # ============================================
-    # Step 2: Schedule a known future alarm
-    # ============================================
-    print_step "2" "Launch app and schedule alarm..."
+    substep "Step 2: Schedule a known future alarm"
     launch_app
     ensure_plugin_configured
     
-    wait_for_ui_action "In the app UI, click the 'Test Notification' button.
+    if [ "${MODE}" != "ci" ]; then
+      ui_prompt "1) In the app UI, click the 'Test Notification' button.
+      
+      This will schedule ONE notification for 4 minutes in the future.
+      (App supports one alarm per day)
+      
+      The alarm will be stored in the database AND scheduled in AlarmManager."
+    else
+      info "CI mode: Assuming notification is scheduled manually"
+      sleep 3
+    fi
     
-    This will schedule ONE notification for 4 minutes in the future.
-    (App supports one alarm per day)
-    
-    The alarm will be stored in the database AND scheduled in AlarmManager."
-    
-    print_step "3" "Verifying alarm exists in AlarmManager (BEFORE force-stop)..."
     sleep 2
     
-    ALARM_COUNT_BEFORE=$(get_plugin_alarm_count)
-    SYSTEM_COUNT_BEFORE=$(get_system_alarm_count)
-    print_info "Plugin alarms: ${ALARM_COUNT_BEFORE} (expected: 1)"
-    print_info "System/other alarms: ${SYSTEM_COUNT_BEFORE} (for context)"
+    # Capture before force-stop state
+    capture_alarms "test1_before_force_stop"
+    capture_logcat "test1_before_force_stop" "DNP-SCHEDULE|DNP-NOTIFY" 50
     
-    if [ "${ALARM_COUNT_BEFORE}" -eq "0" ] 2>/dev/null; then
-        print_error "No plugin alarms found in AlarmManager - cannot test force-stop recovery"
-        print_info "Make sure you clicked 'Test Notification' and wait a moment"
-        wait_for_user
+    substep "Step 3: Verify alarm exists in AlarmManager (BEFORE force-stop)"
+    local alarm_count_before system_count_before
+    alarm_count_before="$(get_plugin_alarm_count)"
+    system_count_before="$(get_system_alarm_count)"
+    info "Plugin alarms: ${alarm_count_before} (expected: 1)"
+    info "System/other alarms: ${system_count_before} (for context)"
+    
+    if [ "${alarm_count_before}" -eq "0" ] 2>/dev/null; then
+        error "No plugin alarms found in AlarmManager - cannot test force-stop recovery"
+        info "Make sure you clicked 'Test Notification' and wait a moment"
+        if [ "${MODE}" != "ci" ]; then
+          pause
+        fi
         # Re-check
-        ALARM_COUNT_BEFORE=$(get_plugin_alarm_count)
-        if [ "${ALARM_COUNT_BEFORE}" -eq "0" ] 2>/dev/null; then
-            print_error "Still no alarms found - aborting test"
-            exit 1
+        alarm_count_before="$(get_plugin_alarm_count)"
+        if [ "${alarm_count_before}" -eq "0" ] 2>/dev/null; then
+            error "Still no alarms found - aborting test"
+            verdict_fail "test1_force_stop_recovery" "No alarms found before force-stop - cannot test recovery"
+            evidence_block "test1_force_stop_recovery"
+            goto_test1_end=true
         fi
     fi
     
-    if [ "${ALARM_COUNT_BEFORE}" -eq "1" ] 2>/dev/null; then
-        print_success "✅ Single plugin alarm confirmed in AlarmManager (one per day)"
+    if [ "${alarm_count_before}" -eq "1" ] 2>/dev/null; then
+        ok "Single plugin alarm confirmed in AlarmManager (one per day)"
     else
-        print_warn "⚠️  Found ${ALARM_COUNT_BEFORE} plugin alarms (expected: 1) - continuing anyway"
+        warn "Found ${alarm_count_before} plugin alarms (expected: 1) - continuing anyway"
     fi
     
-    # Capture alarm details for later verification
-    ALARM_DETAILS_BEFORE=$($ADB_BIN shell dumpsys alarm | grep -A 3 "$APP_ID" | head -10)
-    print_info "Alarm details:"
-    echo "${ALARM_DETAILS_BEFORE}" | head -5
-    echo ""
-    
     # Extract trigger time for later verification
-    ALARM_TRIGGER_MS=$(echo "${ALARM_DETAILS_BEFORE}" | grep -oE "origWhen [0-9]+" | head -1 | awk '{print $2}')
-    if [ -n "${ALARM_TRIGGER_MS}" ]; then
-        ALARM_TRIGGER_SEC=$((ALARM_TRIGGER_MS / 1000))
-        ALARM_READABLE=$(date -d "@${ALARM_TRIGGER_SEC}" 2>/dev/null || echo "${ALARM_TRIGGER_SEC}")
-        print_info "Alarm scheduled for: ${ALARM_READABLE} (${ALARM_TRIGGER_MS} ms)"
+    local alarm_details_before alarm_trigger_ms alarm_trigger_sec alarm_readable
+    alarm_details_before="$($ADB_BIN shell dumpsys alarm | grep -A 3 "$APP_ID" | head -10)"
+    if [ -n "${alarm_details_before}" ]; then
+        info "Alarm details:"
+        echo "${alarm_details_before}" | head -5
+        echo ""
     fi
     
-    print_info "Checking logs for scheduling confirmation..."
-    $ADB_BIN logcat -d | grep -E "DN|SCHEDULE|Stored notification content" | tail -5
-    echo ""
+    alarm_trigger_ms=$(echo "${alarm_details_before}" | grep -oE "origWhen [0-9]+" | head -1 | awk '{print $2}')
+    if [ -n "${alarm_trigger_ms}" ]; then
+        alarm_trigger_sec=$((alarm_trigger_ms / 1000))
+        alarm_readable=$(date -d "@${alarm_trigger_sec}" 2>/dev/null || echo "${alarm_trigger_sec}")
+        info "Alarm scheduled for: ${alarm_readable} (${alarm_trigger_ms} ms)"
+    fi
     
-    wait_for_user
+    if [ "${MODE}" != "ci" ]; then
+      pause
+    fi
     
-    # ============================================
-    # Step 3: Force-stop the app (clears alarms)
-    # ============================================
-    print_step "4" "Force-stopping app (clears all alarms)..."
-    print_warn "Force-stop will clear ALL alarms from AlarmManager"
-    print_info "Executing: $ADB_BIN shell am force-stop ${APP_ID}"
+    substep "Step 4: Force-stop the app (clears alarms)"
+    warn "Force-stop will clear ALL alarms from AlarmManager"
+    info "Executing: $ADB_BIN shell am force-stop ${APP_ID}"
     force_stop_app
     sleep 2
     
-    # Verify app is stopped (force_stop_app already handles this)
+    # Capture after force-stop state
+    capture_alarms "test1_after_force_stop"
     
-    # ============================================
-    # Step 4: Verify alarms are MISSING (cleared by OS)
-    # ============================================
-    print_step "5" "Verifying alarms are MISSING from AlarmManager (AFTER force-stop)..."
+    substep "Step 5: Verify alarms are MISSING (cleared by OS)"
     sleep 1
-    ALARM_COUNT_AFTER=$(get_plugin_alarm_count)
-    SYSTEM_COUNT_AFTER=$(get_system_alarm_count)
-    print_info "Plugin alarms after force-stop: ${ALARM_COUNT_AFTER} (expected: 0)"
-    print_info "System/other alarms: ${SYSTEM_COUNT_AFTER} (for context)"
+    local alarm_count_after system_count_after
+    alarm_count_after="$(get_plugin_alarm_count)"
+    system_count_after="$(get_system_alarm_count)"
+    info "Plugin alarms after force-stop: ${alarm_count_after} (expected: 0)"
+    info "System/other alarms: ${system_count_after} (for context)"
     
-    if [ "${ALARM_COUNT_AFTER}" -eq "0" ] 2>/dev/null; then
-        print_success "✅ Plugin alarms cleared by force-stop (count: ${ALARM_COUNT_AFTER})"
-        print_info "This confirms: Force-stop cleared alarms from AlarmManager"
+    if [ "${alarm_count_after}" -eq "0" ] 2>/dev/null; then
+        ok "Plugin alarms cleared by force-stop (count: ${alarm_count_after})"
+        info "This confirms: Force-stop cleared alarms from AlarmManager"
     else
-        print_warn "⚠️  Plugin alarms still present after force-stop (count: ${ALARM_COUNT_AFTER})"
-        print_info "Some devices/OS versions may not clear alarms on force-stop"
-        print_info "Continuing test anyway - recovery should still work"
+        warn "Plugin alarms still present after force-stop (count: ${alarm_count_after})"
+        info "Some devices/OS versions may not clear alarms on force-stop"
+        info "Continuing test anyway - recovery should still work"
     fi
     
-    wait_for_user
+    if [ "${MODE}" != "ci" ]; then
+      pause
+    fi
     
-    # ============================================
-    # Step 5: Relaunch app (triggers recovery from database)
-    # ============================================
-    print_step "6" "Relaunching app (triggers recovery from database)..."
+    substep "Step 6: Relaunch app (triggers recovery from database)"
     clear_logs
     launch_app
     sleep 4  # Give recovery time to run
     
-    # ============================================
-    # Step 6: Verify recovery rebuilt alarms from database
-    # ============================================
-    print_step "7" "Verifying recovery rebuilt alarms from database..."
+    substep "Step 7: Verify recovery rebuilt alarms from database"
     sleep 2
-    ALARM_COUNT_RECOVERED=$(get_plugin_alarm_count)
-    SYSTEM_COUNT_RECOVERED=$(get_system_alarm_count)
-    print_info "Plugin alarms after recovery: ${ALARM_COUNT_RECOVERED} (expected: 1)"
-    print_info "System/other alarms: ${SYSTEM_COUNT_RECOVERED} (for context)"
     
-    print_info "Checking recovery logs..."
+    # Capture after recovery state
+    capture_alarms "test1_after_recovery"
+    capture_logcat "test1_after_recovery" "DNP-REACTIVATION" 100
+    capture_screenshot "test1_after_recovery"
+    
+    local alarm_count_recovered system_count_recovered
+    alarm_count_recovered="$(get_plugin_alarm_count)"
+    system_count_recovered="$(get_system_alarm_count)"
+    info "Plugin alarms after recovery: ${alarm_count_recovered} (expected: 1)"
+    info "System/other alarms: ${system_count_recovered} (for context)"
+    
+    info "Checking recovery logs..."
     check_recovery_logs
     
-    print_info "Expected log output:"
+    info "Expected log output:"
     echo "  DNP-REACTIVATION: Starting app launch recovery"
     echo "  DNP-REACTIVATION: Rescheduled alarm: <id> for <time>"
     echo "  DNP-REACTIVATION: Cold start recovery complete: ... rescheduled>=1, ..."
     echo ""
     
     # Check recovery logs for rescheduling and recovery source
-    RECOVERY_RESULT=$($ADB_BIN logcat -d | grep "Cold start recovery complete\|Boot recovery complete" | tail -1)
-    RESCHEDULED_COUNT=$(echo "${RECOVERY_RESULT}" | grep -oE "rescheduled=[0-9]+" | grep -oE "[0-9]+" || echo "0")
-    VERIFIED_COUNT=$(echo "${RECOVERY_RESULT}" | grep -oE "verified=[0-9]+" | grep -oE "[0-9]+" || echo "0")
-    
-    # Check for explicit recovery source indication (if logged)
-    RECOVERY_SOURCE=$($ADB_BIN logcat -d | grep -E "recovery source|from database|DATABASE" | tail -1 || echo "")
+    local recovery_result rescheduled_count verified_count recovery_source
+    recovery_result="$($ADB_BIN logcat -d | grep "Cold start recovery complete\|Boot recovery complete" | tail -1)"
+    rescheduled_count=$(echo "${recovery_result}" | grep -oE "rescheduled=[0-9]+" | grep -oE "[0-9]+" || echo "0")
+    verified_count=$(echo "${recovery_result}" | grep -oE "verified=[0-9]+" | grep -oE "[0-9]+" || echo "0")
+    recovery_source="$($ADB_BIN logcat -d | grep -E "recovery source|from database|DATABASE" | tail -1 || echo "")"
     
     # Pass/fail criteria
-    TEST1_PASSED=false
+    local test1_passed=false
     
-    if [ "${ALARM_COUNT_RECOVERED}" -gt "0" ] 2>/dev/null; then
-        print_success "✅ Alarms restored in AlarmManager (count: ${ALARM_COUNT_RECOVERED})"
-        if [ "${RESCHEDULED_COUNT}" -gt "0" ] 2>/dev/null; then
-            print_success "✅ Recovery logs confirm rescheduling (rescheduled=${RESCHEDULED_COUNT})"
-            TEST1_PASSED=true
+    if [ "${alarm_count_recovered}" -gt "0" ] 2>/dev/null; then
+        ok "Alarms restored in AlarmManager (count: ${alarm_count_recovered})"
+        if [ "${rescheduled_count}" -gt "0" ] 2>/dev/null; then
+            ok "Recovery logs confirm rescheduling (rescheduled=${rescheduled_count})"
+            test1_passed=true
         else
-            print_warn "⚠️  Alarms restored but logs show rescheduled=0"
-            print_info "This might be okay if alarms were verified instead of rescheduled"
+            warn "Alarms restored but logs show rescheduled=0"
+            info "This might be okay if alarms were verified instead of rescheduled"
             # Still pass if alarms are restored, even if rescheduled=0
-            TEST1_PASSED=true
+            test1_passed=true
         fi
     else
-        print_error "❌ No alarms restored (count: ${ALARM_COUNT_RECOVERED})"
-        print_info "Recovery may have failed or alarms were not in database"
+        error "No alarms restored (count: ${alarm_count_recovered})"
+        info "Recovery may have failed or alarms were not in database"
     fi
     
-    if [ "${TEST1_PASSED}" = true ]; then
-        print_success "TEST 1 PASSED: Recovery successfully rebuilt alarms from database!"
-        print_info "Summary:"
-        echo "  - Before force-stop: ${ALARM_COUNT_BEFORE} alarm(s)"
-        echo "  - After force-stop: ${ALARM_COUNT_AFTER} alarm(s) (cleared)"
-        echo "  - After recovery: ${ALARM_COUNT_RECOVERED} alarm(s) (rebuilt)"
-        echo "  - Rescheduled: ${RESCHEDULED_COUNT} alarm(s)"
-        echo "  - Verified: ${VERIFIED_COUNT} alarm(s)"
-        if [ -n "${RECOVERY_SOURCE}" ]; then
-            echo "  - Recovery source: ${RECOVERY_SOURCE}"
-        fi
+    # Final verdict
+    if [ "${test1_passed}" = "true" ]; then
+        verdict_pass "test1_force_stop_recovery" "Recovery successfully rebuilt alarms from database (before: ${alarm_count_before}, after stop: ${alarm_count_after}, after recovery: ${alarm_count_recovered}, rescheduled: ${rescheduled_count})"
     else
-        print_error "TEST 1 FAILED: Recovery did not rebuild alarms correctly"
-        print_info "Check logs above for recovery errors"
+        verdict_fail "test1_force_stop_recovery" "Recovery did not rebuild alarms correctly (before: ${alarm_count_before}, after stop: ${alarm_count_after}, after recovery: ${alarm_count_recovered})"
     fi
     
-    # ============================================
-    # Step 7: Verify alarms actually fire (optional, controlled by VERIFY_FIRE flag)
-    # ============================================
-    if [ "${VERIFY_FIRE}" = "true" ] && [ -n "${ALARM_TRIGGER_MS}" ]; then
-        print_step "8" "Verifying alarm fires at scheduled time..."
+    evidence_block "test1_force_stop_recovery"
+    
+    # Optional: Verify alarm fires (controlled by VERIFY_FIRE flag)
+    if [ "${VERIFY_FIRE}" = "true" ] && [ -n "${alarm_trigger_ms}" ] && [ "${goto_test1_end}" != "true" ]; then
+        substep "Step 8: Verify alarm fires at scheduled time (optional)"
         
-        # Get current time in milliseconds
-        CURRENT_TIME_SEC=$(get_current_time)
-        CURRENT_TIME_MS=$((CURRENT_TIME_SEC * 1000))
-        WAIT_MS=$((ALARM_TRIGGER_MS - CURRENT_TIME_MS))
+        local current_time_sec current_time_ms wait_ms wait_sec
+        current_time_sec=$(get_current_time)
+        current_time_ms=$((current_time_sec * 1000))
+        wait_ms=$((alarm_trigger_ms - current_time_ms))
         
-        if [ "${WAIT_MS}" -lt 0 ]; then
-            print_warn "Alarm time already passed (${WAIT_MS} ms ago); skipping fire verification"
+        if [ "${wait_ms}" -lt 0 ]; then
+            warn "Alarm time already passed (${wait_ms} ms ago); skipping fire verification"
         else
-            WAIT_SEC=$((WAIT_MS / 1000))
+            wait_sec=$((wait_ms / 1000))
             
             # Clamp upper bound to prevent accidentally waiting 30+ minutes
-            if [ "${WAIT_SEC}" -gt 600 ]; then
-                print_warn "Alarm is >10 minutes away (${WAIT_SEC}s); skipping fire verification"
-                print_info "To test fire verification, schedule alarm closer to current time"
-                print_info "Or set a shorter test alarm interval in the app"
+            if [ "${wait_sec}" -gt 600 ]; then
+                warn "Alarm is >10 minutes away (${wait_sec}s); skipping fire verification"
+                info "To test fire verification, schedule alarm closer to current time"
             else
-                print_info "Alarm scheduled for: ${ALARM_READABLE}"
-                print_info "Current time: $(date -d "@${CURRENT_TIME_SEC}" 2>/dev/null || echo "${CURRENT_TIME_SEC}")"
-                print_info "Waiting ~${WAIT_SEC} seconds for alarm to fire..."
+                info "Alarm scheduled for: ${alarm_readable}"
+                info "Current time: $(date -d "@${current_time_sec}" 2>/dev/null || echo "${current_time_sec}")"
+                info "Waiting ~${wait_sec} seconds for alarm to fire..."
                 
-                # Clear logs before waiting
                 clear_logs
-                
-                # Wait for alarm time (with a small buffer)
-                sleep ${WAIT_SEC}
-                
-                # Give alarm a moment to fire and log
+                sleep ${wait_sec}
                 sleep 2
                 
-                print_info "Checking logs for fired alarm..."
-                ALARM_FIRED=$($ADB_BIN logcat -d | grep -E "DNP-RECEIVE|DNP-NOTIFY|DNP-WORK|Alarm fired|Notification displayed" | tail -10)
+                info "Checking logs for fired alarm..."
+                local alarm_fired
+                alarm_fired="$($ADB_BIN logcat -d | grep -E "DNP-RECEIVE|DNP-NOTIFY|DNP-WORK|Alarm fired|Notification displayed" | tail -10)"
                 
-                if [ -n "${ALARM_FIRED}" ]; then
-                    print_success "✅ Alarm fired! Logs:"
-                    echo "${ALARM_FIRED}"
+                if [ -n "${alarm_fired}" ]; then
+                    ok "Alarm fired! Logs:"
+                    echo "${alarm_fired}"
                 else
-                    print_warn "⚠️  No alarm fire logs found"
-                    print_info "This might mean:"
-                    echo "  - Alarm fired but logs were cleared"
-                    echo "  - Alarm receiver didn't log"
-                    echo "  - Check notification tray manually"
-                    print_info "Recent logs:"
-                    $ADB_BIN logcat -d | grep -E "DNP|DailyNotification" | tail -10
+                    warn "No alarm fire logs found"
+                    info "Check notification tray manually or review recent logs"
                 fi
             fi
         fi
-    elif [ "${VERIFY_FIRE}" = "true" ]; then
-        print_info "Skipping fire verification (alarm trigger time not captured)"
-    else
-        print_info "Skipping fire verification (VERIFY_FIRE=false, set VERIFY_FIRE=true to enable)"
     fi
     
-    fi  # End of "if goto_test1_end != true" block (wraps all TEST 1 steps after clean state check)
+    fi  # End of "if goto_test1_end != true" block
     
-    wait_for_user
-    fi  # End of "if should_run_test 1" block
+    if [ "${MODE}" != "ci" ]; then
+      pause
+    fi
+  fi  # End of "if should_run_test 1" block
+  
+  # ============================================
+  # TEST 2: Schedule Update (One-Per-Day Semantics)
+  # ============================================
+  if should_run_test "2" SELECTED_TESTS; then
+    section "TEST 2: Schedule Update Verification"
     
-    # ============================================
-    # TEST 2: Schedule Update (One-Per-Day Semantics)
-    # ============================================
-    if should_run_test "2" SELECTED_TESTS; then
-    print_header "TEST 2: Schedule Update Verification"
-    echo "Purpose: Verify that updating the schedule time maintains 'one per day' semantics."
+    info "Purpose: Verify that updating the schedule time maintains 'one per day' semantics"
+    info ""
+    info "Expected time: 4-6 minutes"
+    info "Automatable: Partial (requires manual schedule update)"
     echo ""
-    echo "Note: This test verifies that when the schedule time changes, the old alarm"
-    echo "      is canceled and only the new one remains (one notification per day)."
-    echo ""
-    wait_for_user
     
-    print_step "1" "Launch app and verify initial schedule"
+    if [ "${MODE}" != "ci" ]; then
+      pause
+    fi
+    
+    # Capture initial state
+    capture_alarms "test2_initial"
+    capture_logcat "test2_initial" "DNP" 50
+    
+    substep "Step 1: Launch app and verify initial schedule"
     launch_app
     ensure_plugin_configured
     
     # Get initial alarm count
-    INITIAL_ALARM_COUNT=$(get_plugin_alarm_count)
-    SYSTEM_ALARM_COUNT=$(get_system_alarm_count)
-    print_info "Plugin alarms: ${INITIAL_ALARM_COUNT} (expected: 1)"
-    print_info "System/other alarms: ${SYSTEM_ALARM_COUNT} (for context)"
+    local initial_alarm_count system_alarm_count
+    initial_alarm_count="$(get_plugin_alarm_count)"
+    system_alarm_count="$(get_system_alarm_count)"
+    info "Plugin alarms: ${initial_alarm_count} (expected: 1)"
+    info "System/other alarms: ${system_alarm_count} (for context)"
     
-    if [ "${INITIAL_ALARM_COUNT}" -eq "1" ] 2>/dev/null; then
-        print_success "✅ Initial alarm confirmed (one per day)"
-    elif [ "${INITIAL_ALARM_COUNT}" -eq "0" ] 2>/dev/null; then
-        print_warn "⚠️  No initial alarm found - scheduling one first..."
-        wait_for_ui_action "In the app UI, schedule a daily notification (e.g., click 'Test Notification')."
-        sleep 2
-        INITIAL_ALARM_COUNT=$(get_plugin_alarm_count)
-        if [ "${INITIAL_ALARM_COUNT}" -eq "1" ] 2>/dev/null; then
-            print_success "✅ Alarm scheduled"
+    if [ "${initial_alarm_count}" -eq "1" ] 2>/dev/null; then
+        ok "Initial alarm confirmed (one per day)"
+    elif [ "${initial_alarm_count}" -eq "0" ] 2>/dev/null; then
+        warn "No initial alarm found - scheduling one first..."
+        if [ "${MODE}" != "ci" ]; then
+          ui_prompt "1) In the app UI, schedule a daily notification (e.g., click 'Test Notification')."
         else
-            print_error "Failed to schedule initial alarm"
-            wait_for_user
+          info "CI mode: Assuming notification is scheduled manually"
+          sleep 2
+        fi
+        sleep 2
+        initial_alarm_count="$(get_plugin_alarm_count)"
+        if [ "${initial_alarm_count}" -eq "1" ] 2>/dev/null; then
+            ok "Alarm scheduled"
+        else
+            error "Failed to schedule initial alarm"
+            if [ "${MODE}" != "ci" ]; then
+              pause
+            fi
         fi
     else
-        print_warn "⚠️  Found ${INITIAL_ALARM_COUNT} plugin alarms (expected: 1) - continuing anyway"
+        warn "Found ${initial_alarm_count} plugin alarms (expected: 1) - continuing anyway"
     fi
     
-    print_step "2" "Updating schedule time"
-    wait_for_ui_action "In the app UI, change the schedule time (e.g., from 06:50 to 07:10)
-    and apply the schedule.
+    # Capture before update state
+    capture_alarms "test2_before_update"
     
-    This should cancel the old alarm and schedule a new one at the new time.
-    You should still have exactly 1 alarm (one per day)."
+    substep "Step 2: Update schedule time"
+    if [ "${MODE}" != "ci" ]; then
+      ui_prompt "2) In the app UI, change the schedule time (e.g., from 06:50 to 07:10)
+      and apply the schedule.
+      
+      This should cancel the old alarm and schedule a new one at the new time.
+      You should still have exactly 1 alarm (one per day)."
+    else
+      info "CI mode: Assuming schedule is updated manually"
+      sleep 3
+    fi
     
     sleep 3
-    check_alarm_status
     
-    UPDATED_ALARM_COUNT=$(get_plugin_alarm_count)
-    print_info "Plugin alarms after update: ${UPDATED_ALARM_COUNT} (expected: 1)"
+    # Capture after update state
+    capture_alarms "test2_after_update"
+    capture_logcat "test2_after_update" "DNP-SCHEDULE|DNP-NOTIFY" 50
     
-    if [ "${UPDATED_ALARM_COUNT}" -eq "1" ] 2>/dev/null; then
-        print_success "✅ Single alarm confirmed after schedule update (one per day maintained)"
-    elif [ "${UPDATED_ALARM_COUNT}" -gt "1" ] 2>/dev/null; then
-        print_error "❌ TEST 2 FAILED: Found ${UPDATED_ALARM_COUNT} plugin alarms after update (expected: 1)"
-        print_error "   Old alarm was NOT canceled - violates 'one per day' semantics"
-        print_info "   This indicates the plugin did not clean up existing schedules before creating new one"
-        TEST2_FAILED=true
+    local updated_alarm_count
+    updated_alarm_count="$(get_plugin_alarm_count)"
+    info "Plugin alarms after update: ${updated_alarm_count} (expected: 1)"
+    
+    local test2_failed=false
+    
+    if [ "${updated_alarm_count}" -eq "1" ] 2>/dev/null; then
+        ok "Single alarm confirmed after schedule update (one per day maintained)"
+    elif [ "${updated_alarm_count}" -gt "1" ] 2>/dev/null; then
+        error "TEST 2 FAILED: Found ${updated_alarm_count} plugin alarms after update (expected: 1)"
+        error "Old alarm was NOT canceled - violates 'one per day' semantics"
+        info "This indicates the plugin did not clean up existing schedules before creating new one"
+        test2_failed=true
     else
-        print_warn "⚠️  Found ${UPDATED_ALARM_COUNT} plugin alarms (expected: 1) - no alarm scheduled after update"
+        warn "Found ${updated_alarm_count} plugin alarms (expected: 1) - no alarm scheduled after update"
     fi
     
-    print_step "3" "Killing app and relaunching (triggers recovery)..."
+    substep "Step 3: Kill app and relaunch (triggers recovery)"
     kill_app
     clear_logs
     launch_app
     
-    print_step "4" "Checking recovery logs for verification..."
+    substep "Step 4: Check recovery logs and verify alarm count"
     sleep 3
+    
+    # Capture after recovery state
+    capture_alarms "test2_after_recovery"
+    capture_logcat "test2_after_recovery" "DNP-REACTIVATION" 100
+    
     check_recovery_logs
     
-    print_info "Expected log output (either):"
+    info "Expected log output (either):"
     echo "  DNP-REACTIVATION: Verified scheduled alarm: <id> at <time>"
     echo "    OR"
     echo "  DNP-REACTIVATION: Rescheduled missing alarm: <id> at <time>"
     echo "  DNP-REACTIVATION: Cold start recovery complete: ..., verified=1 or rescheduled=1, ..."
     echo ""
     
-    RECOVERY_RESULT=$($ADB_BIN logcat -d | grep "Cold start recovery complete" | tail -1)
-    
-    # Extract counts from recovery result
-    RESCHEDULED_COUNT=$(echo "${RECOVERY_RESULT}" | grep -oE "rescheduled=[0-9]+" | grep -oE "[0-9]+" || echo "0")
-    VERIFIED_COUNT=$(echo "${RECOVERY_RESULT}" | grep -oE "verified=[0-9]+" | grep -oE "[0-9]+" || echo "0")
-    
-    # Verify alarm count after recovery
-    ALARM_COUNT_AFTER_RECOVERY=$(get_plugin_alarm_count)
-    print_info "Plugin alarms after recovery: ${ALARM_COUNT_AFTER_RECOVERY} (expected: 1)"
+    local recovery_result rescheduled_count verified_count alarm_count_after_recovery
+    recovery_result="$($ADB_BIN logcat -d | grep "Cold start recovery complete" | tail -1)"
+    rescheduled_count=$(echo "${recovery_result}" | grep -oE "rescheduled=[0-9]+" | grep -oE "[0-9]+" || echo "0")
+    verified_count=$(echo "${recovery_result}" | grep -oE "verified=[0-9]+" | grep -oE "[0-9]+" || echo "0")
+    alarm_count_after_recovery="$(get_plugin_alarm_count)"
+    info "Plugin alarms after recovery: ${alarm_count_after_recovery} (expected: 1)"
     
     # CRITICAL: Test fails if alarm count > 1 after recovery (violates "one per day")
-    if [ "${ALARM_COUNT_AFTER_RECOVERY}" -gt "1" ] 2>/dev/null; then
-        print_error "❌ TEST 2 FAILED: Found ${ALARM_COUNT_AFTER_RECOVERY} plugin alarms after recovery (expected: 1)"
-        print_error "   Multiple schedules in database caused recovery to reschedule duplicates"
-        print_error "   This violates 'one per day' semantics - only one notification per day should exist"
-        TEST2_FAILED=true
-    fi
-    
-    if [ "${RESCHEDULED_COUNT}" -gt "0" ] 2>/dev/null; then
-        if [ "${ALARM_COUNT_AFTER_RECOVERY}" -eq "1" ] 2>/dev/null; then
-            print_success "✅ TEST 2 PASSED: Missing alarm was detected and rescheduled (rescheduled=${RESCHEDULED_COUNT})!"
-            print_success "✅ Single alarm confirmed after recovery (one per day maintained)"
-        elif [ "${TEST2_FAILED:-false}" != "true" ]; then
-            print_warn "⚠️  Recovery rescheduled ${RESCHEDULED_COUNT} alarm(s), but alarm count is ${ALARM_COUNT_AFTER_RECOVERY} (expected: 1)"
-        fi
-    elif [ "${VERIFIED_COUNT}" -gt "0" ] 2>/dev/null; then
-        if [ "${ALARM_COUNT_AFTER_RECOVERY}" -eq "1" ] 2>/dev/null; then
-            print_success "✅ TEST 2 PASSED: Alarm verified in AlarmManager (verified=${VERIFIED_COUNT})!"
-            print_success "✅ Single alarm confirmed after recovery (one per day maintained)"
-        elif [ "${TEST2_FAILED:-false}" != "true" ]; then
-            print_warn "⚠️  Recovery verified ${VERIFIED_COUNT} alarm(s), but alarm count is ${ALARM_COUNT_AFTER_RECOVERY} (expected: 1)"
-        fi
-    elif [ "${RESCHEDULED_COUNT}" -eq "0" ] 2>/dev/null && [ "${VERIFIED_COUNT}" -eq "0" ] 2>/dev/null; then
-        if [ "${ALARM_COUNT_AFTER_RECOVERY}" -eq "1" ] 2>/dev/null; then
-            print_success "✅ TEST 2 PASSED: No recovery needed - alarm already properly scheduled"
-            print_success "✅ Single alarm confirmed (one per day maintained)"
-        else
-            print_warn "⚠️  TEST 2: No verification/rescheduling needed (both verified=0 and rescheduled=0)"
-            print_info "This might mean:"
-            echo "  - Alarm was already properly scheduled and didn't need recovery"
-            echo "  - Recovery didn't detect any issues"
-            if [ "${ALARM_COUNT_AFTER_RECOVERY}" -eq "1" ] 2>/dev/null; then
-                print_success "✅ Single alarm still present - recovery may have verified it silently"
-            fi
-        fi
-    else
-        print_error "TEST 2 INCONCLUSIVE: Could not find recovery result"
-        print_info "Recovery result: ${RECOVERY_RESULT}"
+    if [ "${alarm_count_after_recovery}" -gt "1" ] 2>/dev/null; then
+        error "TEST 2 FAILED: Found ${alarm_count_after_recovery} plugin alarms after recovery (expected: 1)"
+        error "Multiple schedules in database caused recovery to reschedule duplicates"
+        error "This violates 'one per day' semantics - only one notification per day should exist"
+        test2_failed=true
     fi
     
     # Final verdict
-    if [ "${TEST2_FAILED:-false}" = "true" ]; then
-        print_error ""
-        print_error "════════════════════════════════════════════════════════════"
-        print_error "TEST 2 FINAL RESULT: ❌ FAILED"
-        print_error "════════════════════════════════════════════════════════════"
-        print_error "Reason: Multiple alarms detected - violates 'one per day' semantics"
-        print_error "Expected: 1 alarm after update and after recovery"
-        print_error "Actual: ${UPDATED_ALARM_COUNT} after update, ${ALARM_COUNT_AFTER_RECOVERY} after recovery"
-        print_error "════════════════════════════════════════════════════════════"
-    fi
-    
-    print_step "5" "Verifying alarms are still scheduled in AlarmManager..."
-    check_alarm_status
-    
-    wait_for_user
-    fi
-    
-    # ============================================
-    # TEST 3: Recovery Timeout
-    # ============================================
-    if should_run_test "3" SELECTED_TESTS; then
-    print_header "TEST 3: Recovery Timeout"
-    echo "Purpose: Verify recovery times out gracefully."
-    echo ""
-    echo "Note: This test requires creating many schedules (100+)."
-    echo "For now, we'll verify the timeout mechanism exists."
-    echo ""
-    wait_for_user
-    
-    print_step "1" "Checking recovery timeout implementation..."
-    if grep -q "RECOVERY_TIMEOUT_SECONDS.*2L" "${PROJECT_ROOT}/android/src/main/java/com/timesafari/dailynotification/ReactivationManager.kt"; then
-        print_success "Timeout is set to 2 seconds"
+    if [ "${test2_failed}" = "true" ]; then
+        verdict_fail "test2_schedule_update" "Multiple alarms detected - violates 'one per day' semantics (after update: ${updated_alarm_count}, after recovery: ${alarm_count_after_recovery})"
+    elif [ "${alarm_count_after_recovery}" -eq "1" ] 2>/dev/null; then
+        if [ "${rescheduled_count}" -gt "0" ] 2>/dev/null; then
+            verdict_pass "test2_schedule_update" "Schedule update maintained one per day semantics (rescheduled: ${rescheduled_count})"
+        elif [ "${verified_count}" -gt "0" ] 2>/dev/null; then
+            verdict_pass "test2_schedule_update" "Schedule update maintained one per day semantics (verified: ${verified_count})"
+        else
+            verdict_pass "test2_schedule_update" "Schedule update maintained one per day semantics (no recovery needed)"
+        fi
     else
-        print_error "Timeout not found in code"
+        verdict_warn "test2_schedule_update" "Schedule update result inconclusive (after update: ${updated_alarm_count}, after recovery: ${alarm_count_after_recovery})"
     fi
     
-    if grep -q "withTimeout" "${PROJECT_ROOT}/android/src/main/java/com/timesafari/dailynotification/ReactivationManager.kt"; then
-        print_success "Timeout protection is implemented"
+    evidence_block "test2_schedule_update"
+    
+    if [ "${MODE}" != "ci" ]; then
+      pause
+    fi
+  fi  # End of "if should_run_test 2" block
+  
+  # ============================================
+  # TEST 3: Recovery Timeout
+  # ============================================
+  if should_run_test "3" SELECTED_TESTS; then
+    section "TEST 3: Recovery Timeout"
+    
+    info "Purpose: Verify recovery times out gracefully"
+    info ""
+    info "Expected time: 2-3 minutes"
+    info "Automatable: Yes (code verification only)"
+    info "Note: Full test (100+ schedules) requires manual execution"
+    echo ""
+    
+    if [ "${MODE}" != "ci" ]; then
+      pause
+    fi
+    
+    # Capture initial state
+    capture_alarms "test3_initial"
+    
+    substep "Step 1: Check recovery timeout implementation"
+    local timeout_found timeout_protection_found
+    timeout_found=false
+    timeout_protection_found=false
+    
+    if grep -q "RECOVERY_TIMEOUT_SECONDS.*2L" "${PROJECT_ROOT}/android/src/main/java/com/timesafari/dailynotification/ReactivationManager.kt" 2>/dev/null; then
+        ok "Timeout is set to 2 seconds"
+        timeout_found=true
     else
-        print_error "Timeout protection not found"
+        error "Timeout not found in code"
     fi
     
-    print_info "TEST 3: Timeout mechanism verified in code"
-    print_info "Full test (100+ schedules) can be done manually if needed"
-    
-    wait_for_user
+    if grep -q "withTimeout" "${PROJECT_ROOT}/android/src/main/java/com/timesafari/dailynotification/ReactivationManager.kt" 2>/dev/null; then
+        ok "Timeout protection is implemented"
+        timeout_protection_found=true
+    else
+        error "Timeout protection not found"
     fi
     
-    # ============================================
-    # TEST 4: Invalid Data Handling
-    # ============================================
-    if should_run_test "4" SELECTED_TESTS; then
-    print_header "TEST 4: Invalid Data Handling"
-    echo "Purpose: Verify invalid data doesn't crash recovery."
-    echo ""
-    echo "This test injects invalid data (empty IDs, null nextRunAt) and"
-    echo "verifies that recovery handles it gracefully without crashing."
-    echo ""
-    wait_for_user
+    # Capture evidence
+    capture_logcat "test3_timeout_check" "DNP-REACTIVATION" 50
     
-    print_step "1" "Injecting invalid test data via plugin API..."
+    # Final verdict
+    if [ "${timeout_found}" = "true" ] && [ "${timeout_protection_found}" = "true" ]; then
+        verdict_pass "test3_recovery_timeout" "Timeout mechanism verified in code (2 seconds, withTimeout protection)"
+    else
+        verdict_fail "test3_recovery_timeout" "Timeout mechanism not properly implemented (timeout found: ${timeout_found}, protection found: ${timeout_protection_found})"
+    fi
+    
+    evidence_block "test3_recovery_timeout"
+    
+    if [ "${MODE}" != "ci" ]; then
+      pause
+    fi
+  fi  # End of "if should_run_test 3" block
+  
+  # ============================================
+  # TEST 4: Invalid Data Handling
+  # ============================================
+  if should_run_test "4" SELECTED_TESTS; then
+    section "TEST 4: Invalid Data Handling"
+    
+    info "Purpose: Verify invalid data doesn't crash recovery"
+    info ""
+    info "Expected time: 5-8 minutes"
+    info "Automatable: Partial (requires debuggable app or manual injection)"
+    info "Note: This test injects invalid data (empty IDs, null nextRunAt) and"
+    info "      verifies that recovery handles it gracefully without crashing"
+    echo ""
+    
+    if [ "${MODE}" != "ci" ]; then
+      pause
+    fi
+    
+    # Capture initial state
+    capture_alarms "test4_initial"
+    capture_logcat "test4_initial" "DNP" 50
+    
+    substep "Step 1: Inject invalid test data"
     
     # Clear logs before test
-    $ADB_BIN logcat -c > /dev/null 2>&1
-    
-    # Inject invalid data using plugin method
-    INJECT_RESULT=$($ADB_BIN shell "am start -a android.intent.action.VIEW -d 'capacitor://localhost/inject-invalid-test-data' ${APP_ID}/.MainActivity" 2>&1)
-    
-    # Better approach: Use Capacitor bridge via JavaScript
-    # We'll use a test HTML page that calls the plugin method
-    print_info "Using plugin API to inject invalid data..."
-    
-    # Create temporary test script
-    TEST_SCRIPT=$(mktemp)
-    cat > "${TEST_SCRIPT}" << 'EOF'
-// Inject invalid test data
-(async () => {
-    try {
-        const result = await window.DailyNotification.injectInvalidTestData({
-            injectEmptyScheduleId: true,
-            injectNullNextRunAt: true,
-            injectEmptyNotificationId: true
-        });
-        console.log('TEST4: Invalid data injected:', result);
-        document.body.innerHTML = '<h1>TEST 4: Invalid Data Injected</h1><pre>' + JSON.stringify(result, null, 2) + '</pre>';
-    } catch (error) {
-        console.error('TEST4: Failed to inject invalid data:', error);
-        document.body.innerHTML = '<h1>TEST 4: Error</h1><pre>' + error.message + '</pre>';
-    }
-})();
-EOF
-    
-    # Copy test script to device (if we had a way to execute it)
-    # For now, we'll use the plugin method directly via ADB shell and JavaScript bridge
-    print_info "Injecting invalid data via Capacitor bridge..."
-    
-    # Alternative: Use adb shell to execute JavaScript in the app
-    # This requires the app to be running and have a way to execute JS
-    # For now, let's use a simpler approach: check if debuggable and use direct DB access
-    # OR use the plugin method if the app is running
+    clear_logs
     
     # Check if app is debuggable (look for DEBUGGABLE flag)
-    IS_DEBUGGABLE=false
+    local is_debuggable=false
     if $ADB_BIN shell dumpsys package "${APP_ID}" | grep -qi "DEBUGGABLE"; then
-        IS_DEBUGGABLE=true
+        is_debuggable=true
     fi
     
-    if [ "${IS_DEBUGGABLE}" = "true" ]; then
-        print_success "App is debuggable - can inject data via plugin or database"
+    if [ "${is_debuggable}" = "true" ]; then
+        ok "App is debuggable - can inject data via database"
         
-        print_step "2" "Injecting invalid data via direct database access..."
+        substep "Step 2: Inject invalid data via direct database access"
         
         # Launch app first to ensure database is initialized
-        print_info "Launching app to initialize database..."
+        info "Launching app to initialize database..."
         $ADB_BIN shell am start -n "${APP_ID}/.MainActivity" > /dev/null 2>&1
         sleep 2
         
         # Stop app before database injection (prevents locking issues)
-        print_info "Stopping app before database injection..."
+        info "Stopping app before database injection..."
         $ADB_BIN shell am force-stop "${APP_ID}"
         sleep 1
         
         # Inject invalid data via direct database access
-        print_info "Injecting invalid test data into database..."
+        info "Injecting invalid test data into database..."
         
         # Calculate next run time (24 hours from now in milliseconds)
-        NEXT_RUN=$(($(date +%s) * 1000 + 86400000))
-        PAST_TIME=$(($(date +%s) * 1000 - 3600000))
-        NOW_TIME=$(($(date +%s) * 1000))
+        local next_run past_time now_time
+        next_run=$(($(date +%s) * 1000 + 86400000))
+        past_time=$(($(date +%s) * 1000 - 3600000))
+        now_time=$(($(date +%s) * 1000))
         
         # Inject schedule with empty ID
-        print_info "  - Injecting schedule with empty ID..."
-        $ADB_BIN shell "run-as ${APP_ID} sqlite3 databases/daily_notification_plugin.db \"INSERT OR REPLACE INTO schedules (id, kind, cron, clockTime, enabled, nextRunAt, jitterMs, backoffPolicy) VALUES ('', 'notify', '0 9 * * *', '09:00', 1, ${NEXT_RUN}, 0, 'exp');\"" 2>&1
+        info "  - Injecting schedule with empty ID..."
+        $ADB_BIN shell "run-as ${APP_ID} sqlite3 databases/daily_notification_plugin.db \"INSERT OR REPLACE INTO schedules (id, kind, cron, clockTime, enabled, nextRunAt, jitterMs, backoffPolicy) VALUES ('', 'notify', '0 9 * * *', '09:00', 1, ${next_run}, 0, 'exp');\"" 2>&1 || true
         
         # Inject schedule with null nextRunAt
-        print_info "  - Injecting schedule with null nextRunAt..."
-        $ADB_BIN shell "run-as ${APP_ID} sqlite3 databases/daily_notification_plugin.db \"INSERT OR REPLACE INTO schedules (id, kind, cron, clockTime, enabled, nextRunAt, jitterMs, backoffPolicy) VALUES ('test_null_nextrunat', 'notify', '0 9 * * *', '09:00', 1, NULL, 0, 'exp');\"" 2>&1
-        
-        # Inject notification with empty ID (may fail due to NOT NULL constraint, but we try)
-        print_info "  - Injecting notification with empty ID..."
-        $ADB_BIN shell "run-as ${APP_ID} sqlite3 databases/daily_notification_plugin.db \"INSERT OR REPLACE INTO notification_content (id, title, body, scheduled_time, priority, vibration_enabled, sound_enabled, delivery_status, delivery_attempts, last_delivery_attempt, user_interaction_count, last_user_interaction, ttl_seconds, created_at, updated_at) VALUES ('', 'Test Invalid Notification', 'This has an empty ID', ${PAST_TIME}, 0, 1, 1, 'pending', 0, 0, 0, 0, 86400, ${NOW_TIME}, ${NOW_TIME});\"" 2>&1
+        info "  - Injecting schedule with null nextRunAt..."
+        $ADB_BIN shell "run-as ${APP_ID} sqlite3 databases/daily_notification_plugin.db \"INSERT OR REPLACE INTO schedules (id, kind, cron, clockTime, enabled, nextRunAt, jitterMs, backoffPolicy) VALUES ('test_null_nextrunat', 'notify', '0 9 * * *', '09:00', 1, NULL, 0, 'exp');\"" 2>&1 || true
         
         # Checkpoint WAL file to ensure changes are visible
-        print_info "  - Checkpointing WAL file..."
-        $ADB_BIN shell "run-as ${APP_ID} sqlite3 databases/daily_notification_plugin.db \"PRAGMA wal_checkpoint(FULL);\"" 2>&1
+        info "  - Checkpointing WAL file..."
+        $ADB_BIN shell "run-as ${APP_ID} sqlite3 databases/daily_notification_plugin.db \"PRAGMA wal_checkpoint(FULL);\"" 2>&1 || true
         
         # Verify data was inserted
-        print_info "Verifying data injection..."
-        SCHEDULE_COUNT=$($ADB_BIN shell "run-as ${APP_ID} sqlite3 databases/daily_notification_plugin.db \"SELECT COUNT(*) FROM schedules;\"" 2>&1 | tr -d '\r\n')
-        NOTIFICATION_COUNT=$($ADB_BIN shell "run-as ${APP_ID} sqlite3 databases/daily_notification_plugin.db \"SELECT COUNT(*) FROM notification_content;\"" 2>&1 | tr -d '\r\n')
+        info "Verifying data injection..."
+        local schedule_count
+        schedule_count="$($ADB_BIN shell "run-as ${APP_ID} sqlite3 databases/daily_notification_plugin.db \"SELECT COUNT(*) FROM schedules;\"" 2>&1 | tr -d '\r\n')"
         
-        print_info "  - Schedules in database: ${SCHEDULE_COUNT}"
-        print_info "  - Notifications in database: ${NOTIFICATION_COUNT}"
+        info "  - Schedules in database: ${schedule_count}"
         
-        if [ "${SCHEDULE_COUNT}" -gt "0" ] 2>/dev/null; then
-            print_success "✅ Invalid test data injected successfully"
-            
-            # Show what was inserted
-            print_info "Inserted schedules:"
-            $ADB_BIN shell "run-as ${APP_ID} sqlite3 databases/daily_notification_plugin.db \"SELECT id, kind, enabled, nextRunAt FROM schedules;\"" 2>&1 | while read line; do
-                print_info "    $line"
-            done
+        if [ "${schedule_count}" -gt "0" ] 2>/dev/null; then
+            ok "Invalid test data injected successfully"
         else
-            print_warn "⚠️  No schedules found after injection - data may not have been inserted"
+            warn "No schedules found after injection - data may not have been inserted"
         fi
         
-        print_step "3" "Triggering recovery with invalid data..."
+        substep "Step 3: Trigger recovery with invalid data"
         $ADB_BIN shell am start -n "${APP_ID}/.MainActivity" > /dev/null 2>&1
         sleep 3  # Give recovery time to run
         
-        print_info "Waiting for recovery to complete..."
+        info "Waiting for recovery to complete..."
         sleep 2
         
-        print_step "4" "Checking recovery logs for invalid data handling..."
+        # Capture after recovery state
+        capture_alarms "test4_after_recovery"
+        capture_logcat "test4_after_recovery" "DNP-REACTIVATION|Skipping invalid" 100
+        capture_screenshot "test4_after_recovery"
+        
+        substep "Step 4: Check recovery logs for invalid data handling"
         
         # Check logs
-        RECOVERY_LOGS=$($ADB_BIN logcat -d | grep -E "DNP-REACTIVATION|Skipping invalid|TEST:" | tail -30)
+        local recovery_logs
+        recovery_logs="$($ADB_BIN logcat -d | grep -E "DNP-REACTIVATION|Skipping invalid|TEST:" | tail -30)"
         
         echo ""
-        print_info "Recovery logs:"
-        echo "${RECOVERY_LOGS}"
+        info "Recovery logs:"
+        echo "${recovery_logs}"
         echo ""
         
         # Check for invalid data handling
-        TEST4_PASSED=false
-        TEST4_FAILED=false
+        local test4_passed=false
+        local test4_failed=false
         
-        if echo "${RECOVERY_LOGS}" | grep -q "Skipping invalid"; then
-            print_success "✅ Invalid data was detected and skipped"
-            echo "${RECOVERY_LOGS}" | grep "Skipping invalid"
-            TEST4_PASSED=true
+        if echo "${recovery_logs}" | grep -q "Skipping invalid"; then
+            ok "Invalid data was detected and skipped"
+            echo "${recovery_logs}" | grep "Skipping invalid"
+            test4_passed=true
         else
-            print_warn "⚠️  No 'Skipping invalid' logs found"
-            print_info "This could mean:"
+            warn "No 'Skipping invalid' logs found"
+            info "This could mean:"
             echo "  - Invalid data wasn't injected (database constraints prevented it)"
             echo "  - Recovery didn't encounter invalid data"
             echo "  - Logs were cleared"
-            # Not a failure - constraints may have prevented injection
         fi
         
-        if echo "${RECOVERY_LOGS}" | grep -q "recovery complete\|Recovery completed"; then
-            print_success "✅ Recovery completed successfully"
-            if [ "${TEST4_PASSED}" = "false" ]; then
-                TEST4_PASSED=true  # Recovery completed = passed (even if no invalid data found)
+        if echo "${recovery_logs}" | grep -q "recovery complete\|Recovery completed"; then
+            ok "Recovery completed successfully"
+            if [ "${test4_passed}" = "false" ]; then
+                test4_passed=true  # Recovery completed = passed (even if no invalid data found)
             fi
         else
-            print_warn "⚠️  Recovery completion message not found in logs"
+            warn "Recovery completion message not found in logs"
         fi
         
-        if echo "${RECOVERY_LOGS}" | grep -qiE "crash|fatal|exception.*recovery|Failed.*recovery"; then
-            print_error "❌ TEST 4 FAILED: Recovery crashed or threw fatal exception"
-            TEST4_FAILED=true
+        if echo "${recovery_logs}" | grep -qiE "crash|fatal|exception.*recovery|Failed.*recovery"; then
+            error "TEST 4 FAILED: Recovery crashed or threw fatal exception"
+            test4_failed=true
         fi
         
         # Final verdict
-        if [ "${TEST4_FAILED}" = "true" ]; then
-            print_error ""
-            print_error "════════════════════════════════════════════════════════════"
-            print_error "TEST 4 FINAL RESULT: ❌ FAILED"
-            print_error "════════════════════════════════════════════════════════════"
-            print_error "Reason: Recovery crashed or threw fatal exception"
-            print_error "════════════════════════════════════════════════════════════"
-        elif [ "${TEST4_PASSED}" = "true" ]; then
-            print_success ""
-            print_success "════════════════════════════════════════════════════════════"
-            print_success "TEST 4 FINAL RESULT: ✅ PASSED"
-            print_success "════════════════════════════════════════════════════════════"
-            print_success "Recovery handled invalid data gracefully (or no invalid data found)"
-            print_success "════════════════════════════════════════════════════════════"
+        if [ "${test4_failed}" = "true" ]; then
+            verdict_fail "test4_invalid_data_handling" "Recovery crashed or threw fatal exception when handling invalid data"
+        elif [ "${test4_passed}" = "true" ]; then
+            verdict_pass "test4_invalid_data_handling" "Recovery handled invalid data gracefully (or no invalid data found)"
         else
-            print_warn ""
-            print_warn "════════════════════════════════════════════════════════════"
-            print_warn "TEST 4 FINAL RESULT: ⚠️  INCONCLUSIVE"
-            print_warn "════════════════════════════════════════════════════════════"
-            print_warn "Could not verify invalid data handling"
-            print_warn "════════════════════════════════════════════════════════════"
+            verdict_warn "test4_invalid_data_handling" "Could not verify invalid data handling"
         fi
         
     else
-        print_info "App is not debuggable - using plugin API method"
-        print_info "The plugin method 'injectInvalidTestData' can be called from JavaScript:"
-        echo ""
-        echo "  await window.DailyNotification.injectInvalidTestData({"
-        echo "    injectEmptyScheduleId: true,"
-        echo "    injectNullNextRunAt: true,"
-        echo "    injectEmptyNotificationId: true"
-        echo "  });"
-        echo ""
-        print_info "TEST 4: Code review confirms invalid data handling exists"
-        print_info "  - ReactivationManager.kt checks for empty IDs (line 401, 439)"
-        print_info "  - Errors are logged but don't crash recovery"
-        print_info "  - Plugin method 'injectInvalidTestData' available for testing"
+        info "App is not debuggable - cannot inject data via database"
+        info "TEST 4: Code review confirms invalid data handling exists"
+        info "  - ReactivationManager.kt checks for empty IDs"
+        info "  - Errors are logged but don't crash recovery"
+        verdict_warn "test4_invalid_data_handling" "App not debuggable - cannot inject invalid data for testing"
     fi
     
-    # Cleanup
-    rm -f "${TEST_SCRIPT}"
+    evidence_block "test4_invalid_data_handling"
     
-    wait_for_user
+    if [ "${MODE}" != "ci" ]; then
+      pause
     fi
-    
-    # ============================================
-    # Summary
-    # ============================================
-    print_header "Testing Complete"
-    
-    echo "Test Results Summary:"
-    echo ""
-    echo "TEST 1: Cold Start Missed Detection"
-    echo "  - ✅ PASSED if logs show 'missed=1'"
-    echo "  - ❌ FAILED if logs show 'missed=0' or no recovery logs"
-    echo ""
-    echo "TEST 2: Future Alarm Verification/Rescheduling"
-    echo "  - ✅ PASSED if logs show 'rescheduled=1' OR 'verified=1'"
-    echo "  - ℹ️  INFO if both are 0 (no future alarms to check)"
-    echo ""
-    echo "TEST 3: Recovery Timeout"
-    echo "  - Timeout mechanism verified in code"
-    echo ""
-    echo "TEST 4: Invalid Data Handling"
-    echo "  - Requires database access (debuggable app or root)"
-    echo ""
-    
-    print_info "All recovery logs:"
-    echo ""
-    $ADB_BIN logcat -d | grep "$REACTIVATION_TAG" | tail -20
-    echo ""
-    
-    print_success "Phase 1 testing script complete!"
-    echo ""
-    echo "Next steps:"
-    echo "  - Review logs above"
-    echo "  - Verify all tests passed"
-    echo "  - Check database if needed (debuggable app)"
-    echo "  - Update Doc B with test results"
+  fi  # End of "if should_run_test 4" block
+  
+  # ============================================
+  # Summary
+  # ============================================
+  section "Testing Complete"
+  
+  info "Test Results Summary:"
+  echo ""
+  echo "All test verdicts are shown above with evidence locations."
+  echo "Review evidence in: $(get_run_dir)"
+  echo ""
+  
+  info "All recovery logs:"
+  echo ""
+  $ADB_BIN logcat -d | grep "$REACTIVATION_TAG" | tail -20
+  echo ""
+  
+  ok "Phase 1 testing script complete!"
+  echo ""
+  echo "Next steps:"
+  echo "  - Review evidence in: $(get_run_dir)"
+  echo "  - Verify all test verdicts above"
+  echo "  - Check database if needed (debuggable app)"
+  echo "  - Update documentation with test results"
 }
 
 # Run main function
diff --git a/test-apps/android-test-app/test-phase2.sh b/test-apps/android-test-app/test-phase2.sh
index 8fce43c..db7c701 100755
--- a/test-apps/android-test-app/test-phase2.sh
+++ b/test-apps/android-test-app/test-phase2.sh
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 
 set -euo pipefail
+IFS=$'\n\t'
 
 # ========================================
 # Phase 2 Testing Script – Force Stop Recovery
@@ -10,6 +11,12 @@ set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "${SCRIPT_DIR}/alarm-test-lib.sh"
 
+# Initialize run directory (P1)
+ensure_run_dir || {
+  error "Failed to initialize run directory"
+  exit 1
+}
+
 # Phase 2 specific configuration
 # Log tags / patterns (matched to actual ReactivationManager logs)
 FORCE_STOP_SCENARIO_VALUE="FORCE_STOP"
@@ -17,6 +24,11 @@ COLD_START_SCENARIO_VALUE="COLD_START"
 NONE_SCENARIO_VALUE="NONE"
 BOOT_SCENARIO_VALUE="BOOT"
 
+# Strictness policy (P3.2)
+# soft: minor device quirks = warn (default, for development)
+# hard: any unexpected alarm loss / missed schedule = fail (for release gating)
+: "${STRICTNESS:=soft}"
+
 # Allow selecting specific tests on the command line (e.g. ./test-phase2.sh 2 3)
 SELECTED_TESTS=()
 
@@ -27,16 +39,31 @@ SELECTED_TESTS=()
 test1_force_stop_cleared_alarms() {
   section "TEST 1: Force Stop – Alarms Cleared"
 
-  echo "Purpose: Verify force stop detection and alarm rescheduling when alarms are cleared."
+  info "Purpose: Verify force stop detection and alarm rescheduling when alarms are cleared."
+  info "Expected time: 5-8 minutes"
+  info "Automatable: Partial (requires manual force-stop verification)"
+  echo ""
 
   pause
 
+  # Capture initial state
+  capture_alarms "phase2_test1_initial"
+  capture_logcat "phase2_test1_initial" "DNP" 50
+
   substep "Step 1: Launch app & check plugin status"
   launch_app
 
-  ui_prompt "In the app UI, verify plugin status:\n\n  ⚙️ Plugin Settings: ✅ Configured\n  🔌 Native Fetcher: ✅ Configured\n\nIf either shows ❌ or 'Not configured', click 'Configure Plugin', wait until both are ✅, then press Enter."
+  ui_prompt "1) In the app UI, verify plugin status:
 
-  ui_prompt "Now schedule at least one future notification (e.g., click 'Test Notification' to schedule for a few minutes in the future)."
+  ⚙️ Plugin Settings: ✅ Configured
+  🔌 Native Fetcher: ✅ Configured
+
+  If either shows ❌ or 'Not configured', click 'Configure Plugin', wait until both are ✅, then press Enter."
+
+  ui_prompt "2) Now schedule at least one future notification (e.g., click 'Test Notification' to schedule for a few minutes in the future)."
+
+  # Capture before force-stop state
+  capture_alarms "phase2_test1_before_force_stop"
 
   substep "Step 2: Verify alarms are scheduled"
   show_alarms
@@ -59,6 +86,9 @@ test1_force_stop_cleared_alarms() {
   substep "Step 3: Force stop app (should clear alarms on many devices)"
   force_stop_app
 
+  # Capture after force-stop state
+  capture_alarms "phase2_test1_after_force_stop"
+
   substep "Step 4: Check alarms after force stop"
   local after_count system_after
   after_count="$(get_plugin_alarm_count)"
@@ -68,8 +98,12 @@ test1_force_stop_cleared_alarms() {
   show_alarms
 
   if [[ "$after_count" -gt 0 ]]; then
-    warn "Plugin alarms still present after force stop. This device/OS may not clear alarms on force stop."
-    warn "TEST 1 will continue but may not fully validate FORCE_STOP scenario."
+    if [[ "$STRICTNESS" == "hard" ]]; then
+      error "Plugin alarms still present after force stop (strict mode: hard)"
+    else
+      warn "Plugin alarms still present after force stop. This device/OS may not clear alarms on force stop."
+      warn "TEST 1 will continue but may not fully validate FORCE_STOP scenario."
+    fi
   fi
 
   pause
@@ -77,7 +111,7 @@ test1_force_stop_cleared_alarms() {
   substep "Step 4.5: Clear boot flag (prevent false BOOT detection)"
   # Clear boot flag to ensure force stop detection works correctly
   # Boot flag might be set from previous runs or emulator quirks
-  adb shell "run-as ${APP_ID} rm -f shared_prefs/dailynotification_recovery.xml 2>/dev/null || true"
+  $ADB_BIN shell "run-as ${APP_ID} rm -f shared_prefs/dailynotification_recovery.xml 2>/dev/null || true"
   info "Boot flag cleared (if it existed)"
 
   substep "Step 5: Launch app (triggers recovery) and capture logs"
@@ -85,6 +119,11 @@ test1_force_stop_cleared_alarms() {
   launch_app
   sleep 5  # give recovery a moment to run
 
+  # Capture after recovery state
+  capture_alarms "phase2_test1_after_recovery"
+  capture_logcat "phase2_test1_after_recovery" "DNP-REACTIVATION" 250
+  capture_screenshot "phase2_test1_after_recovery"
+
   info "Collecting recovery logs..."
   local logs
   logs="$(get_recovery_logs)"
@@ -104,24 +143,64 @@ test1_force_stop_cleared_alarms() {
   echo "  errors     = ${errors}"
   echo
 
+  # Determine verdict based on STRICTNESS policy
+  local test1_passed=false
+  local test1_message=""
+
   if [[ "$errors" -gt 0 ]]; then
     error "Recovery reported errors>0 (errors=$errors)"
+    if [[ "$STRICTNESS" == "hard" ]]; then
+      test1_message="Recovery reported errors (errors=$errors)"
+    else
+      test1_message="Recovery reported errors but continuing (errors=$errors, strictness=soft)"
+    fi
   fi
 
   if [[ "$scenario" == "$FORCE_STOP_SCENARIO_VALUE" && "$rescheduled" -gt 0 ]]; then
     ok "TEST 1 PASSED: Force stop detected and alarms rescheduled (scenario=$scenario, rescheduled=$rescheduled)."
+    test1_passed=true
+    test1_message="Force stop detected and alarms rescheduled (scenario=$scenario, rescheduled=$rescheduled)"
   elif [[ "$scenario" == "$FORCE_STOP_SCENARIO_VALUE" && "$rescheduled" -eq 0 ]]; then
-    warn "TEST 1: scenario=FORCE_STOP but rescheduled=0. Check implementation or logs."
+    if [[ "$STRICTNESS" == "hard" ]]; then
+      test1_message="scenario=FORCE_STOP but rescheduled=0 (strict mode: hard)"
+    else
+      warn "TEST 1: scenario=FORCE_STOP but rescheduled=0. Check implementation or logs."
+      test1_message="scenario=FORCE_STOP but rescheduled=0 (strictness=soft)"
+    fi
   elif [[ "$after_count" -gt 0 ]]; then
     info "TEST 1: Device/emulator kept alarms after force stop; FORCE_STOP scenario may not trigger here."
     if [[ "$rescheduled" -gt 0 ]]; then
       info "Recovery still worked (rescheduled=$rescheduled), but scenario was ${scenario:-COLD_START} instead of FORCE_STOP"
+      test1_passed=true
+      test1_message="Recovery worked but FORCE_STOP scenario not detected (device kept alarms, rescheduled=$rescheduled, scenario=${scenario:-COLD_START})"
+    else
+      if [[ "$STRICTNESS" == "hard" ]]; then
+        test1_message="Device kept alarms but recovery didn't reschedule (strict mode: hard)"
+      else
+        test1_message="Device kept alarms, FORCE_STOP scenario may not trigger (strictness=soft)"
+      fi
     fi
   else
-    warn "TEST 1: Expected FORCE_STOP scenario not clearly detected. Review logs and scenario detection logic."
-    info "Scenario detected: ${scenario:-<none>}, rescheduled=$rescheduled"
+    if [[ "$STRICTNESS" == "hard" ]]; then
+      test1_message="Expected FORCE_STOP scenario not detected (strict mode: hard, scenario=${scenario:-<none>}, rescheduled=$rescheduled)"
+    else
+      warn "TEST 1: Expected FORCE_STOP scenario not clearly detected. Review logs and scenario detection logic."
+      info "Scenario detected: ${scenario:-<none>}, rescheduled=$rescheduled"
+      test1_message="FORCE_STOP scenario not clearly detected (scenario=${scenario:-<none>}, rescheduled=$rescheduled, strictness=soft)"
+    fi
   fi
 
+  # Emit verdict
+  if [[ "$test1_passed" == "true" ]]; then
+    verdict_pass "phase2_test1_force_stop_cleared" "$test1_message"
+  elif [[ "$STRICTNESS" == "hard" ]]; then
+    verdict_fail "phase2_test1_force_stop_cleared" "$test1_message"
+  else
+    verdict_warn "phase2_test1_force_stop_cleared" "$test1_message"
+  fi
+
+  evidence_block "phase2_test1_force_stop_cleared"
+
   substep "Step 6: Verify alarms are rescheduled in AlarmManager"
   show_alarms
 }
@@ -133,13 +212,25 @@ test1_force_stop_cleared_alarms() {
 test2_force_stop_intact_alarms() {
   section "TEST 2: Force Stop / Process Stop – Alarms Intact"
 
-  echo "Purpose: Verify that heavy FORCE_STOP recovery does not run when alarms are still present."
+  info "Purpose: Verify that heavy FORCE_STOP recovery does not run when alarms are still present."
+  info "Expected time: 4-6 minutes"
+  info "Automatable: Partial (requires manual verification)"
+  echo ""
 
   pause
 
+  # Capture initial state
+  capture_alarms "phase2_test2_initial"
+  capture_logcat "phase2_test2_initial" "DNP" 50
+
   substep "Step 1: Launch app & schedule notifications"
   launch_app
-  ui_prompt "In the app UI, ensure plugin is configured and schedule at least one future notification.\n\nPress Enter when done."
+  ui_prompt "1) In the app UI, ensure plugin is configured and schedule at least one future notification.
+
+  Press Enter when done."
+
+  # Capture before soft stop state
+  capture_alarms "phase2_test2_before_soft_stop"
 
   substep "Step 2: Verify alarms are scheduled"
   show_alarms
@@ -165,6 +256,9 @@ test2_force_stop_intact_alarms() {
   sleep 2
   ok "Kill signal sent (soft stop)"
 
+  # Capture after soft stop state
+  capture_alarms "phase2_test2_after_soft_stop"
+
   substep "Step 4: Verify alarms are still scheduled"
   local after system_after
   after="$(get_plugin_alarm_count)"
@@ -174,7 +268,11 @@ test2_force_stop_intact_alarms() {
   show_alarms
 
   if [[ "$after" -eq 0 ]]; then
-    warn "Alarms appear cleared after soft stop; this environment may not distinguish TEST 2 well."
+    if [[ "$STRICTNESS" == "hard" ]]; then
+      error "Alarms cleared after soft stop (strict mode: hard)"
+    else
+      warn "Alarms appear cleared after soft stop; this environment may not distinguish TEST 2 well."
+    fi
   fi
 
   pause
@@ -184,6 +282,11 @@ test2_force_stop_intact_alarms() {
   launch_app
   sleep 5
 
+  # Capture after recovery state
+  capture_alarms "phase2_test2_after_recovery"
+  capture_logcat "phase2_test2_after_recovery" "DNP-REACTIVATION" 250
+  capture_screenshot "phase2_test2_after_recovery"
+
   info "Collecting recovery logs..."
   local logs
   logs="$(get_recovery_logs)"
@@ -205,16 +308,49 @@ test2_force_stop_intact_alarms() {
   echo "  errors     = ${errors}"
   echo
 
+  # Determine verdict based on STRICTNESS policy
+  local test2_passed=false
+  local test2_message=""
+
   if [[ "$errors" -gt 0 ]]; then
     error "Recovery reported errors>0 (errors=$errors)"
+    if [[ "$STRICTNESS" == "hard" ]]; then
+      test2_message="Recovery reported errors (errors=$errors)"
+    else
+      test2_message="Recovery reported errors but continuing (errors=$errors, strictness=soft)"
+    fi
   fi
 
   if [[ "$after" -gt 0 && "$rescheduled" -eq 0 && "$scenario" != "$FORCE_STOP_SCENARIO_VALUE" ]]; then
     ok "TEST 2 PASSED: Alarms remained intact, and FORCE_STOP scenario did not run (scenario=$scenario, rescheduled=0)."
+    test2_passed=true
+    test2_message="Alarms remained intact, FORCE_STOP scenario did not run (scenario=$scenario, rescheduled=0)"
   else
-    warn "TEST 2: Verify that FORCE_STOP recovery didn't misfire when alarms were intact."
-    info "Scenario=${scenario:-<none>}, rescheduled=$rescheduled, after_count=$after"
+    if [[ "$STRICTNESS" == "hard" ]]; then
+      if [[ "$after" -eq 0 ]]; then
+        test2_message="Alarms were cleared but should have remained (strict mode: hard)"
+      elif [[ "$rescheduled" -gt 0 ]]; then
+        test2_message="FORCE_STOP recovery ran when alarms were intact (strict mode: hard, scenario=$scenario, rescheduled=$rescheduled)"
+      else
+        test2_message="Unexpected state (strict mode: hard, scenario=$scenario, rescheduled=$rescheduled, after=$after)"
+      fi
+    else
+      warn "TEST 2: Verify that FORCE_STOP recovery didn't misfire when alarms were intact."
+      info "Scenario=${scenario:-<none>}, rescheduled=$rescheduled, after_count=$after"
+      test2_message="FORCE_STOP recovery may have misfired (scenario=$scenario, rescheduled=$rescheduled, after=$after, strictness=soft)"
+    fi
   fi
+
+  # Emit verdict
+  if [[ "$test2_passed" == "true" ]]; then
+    verdict_pass "phase2_test2_force_stop_intact" "$test2_message"
+  elif [[ "$STRICTNESS" == "hard" ]]; then
+    verdict_fail "phase2_test2_force_stop_intact" "$test2_message"
+  else
+    verdict_warn "phase2_test2_force_stop_intact" "$test2_message"
+  fi
+
+  evidence_block "phase2_test2_force_stop_intact"
 }
 
 # ------------------------------------------------------------------------------
@@ -224,10 +360,16 @@ test2_force_stop_intact_alarms() {
 test3_first_launch_no_schedules() {
   section "TEST 3: First Launch / No Schedules Safeguard"
 
-  echo "Purpose: Ensure force-stop recovery is NOT triggered when DB is empty or plugin isn't configured."
+  info "Purpose: Ensure force-stop recovery is NOT triggered when DB is empty or plugin isn't configured."
+  info "Expected time: 3-5 minutes"
+  info "Automatable: Yes"
+  echo ""
 
   pause
 
+  # Capture initial state (before uninstall)
+  capture_alarms "phase2_test3_initial"
+
   substep "Step 1: Uninstall app to clear DB/state"
   set +e
   $ADB_BIN uninstall "$APP_ID" >/dev/null 2>&1
@@ -243,7 +385,7 @@ test3_first_launch_no_schedules() {
   fi
 
   info "Clearing logcat..."
-  $ADB_BIN logcat -c
+  clear_logs
   ok "Logs cleared"
 
   pause
@@ -252,6 +394,11 @@ test3_first_launch_no_schedules() {
   launch_app
   sleep 5
 
+  # Capture after first launch state
+  capture_alarms "phase2_test3_after_first_launch"
+  capture_logcat "phase2_test3_after_first_launch" "DNP-REACTIVATION" 250
+  capture_screenshot "phase2_test3_after_first_launch"
+
   substep "Step 4: Collect logs and ensure no force-stop recovery ran"
   local logs
   logs="$(get_recovery_logs)"
@@ -267,15 +414,45 @@ test3_first_launch_no_schedules() {
   echo "  rescheduled= ${rescheduled}"
   echo
 
+  # Determine verdict based on STRICTNESS policy
+  local test3_passed=false
+  local test3_message=""
+
   if [[ -z "$logs" ]]; then
     ok "TEST 3 PASSED: No force-stop recovery logs on first launch."
+    test3_passed=true
+    test3_message="No force-stop recovery logs on first launch (expected behavior)"
   elif [[ "$scenario" == "$NONE_SCENARIO_VALUE" && "$rescheduled" -eq 0 ]]; then
     ok "TEST 3 PASSED: NONE scenario logged with rescheduled=0 on first launch."
+    test3_passed=true
+    test3_message="NONE scenario logged with rescheduled=0 on first launch (expected behavior)"
   elif [[ "$rescheduled" -gt 0 ]]; then
-    warn "TEST 3: rescheduled>0 on first launch / empty DB. Check that force-stop recovery isn't misfiring."
+    if [[ "$STRICTNESS" == "hard" ]]; then
+      test3_message="rescheduled>0 on first launch / empty DB - force-stop recovery misfired (strict mode: hard, rescheduled=$rescheduled)"
+    else
+      warn "TEST 3: rescheduled>0 on first launch / empty DB. Check that force-stop recovery isn't misfiring."
+      test3_message="rescheduled>0 on first launch (rescheduled=$rescheduled, strictness=soft)"
+    fi
   else
-    info "TEST 3: Logs present but no rescheduling; review scenario handling to ensure it's explicit about NONE / FIRST_LAUNCH."
+    if [[ "$STRICTNESS" == "hard" ]]; then
+      test3_message="Logs present but scenario unclear (strict mode: hard, scenario=${scenario:-<none>}, rescheduled=$rescheduled)"
+    else
+      info "TEST 3: Logs present but no rescheduling; review scenario handling to ensure it's explicit about NONE / FIRST_LAUNCH."
+      test3_passed=true  # Not a failure, just needs review
+      test3_message="Logs present but no rescheduling (scenario=${scenario:-<none>}, rescheduled=$rescheduled, strictness=soft)"
+    fi
   fi
+
+  # Emit verdict
+  if [[ "$test3_passed" == "true" ]]; then
+    verdict_pass "phase2_test3_first_launch_no_schedules" "$test3_message"
+  elif [[ "$STRICTNESS" == "hard" ]]; then
+    verdict_fail "phase2_test3_first_launch_no_schedules" "$test3_message"
+  else
+    verdict_warn "phase2_test3_first_launch_no_schedules" "$test3_message"
+  fi
+
+  evidence_block "phase2_test3_first_launch_no_schedules"
 }
 
 # ------------------------------------------------------------------------------
@@ -285,26 +462,34 @@ test3_first_launch_no_schedules() {
 main() {
   # Allow selecting specific tests: e.g. `./test-phase2.sh 1 3`
   if [[ "$#" -gt 0 && ( "$1" == "-h" || "$1" == "--help" ) ]]; then
-    echo "Usage: $0 [TEST_IDS...]"
+    echo "Usage: $0 [TEST_IDS...] [STRICTNESS=soft|hard]"
     echo
     echo "If no TEST_IDS are given, all tests (1, 2, 3) will run."
+    echo
+    echo "STRICTNESS policy (P3.2):"
+    echo "  soft (default): minor device quirks = warn"
+    echo "  hard: any unexpected alarm loss / missed schedule = fail"
+    echo
     echo "Examples:"
-    echo "  $0          # run all tests"
-    echo "  $0 1        # run only TEST 1"
-    echo "  $0 2 3      # run only TEST 2 and TEST 3"
+    echo "  $0                    # run all tests (soft mode)"
+    echo "  $0 1                  # run only TEST 1 (soft mode)"
+    echo "  $0 2 3                # run only TEST 2 and TEST 3 (soft mode)"
+    echo "  STRICTNESS=hard $0    # run all tests (hard mode, release gating)"
     return 0
   fi
 
   SELECTED_TESTS=("$@")
 
-  echo
-  echo "========================================"
-  echo "Phase 2 Testing Script – Force Stop Recovery"
-  echo "========================================"
-  echo
-  echo "This script will guide you through Phase 2 tests."
-  echo "You'll be prompted when UI interaction is needed."
-  echo
+  section "Phase 2 Testing Script – Force Stop Recovery"
+  
+  info "Mode: Standard"
+  info "Strictness: ${STRICTNESS} (soft=warn on quirks, hard=fail on issues)"
+  info "Run ID: ${RUN_ID}"
+  info "Evidence directory: $(get_run_dir)"
+  echo ""
+  info "This script will guide you through Phase 2 tests."
+  info "You'll be prompted when UI interaction is needed."
+  echo ""
 
   pause
 
@@ -328,25 +513,23 @@ main() {
 
   section "Testing Complete"
 
-  echo "Test Results Summary (see logs above for details):"
-  echo
-  echo "TEST 1: Force Stop – Alarms Cleared"
-  echo "  - Check logs for scenario=$FORCE_STOP_SCENARIO_VALUE and rescheduled>0"
-  echo
-  echo "TEST 2: Force Stop / Process Stop – Alarms Intact"
-  echo "  - Verify FORCE_STOP scenario is not incorrectly triggered when alarms are still present"
-  echo
-  echo "TEST 3: First Launch / No Schedules"
-  echo "  - Confirm that no force-stop recovery runs, or that NONE/FIRST_LAUNCH scenario is logged with rescheduled=0"
-  echo
+  info "Test Results Summary:"
+  echo ""
+  echo "All test verdicts are shown above with evidence locations."
+  echo "Review evidence in: $(get_run_dir)"
+  echo ""
+  echo "Strictness mode: ${STRICTNESS}"
+  echo "  - soft: Minor device quirks treated as warnings"
+  echo "  - hard: Any unexpected behavior treated as failures"
+  echo ""
 
   ok "Phase 2 testing script complete!"
-  echo
+  echo ""
   echo "Next steps:"
-  echo "  - Review logs above"
-  echo "  - Capture snippets into PHASE2-EMULATOR-TESTING.md"
-  echo "  - Update PHASE2-VERIFICATION.md and unified directive status matrix"
-  echo
+  echo "  - Review evidence in: $(get_run_dir)"
+  echo "  - Verify all test verdicts above"
+  echo "  - Update documentation with test results"
+  echo ""
 }
 
 main "$@"
diff --git a/test-apps/android-test-app/test-phase3.sh b/test-apps/android-test-app/test-phase3.sh
index 14a9f84..281cab4 100755
--- a/test-apps/android-test-app/test-phase3.sh
+++ b/test-apps/android-test-app/test-phase3.sh
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 
 set -euo pipefail
+IFS=$'\n\t'
 
 # ========================================
 # Phase 3 Testing Script – Boot Recovery
@@ -10,11 +11,22 @@ set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "${SCRIPT_DIR}/alarm-test-lib.sh"
 
+# Initialize run directory (P1)
+ensure_run_dir || {
+  error "Failed to initialize run directory"
+  exit 1
+}
+
 # Phase 3 specific configuration
 # Log tags / patterns (matched to actual ReactivationManager logs)
 BOOT_SCENARIO_VALUE="BOOT"
 NONE_SCENARIO_VALUE="NONE"
 
+# Release gating config (P4.1)
+# 0 = advisory mode (default): failures become warnings, continue
+# 1 = release-blocking mode: failures exit with nonzero
+: "${RELEASE_GATE_PHASE3:=0}"
+
 # Allow selecting specific tests on the command line (e.g. ./test-phase3.sh 1 3)
 SELECTED_TESTS=()
 
@@ -39,16 +51,32 @@ extract_scenario_from_logs() {
 test1_boot_future_alarms() {
   section "TEST 1: Boot with Future Alarms"
 
-  echo "Purpose: Verify alarms are recreated on boot when schedules have future run times."
+  info "Purpose: Verify alarms are recreated on boot when schedules have future run times."
+  info "Expected time: 2-3 minutes (includes 30-60s reboot)"
+  info "Automatable: Partial (requires manual reboot confirmation)"
+  info "If you see: 'Boot recovery not detected' → Check boot receiver registration and BOOT_COMPLETED permission"
+  echo ""
 
   pause
 
+  # Capture initial state
+  capture_alarms "phase3_test1_initial"
+  capture_logcat "phase3_test1_initial" "DNP" 50
+
   substep "Step 1: Launch app & check plugin status"
   launch_app
 
-  ui_prompt "In the app UI, verify plugin status:\n\n  ⚙️ Plugin Settings: ✅ Configured\n  🔌 Native Fetcher: ✅ Configured\n\nIf either shows ❌ or 'Not configured', click 'Configure Plugin', wait until both are ✅, then press Enter."
+  ui_prompt "1) In the app UI, verify plugin status:
 
-  ui_prompt "Now schedule at least one future notification (e.g., click 'Test Notification' to schedule for a few minutes in the future)."
+  ⚙️ Plugin Settings: ✅ Configured
+  🔌 Native Fetcher: ✅ Configured
+
+  If either shows ❌ or 'Not configured', click 'Configure Plugin', wait until both are ✅, then press Enter."
+
+  ui_prompt "2) Now schedule at least one future notification (e.g., click 'Test Notification' to schedule for a few minutes in the future)."
+
+  # Capture before reboot state
+  capture_alarms "phase3_test1_before_reboot"
 
   substep "Step 2: Verify alarms are scheduled"
   show_alarms
@@ -76,6 +104,12 @@ test1_boot_future_alarms() {
   substep "Step 4: Collect boot recovery logs"
   info "Collecting recovery logs from boot..."
   sleep 2  # Give recovery a moment to complete
+
+  # Capture after reboot state
+  capture_alarms "phase3_test1_after_reboot"
+  capture_logcat "phase3_test1_after_reboot" "DNP-REACTIVATION" 250
+  capture_screenshot "phase3_test1_after_reboot"
+
   local logs
   logs="$(get_recovery_logs)"
   echo "$logs"
@@ -96,8 +130,29 @@ test1_boot_future_alarms() {
   echo "  errors     = ${errors}"
   echo
 
+  # Determine verdict
+  local test1_passed=false
+  local test1_message=""
+
   if [[ "$errors" -gt 0 ]]; then
     error "Recovery reported errors>0 (errors=$errors)"
+    test1_message="Recovery reported errors (errors=$errors)"
+  fi
+
+  if [[ "$scenario" == "$BOOT_SCENARIO_VALUE" && "$rescheduled" -gt 0 ]]; then
+    ok "TEST 1 PASSED: Boot recovery detected and alarms rescheduled (scenario=$scenario, rescheduled=$rescheduled)."
+    test1_passed=true
+    test1_message="Boot recovery detected and alarms rescheduled (scenario=$scenario, rescheduled=$rescheduled)"
+  elif echo "$logs" | grep -qi "Starting boot recovery\|boot recovery"; then
+    if [[ "$rescheduled" -gt 0 ]]; then
+      ok "TEST 1 PASSED: Boot recovery ran and alarms rescheduled (rescheduled=$rescheduled)."
+      test1_passed=true
+      test1_message="Boot recovery ran and alarms rescheduled (rescheduled=$rescheduled)"
+    else
+      test1_message="Boot recovery ran but rescheduled=0. Check implementation or logs."
+    fi
+  else
+    test1_message="Boot recovery not clearly detected. Review logs and boot receiver implementation (scenario=${scenario:-<none>}, rescheduled=$rescheduled)"
   fi
 
   substep "Step 5: Verify alarms were recreated"
@@ -108,18 +163,22 @@ test1_boot_future_alarms() {
   info "Plugin alarms after boot: $after_count (expected: 1)"
   info "System/other alarms: $system_after (for context)"
 
-  if [[ "$scenario" == "$BOOT_SCENARIO_VALUE" && "$rescheduled" -gt 0 ]]; then
-    ok "TEST 1 PASSED: Boot recovery detected and alarms rescheduled (scenario=$scenario, rescheduled=$rescheduled)."
-  elif echo "$logs" | grep -qi "Starting boot recovery\|boot recovery"; then
-    if [[ "$rescheduled" -gt 0 ]]; then
-      ok "TEST 1 PASSED: Boot recovery ran and alarms rescheduled (rescheduled=$rescheduled)."
-    else
-      warn "TEST 1: Boot recovery ran but rescheduled=0. Check implementation or logs."
-    fi
-  else
-    warn "TEST 1: Boot recovery not clearly detected. Review logs and boot receiver implementation."
-    info "Scenario detected: ${scenario:-<none>}, rescheduled=$rescheduled"
+  if [[ "$after_count" -eq 0 && "$test1_passed" == "true" ]]; then
+    warn "Alarms were not recreated despite recovery success. Check alarm scheduling logic."
+    test1_message="Boot recovery succeeded but alarms not recreated (rescheduled=$rescheduled, after_count=$after_count)"
+    test1_passed=false
+  elif [[ "$after_count" -gt 0 && "$test1_passed" == "true" ]]; then
+    ok "Alarms successfully recreated after boot (after_count=$after_count)"
   fi
+
+  # Emit verdict
+  if [[ "$test1_passed" == "true" ]]; then
+    verdict_pass "phase3_test1_boot_future_alarms" "$test1_message"
+  else
+    verdict_fail "phase3_test1_boot_future_alarms" "$test1_message"
+  fi
+
+  evidence_block "phase3_test1_boot_future_alarms"
 }
 
 # ------------------------------------------------------------------------------
@@ -129,22 +188,44 @@ test1_boot_future_alarms() {
 test2_boot_past_alarms() {
   section "TEST 2: Boot with Past Alarms"
 
-  echo "Purpose: Verify missed alarms are detected and next occurrence is scheduled on boot."
+  info "Purpose: Verify missed alarms are detected and next occurrence is scheduled on boot."
+  info "Expected time: 5-6 minutes (includes 3min wait + 30-60s reboot)"
+  info "Automatable: Partial (requires manual time advancement or wait)"
+  info "If you see: 'No missed alarms detected' → Verify alarm time actually passed before reboot"
+  info "Automation hint: Use 'adb shell date' to check current time, advance if needed"
+  echo ""
 
   pause
 
+  # Capture initial state
+  capture_alarms "phase3_test2_initial"
+  capture_logcat "phase3_test2_initial" "DNP" 50
+
   substep "Step 1: Launch app & ensure plugin configured"
   launch_app
 
-  ui_prompt "In the app UI, verify plugin status:\n\n  ⚙️ Plugin Settings: ✅ Configured\n  🔌 Native Fetcher: ✅ Configured\n\nIf needed, click 'Configure Plugin', then press Enter."
+  ui_prompt "1) In the app UI, verify plugin status:
 
-  ui_prompt "Click 'Test Notification' to schedule a notification for 2 minutes in the future.\n\nAfter scheduling, we'll wait for the alarm time to pass, then reboot."
+  ⚙️ Plugin Settings: ✅ Configured
+  🔌 Native Fetcher: ✅ Configured
+
+  If needed, click 'Configure Plugin', then press Enter."
+
+  ui_prompt "2) Click 'Test Notification' to schedule a notification for 2 minutes in the future.
+
+  After scheduling, we'll wait for the alarm time to pass, then reboot."
+
+  # Capture before wait state
+  capture_alarms "phase3_test2_before_wait"
 
   substep "Step 2: Wait for alarm time to pass"
   info "Waiting 3 minutes for scheduled alarm time to pass..."
   warn "You can manually advance system time if needed (requires root/emulator)"
   sleep 180  # Wait 3 minutes
 
+  # Capture after wait state
+  capture_alarms "phase3_test2_after_wait"
+
   substep "Step 3: Verify alarm time has passed"
   info "Alarm time should now be in the past"
   show_alarms
@@ -159,6 +240,12 @@ test2_boot_past_alarms() {
   substep "Step 5: Collect boot recovery logs"
   info "Collecting recovery logs from boot..."
   sleep 2
+
+  # Capture after reboot state
+  capture_alarms "phase3_test2_after_reboot"
+  capture_logcat "phase3_test2_after_reboot" "DNP-REACTIVATION" 250
+  capture_screenshot "phase3_test2_after_reboot"
+
   local logs
   logs="$(get_recovery_logs)"
   echo "$logs"
@@ -182,17 +269,33 @@ test2_boot_past_alarms() {
   echo "  errors     = ${errors}"
   echo
 
+  # Determine verdict
+  local test2_passed=false
+  local test2_message=""
+
   if [[ "$errors" -gt 0 ]]; then
     error "Recovery reported errors>0 (errors=$errors)"
+    test2_message="Recovery reported errors (errors=$errors)"
   fi
 
   if [[ "$missed" -ge 1 && "$rescheduled" -ge 1 ]]; then
     ok "TEST 2 PASSED: Past alarms detected and next occurrence scheduled (missed=$missed, rescheduled=$rescheduled)."
+    test2_passed=true
+    test2_message="Past alarms detected and next occurrence scheduled (missed=$missed, rescheduled=$rescheduled)"
   elif [[ "$missed" -ge 1 ]]; then
-    warn "TEST 2: Past alarms detected (missed=$missed) but rescheduled=$rescheduled. Check reschedule logic."
+    test2_message="Past alarms detected (missed=$missed) but rescheduled=$rescheduled. Check reschedule logic."
   else
-    warn "TEST 2: No missed alarms detected. Verify alarm time actually passed before reboot."
+    test2_message="No missed alarms detected. Verify alarm time actually passed before reboot (missed=$missed, rescheduled=$rescheduled)"
   fi
+
+  # Emit verdict
+  if [[ "$test2_passed" == "true" ]]; then
+    verdict_pass "phase3_test2_boot_past_alarms" "$test2_message"
+  else
+    verdict_fail "phase3_test2_boot_past_alarms" "$test2_message"
+  fi
+
+  evidence_block "phase3_test2_boot_past_alarms"
 }
 
 # ------------------------------------------------------------------------------
@@ -202,10 +305,17 @@ test2_boot_past_alarms() {
 test3_boot_no_schedules() {
   section "TEST 3: Boot with No Schedules"
 
-  echo "Purpose: Verify boot recovery handles empty database gracefully."
+  info "Purpose: Verify boot recovery handles empty database gracefully."
+  info "Expected time: 2-3 minutes (includes 30-60s reboot)"
+  info "Automatable: Yes"
+  info "If you see: 'rescheduled>0 on first launch' → Check that boot recovery isn't misfiring"
+  echo ""
 
   pause
 
+  # Capture initial state (before uninstall)
+  capture_alarms "phase3_test3_initial"
+
   substep "Step 1: Uninstall app to clear DB/state"
   set +e
   $ADB_BIN uninstall "$APP_ID" >/dev/null 2>&1
@@ -221,7 +331,7 @@ test3_boot_no_schedules() {
   fi
 
   info "Clearing logcat..."
-  $ADB_BIN logcat -c
+  clear_logs
   ok "Logs cleared"
 
   pause
@@ -235,6 +345,12 @@ test3_boot_no_schedules() {
   substep "Step 4: Collect boot recovery logs"
   info "Collecting recovery logs from boot..."
   sleep 2
+
+  # Capture after reboot state
+  capture_alarms "phase3_test3_after_reboot"
+  capture_logcat "phase3_test3_after_reboot" "DNP-REACTIVATION" 250
+  capture_screenshot "phase3_test3_after_reboot"
+
   local logs
   logs="$(get_recovery_logs)"
   echo "$logs"
@@ -251,20 +367,37 @@ test3_boot_no_schedules() {
   echo "  missed    = ${missed}"
   echo
 
+  # Determine verdict
+  local test3_passed=false
+  local test3_message=""
+
   if [[ -z "$logs" ]]; then
     ok "TEST 3 PASSED: No recovery logs when there are no schedules (safe behavior)."
-    return
-  fi
-
-  if echo "$logs" | grep -qiE "No schedules found|No schedules present"; then
+    test3_passed=true
+    test3_message="No recovery logs when there are no schedules (safe behavior)"
+  elif echo "$logs" | grep -qiE "No schedules found|No schedules present"; then
     ok "TEST 3 PASSED: Explicit 'No schedules found' message logged with no rescheduling."
+    test3_passed=true
+    test3_message="Explicit 'No schedules found' message logged with no rescheduling"
   elif [[ "$scenario" == "$NONE_SCENARIO_VALUE" && "$rescheduled" -eq 0 ]]; then
     ok "TEST 3 PASSED: NONE scenario detected with no rescheduling."
+    test3_passed=true
+    test3_message="NONE scenario detected with no rescheduling (scenario=$scenario, rescheduled=$rescheduled)"
   elif [[ "$rescheduled" -gt 0 ]]; then
-    warn "TEST 3: rescheduled>0 on first launch / empty DB. Check that boot recovery isn't misfiring."
+    test3_message="rescheduled>0 on first launch / empty DB. Check that boot recovery isn't misfiring (rescheduled=$rescheduled)"
   else
-    info "TEST 3: Logs present but no rescheduling; review scenario handling to ensure it's explicit about NONE / NO_SCHEDULES."
+    test3_passed=true  # Not a failure, just needs review
+    test3_message="Logs present but no rescheduling; review scenario handling to ensure it's explicit about NONE / NO_SCHEDULES (scenario=${scenario:-<none>}, rescheduled=$rescheduled)"
   fi
+
+  # Emit verdict
+  if [[ "$test3_passed" == "true" ]]; then
+    verdict_pass "phase3_test3_boot_no_schedules" "$test3_message"
+  else
+    verdict_fail "phase3_test3_boot_no_schedules" "$test3_message"
+  fi
+
+  evidence_block "phase3_test3_boot_no_schedules"
 }
 
 # ------------------------------------------------------------------------------
@@ -274,16 +407,32 @@ test3_boot_no_schedules() {
 test4_silent_boot_recovery() {
   section "TEST 4: Silent Boot Recovery (App Never Opened)"
 
-  echo "Purpose: Verify boot recovery occurs even when the app is never opened after reboot."
+  info "Purpose: Verify boot recovery occurs even when the app is never opened after reboot."
+  info "Expected time: 2-3 minutes (includes 30-60s reboot)"
+  info "Automatable: Partial (requires manual verification that app was not opened)"
+  info "If you see: 'Boot recovery not detected' → Verify boot receiver is registered and has BOOT_COMPLETED permission"
+  echo ""
 
   pause
 
+  # Capture initial state
+  capture_alarms "phase3_test4_initial"
+  capture_logcat "phase3_test4_initial" "DNP" 50
+
   substep "Step 1: Launch app & ensure plugin configured"
   launch_app
 
-  ui_prompt "In the app UI, verify plugin status:\n\n  ⚙️ Plugin Settings: ✅ Configured\n  🔌 Native Fetcher: ✅ Configured\n\nIf needed, click 'Configure Plugin', then press Enter."
+  ui_prompt "1) In the app UI, verify plugin status:
 
-  ui_prompt "Click 'Test Notification' to schedule a notification for a few minutes in the future."
+  ⚙️ Plugin Settings: ✅ Configured
+  🔌 Native Fetcher: ✅ Configured
+
+  If needed, click 'Configure Plugin', then press Enter."
+
+  ui_prompt "2) Click 'Test Notification' to schedule a notification for a few minutes in the future."
+
+  # Capture before reboot state
+  capture_alarms "phase3_test4_before_reboot"
 
   substep "Step 2: Verify alarms are scheduled"
   show_alarms
@@ -312,6 +461,12 @@ test4_silent_boot_recovery() {
   substep "Step 4: Collect boot recovery logs (without opening app)"
   info "Collecting recovery logs from boot (app was NOT opened)..."
   sleep 2
+
+  # Capture after reboot state (without opening app)
+  capture_alarms "phase3_test4_after_reboot"
+  capture_logcat "phase3_test4_after_reboot" "DNP-REACTIVATION" 250
+  capture_screenshot "phase3_test4_after_reboot"
+
   local logs
   logs="$(get_recovery_logs)"
   echo "$logs"
@@ -340,15 +495,37 @@ test4_silent_boot_recovery() {
   info "Plugin alarms after boot (app never opened): $after_count (expected: 1)"
   info "System/other alarms: $system_after (for context)"
 
+  # Determine verdict
+  local test4_passed=false
+  local test4_message=""
+
+  if [[ "$errors" -gt 0 ]]; then
+    error "Recovery reported errors>0 (errors=$errors)"
+    test4_message="Recovery reported errors (errors=$errors)"
+  fi
+
   if [[ "$after_count" -gt 0 && "$rescheduled" -gt 0 ]]; then
     ok "TEST 4 PASSED: Boot recovery occurred silently and alarms were recreated (rescheduled=$rescheduled) without app launch."
+    test4_passed=true
+    test4_message="Boot recovery occurred silently and alarms were recreated (rescheduled=$rescheduled, after_count=$after_count) without app launch"
   elif [[ "$rescheduled" -gt 0 ]]; then
     ok "TEST 4 PASSED: Boot recovery occurred silently (rescheduled=$rescheduled), but alarm count check unclear."
+    test4_passed=true
+    test4_message="Boot recovery occurred silently (rescheduled=$rescheduled), but alarm count unclear (after_count=$after_count)"
   elif echo "$logs" | grep -qi "Starting boot recovery\|boot recovery"; then
-    warn "TEST 4: Boot recovery ran but alarms may not have been recreated. Check logs and implementation."
+    test4_message="Boot recovery ran but alarms may not have been recreated. Check logs and implementation (rescheduled=$rescheduled, after_count=$after_count)"
   else
-    warn "TEST 4: Boot recovery not detected. Verify boot receiver is registered and has BOOT_COMPLETED permission."
+    test4_message="Boot recovery not detected. Verify boot receiver is registered and has BOOT_COMPLETED permission (scenario=${scenario:-<none>}, rescheduled=$rescheduled)"
   fi
+
+  # Emit verdict
+  if [[ "$test4_passed" == "true" ]]; then
+    verdict_pass "phase3_test4_silent_boot_recovery" "$test4_message"
+  else
+    verdict_fail "phase3_test4_silent_boot_recovery" "$test4_message"
+  fi
+
+  evidence_block "phase3_test4_silent_boot_recovery"
 }
 
 # ------------------------------------------------------------------------------
@@ -356,32 +533,63 @@ test4_silent_boot_recovery() {
 # ------------------------------------------------------------------------------
 
 main() {
-  # Allow selecting specific tests: e.g. `./test-phase3.sh 1 3`
-  if [[ "$#" -gt 0 && ( "$1" == "-h" || "$1" == "--help" ) ]]; then
-    echo "Usage: $0 [TEST_IDS...]"
-    echo
-    echo "If no TEST_IDS are given, all tests (1, 2, 3, 4) will run."
-    echo "Examples:"
-    echo "  $0          # run all tests"
-    echo "  $0 1        # run only TEST 1"
-    echo "  $0 2 3      # run only TEST 2 and TEST 3"
-    echo "  $0 4        # run only TEST 4 (silent boot recovery)"
-    return 0
+  # Parse CLI args for --gate-phase3 flag
+  local gate_phase3=0
+  local test_args=()
+  while [[ $# -gt 0 ]]; do
+    case "$1" in
+      -h|--help)
+        echo "Usage: $0 [--gate-phase3] [TEST_IDS...]"
+        echo
+        echo "If no TEST_IDS are given, all tests (1, 2, 3, 4) will run."
+        echo
+        echo "Options:"
+        echo "  --gate-phase3    Enable release gating (failures exit with non-zero)"
+        echo "                   Equivalent to: RELEASE_GATE_PHASE3=1 $0"
+        echo
+        echo "Environment:"
+        echo "  RELEASE_GATE_PHASE3=0|1  Release gating mode (default: 0)"
+        echo "                           0 = advisory (warn and continue)"
+        echo "                           1 = release-blocking (fail and exit)"
+        echo
+        echo "Examples:"
+        echo "  $0                    # run all tests (advisory mode)"
+        echo "  $0 1                  # run only TEST 1 (advisory mode)"
+        echo "  $0 --gate-phase3     # run all tests (release-blocking mode)"
+        echo "  $0 --gate-phase3 2 3  # run TEST 2 and 3 (release-blocking mode)"
+        echo "  RELEASE_GATE_PHASE3=1 $0  # same as --gate-phase3"
+        return 0
+        ;;
+      --gate-phase3)
+        gate_phase3=1
+        shift
+        ;;
+      *)
+        test_args+=("$1")
+        shift
+        ;;
+    esac
+  done
+
+  # Set RELEASE_GATE_PHASE3 if flag was provided
+  if [[ "$gate_phase3" -eq 1 ]]; then
+    RELEASE_GATE_PHASE3=1
   fi
 
-  SELECTED_TESTS=("$@")
+  SELECTED_TESTS=("${test_args[@]}")
 
-  echo
-  echo "========================================"
-  echo "Phase 3 Testing Script – Boot Recovery"
-  echo "========================================"
-  echo
-  echo "This script will guide you through Phase 3 tests."
-  echo "You'll be prompted when UI interaction is needed."
-  echo
-  echo "⚠️  WARNING: This script will reboot the emulator multiple times."
-  echo "    Each reboot takes 30-60 seconds."
-  echo
+  section "Phase 3 Testing Script – Boot Recovery"
+
+  info "Mode: ${RELEASE_GATE_PHASE3:-0} (0=advisory, 1=release-blocking)"
+  info "Run ID: ${RUN_ID}"
+  info "Evidence directory: $(get_run_dir)"
+  echo ""
+  info "This script will guide you through Phase 3 tests."
+  info "You'll be prompted when UI interaction is needed."
+  echo ""
+  warn "⚠️  WARNING: This script will reboot the emulator multiple times."
+  info "    Each reboot takes 30-60 seconds."
+  echo ""
 
   pause
 
@@ -410,28 +618,23 @@ main() {
 
   section "Testing Complete"
 
-  echo "Test Results Summary (see logs above for details):"
-  echo
-  echo "TEST 1: Boot with Future Alarms"
-  echo "  - Check logs for scenario=$BOOT_SCENARIO_VALUE and rescheduled>0"
-  echo
-  echo "TEST 2: Boot with Past Alarms"
-  echo "  - Check that missed>=1 and rescheduled>=1"
-  echo
-  echo "TEST 3: Boot with No Schedules"
-  echo "  - Check that no recovery runs, or NONE scenario is logged with rescheduled=0"
-  echo
-  echo "TEST 4: Silent Boot Recovery"
-  echo "  - Check that boot recovery occurred and alarms were recreated without app launch"
-  echo
+  info "Test Results Summary:"
+  echo ""
+  echo "All test verdicts are shown above with evidence locations."
+  echo "Review evidence in: $(get_run_dir)"
+  echo ""
+  echo "Release gating mode: ${RELEASE_GATE_PHASE3:-0}"
+  echo "  - 0 (advisory): Failures become warnings, script continues"
+  echo "  - 1 (release-blocking): Failures cause script to exit with non-zero"
+  echo ""
 
   ok "Phase 3 testing script complete!"
-  echo
+  echo ""
   echo "Next steps:"
-  echo "  - Review logs above"
-  echo "  - Capture snippets into PHASE3-EMULATOR-TESTING.md"
-  echo "  - Update PHASE3-VERIFICATION.md and unified directive status matrix"
-  echo
+  echo "  - Review evidence in: $(get_run_dir)"
+  echo "  - Verify all test verdicts above"
+  echo "  - Update documentation with test results"
+  echo ""
 }
 
 main "$@"