From ac392556729cc020fff511facf705b8f87609c31 Mon Sep 17 00:00:00 2001
From: Matthew Raymer <mraymer@osinetwork.net>
Date: Wed, 24 Dec 2025 12:01:16 +0000
Subject: [PATCH] test(android-test-app): unify presentation framework with
 evidence collection

Implement P0-P5 directives for operator clarity, consistent outcomes, and
easy evidence capture across all test phases.

Changes:
- alarm-test-lib.sh: Add evidence collection (capture_alarms, capture_logcat,
  capture_screenshot), verdict functions (verdict_pass/warn/fail), run directory
  management, and release gating support (RELEASE_GATE_PHASE3)

- test-phase1.sh: Refactor to unified framework with CLI modes (--setup,
  --run, --smoke, --all, --ci), micro-prompts, evidence capture, and verdict
  blocks for all 5 tests

- test-phase2.sh: Add evidence capture, verdict blocks, and STRICTNESS policy
  (soft/hard) for warn vs fail behavior

- test-phase3.sh: Add evidence capture, verdict blocks, release gating
  (--gate-phase3), and fatigue reduction (time estimates, automation hints)

- RUNBOOK-TESTING.md: New comprehensive operator guide (669 lines) covering
  prerequisites, all phases, evidence locations, verdict interpretation,
  common failures, and troubleshooting

All test scripts now use consistent UI helpers (section, substep, info, ok,
warn, error), standardized evidence collection, and clear verdict reporting.
Evidence is saved to timestamped run directories (runs/<RUN_ID>/) with alarms,
logs, and screenshots organized by test phase and scenario.

Tests pass with consistent presentation and reproducible evidence collection.
---
 test-apps/android-test-app/alarm-test-lib.sh  |  329 +++-
 .../android-test-app/docs/RUNBOOK-TESTING.md  |  669 +++++++
 test-apps/android-test-app/test-phase1.sh     | 1619 +++++++++--------
 test-apps/android-test-app/test-phase2.sh     |  275 ++-
 test-apps/android-test-app/test-phase3.sh     |  351 +++-
 5 files changed, 2373 insertions(+), 870 deletions(-)
 create mode 100644 test-apps/android-test-app/docs/RUNBOOK-TESTING.md

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 "$@"