feat(tui,gui): add --headless mode for CI-safe operation

tui --headless and gui --headless bypass crossterm/eframe
respectively, printing section/panel summaries to stdout without
requiring a TTY or display server.  Both subcommands advance from
Grade E (untestable) to Grade D (Alpha) in the CRG scale.

Adds two Grade D readiness tests: readiness_d_tui_headless_runs and
readiness_d_gui_headless_runs, which exercise the full parse-and-render
path using a minimal AssaultReport fixture.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: hyperpolymath

src/main.rs

@@ -458,13 +458,21 @@ enum Commands {
         /// Assault report JSON file
         #[arg(value_name = "REPORT")]
         report: PathBuf,
+
+        /// Headless mode: print sections as plain text without requiring a TTY (CI-safe)
+        #[arg(long, default_value_t = false)]
+        headless: bool,
     },
 
     /// GUI review of a saved report
     Gui {
         /// Assault report JSON file
         #[arg(value_name = "REPORT")]
         report: PathBuf,
+
+        /// Headless mode: print panel summaries without requiring a display server (CI-safe)
+        #[arg(long, default_value_t = false)]
+        headless: bool,
     },
 
     /// Compare two assault reports (defaults to latest VerisimDB runs)
@@ -1662,16 +1670,24 @@ fn run_main() -> Result<()> {
             }
         }
 
-        Commands::Tui { report } => {
+        Commands::Tui { report, headless } => {
             let content = read_report_bounded(&report)?;
             let assault_report: AssaultReport = serde_json::from_str(&content)?;
-            ReportTui::run(&assault_report)?;
+            if headless {
+                ReportTui::run_headless(&assault_report)?;
+            } else {
+                ReportTui::run(&assault_report)?;
+            }
         }
 
-        Commands::Gui { report } => {
+        Commands::Gui { report, headless } => {
             let content = read_report_bounded(&report)?;
             let assault_report: AssaultReport = serde_json::from_str(&content)?;
-            report::ReportGui::run(assault_report)?;
+            if headless {
+                report::ReportGui::run_headless(assault_report)?;
+            } else {
+                report::ReportGui::run(assault_report)?;
+            }
         }
 
         Commands::Diff {

src/report/gui.rs

@@ -65,6 +65,96 @@ impl ReportGui {
         Ok(())
     }
 
+    /// Run without a display server: print a structured text summary of all panels.
+    ///
+    /// Safe to call in CI or headless environments with no Wayland/X11 display.
+    /// Promotes the gui subcommand from Grade E to Grade D.
+    pub fn run_headless(report: AssaultReport) -> Result<()> {
+        let assail = &report.assail_report;
+        let formatter = ReportFormatter::new();
+
+        println!("PANIC-ATTACK GUI REPORT (headless)");
+        println!();
+
+        println!("=== Summary ===");
+        println!("Language: {:?}", assail.language);
+        println!("Score: {:.1}/100", report.overall_assessment.robustness_score);
+        println!("Crashes: {}", report.total_crashes);
+        println!("Signatures: {}", report.total_signatures);
+        println!("Weak points: {}", assail.weak_points.len());
+        println!("Frameworks: {:?}", assail.frameworks);
+        println!();
+
+        println!("=== Assail ===");
+        println!("Program: {}", assail.program_path.display());
+        println!(
+            "Stats: lines={} unsafe={} panics={} unwraps={}",
+            assail.statistics.total_lines,
+            assail.statistics.unsafe_blocks,
+            assail.statistics.panic_sites,
+            assail.statistics.unwrap_calls
+        );
+        for wp in &assail.weak_points {
+            let loc = wp
+                .location
+                .as_deref()
+                .or(wp.file.as_deref())
+                .unwrap_or("<unknown>");
+            println!(
+                "  [{:?}] {:?} @ {} — {}",
+                wp.severity, wp.category, loc, wp.description
+            );
+        }
+        println!();
+
+        println!("=== File Risk ===");
+        for detail in formatter.file_risk_details(assail) {
+            println!("  {}", detail);
+        }
+        println!();
+
+        println!("=== Matrix ===");
+        println!(
+            "Dependency edges: {}  Taint rows: {}",
+            assail.dependency_graph.edges.len(),
+            assail.taint_matrix.rows.len()
+        );
+        for detail in formatter.taint_matrix_details(assail) {
+            println!("  {}", detail);
+        }
+        println!();
+
+        println!("=== Attacks ===");
+        for result in &report.attack_results {
+            let status = if result.skipped {
+                "skipped"
+            } else if result.success {
+                "passed"
+            } else {
+                "failed"
+            };
+            println!(
+                "  {:?}: {} crashes={} duration={:.2}s",
+                result.axis,
+                status,
+                result.crashes.len(),
+                result.duration.as_secs_f64()
+            );
+        }
+        println!();
+
+        println!("=== Assessment ===");
+        for issue in &report.overall_assessment.critical_issues {
+            println!("  CRITICAL: {}", issue);
+        }
+        for rec in &report.overall_assessment.recommendations {
+            println!("  REC: {}", rec);
+        }
+        println!();
+
+        Ok(())
+    }
+
     /// Attempt to load a JSON file as either an `AssaultReport`, `SystemImage`,
     /// or `TemporalDiff`. Detection is format-based: we try each in turn and
     /// keep the first successful parse.

src/report/tui.rs

@@ -18,6 +18,29 @@ use std::time::Duration;
 pub struct ReportTui;
 
 impl ReportTui {
+    /// Run without a TTY: build all sections and print them as plain text.
+    ///
+    /// Safe to call in CI, scripts, or any context without a real terminal.
+    /// Promotes the tui subcommand from Grade E to Grade D.
+    pub fn run_headless(report: &AssaultReport) -> Result<()> {
+        let formatter = ReportFormatter::new();
+        let sections = Self::build_sections(report, &formatter, true);
+
+        println!("PANIC-ATTACK REPORT REVIEW (headless)");
+        println!();
+
+        for section in &sections {
+            println!("=== {} ===", section.title);
+            println!("{}", section.summary);
+            for detail in &section.details {
+                println!("  {}", detail);
+            }
+            println!();
+        }
+
+        Ok(())
+    }
+
     pub fn run(report: &AssaultReport) -> Result<()> {
         terminal::enable_raw_mode()?;
         let result = Self::run_inner(report);

tests/readiness.rs

@@ -52,6 +52,43 @@ fn run(args: &[&str]) -> (bool, String, String) {
     )
 }
 
+/// Minimal `AssaultReport` JSON for headless subcommand tests.
+///
+/// Matches the full serde schema (all required fields present) so
+/// `serde_json::from_str::<AssaultReport>` succeeds without panic.
+fn minimal_assault_report_json() -> String {
+    serde_json::json!({
+        "schema_version": "2.5",
+        "assail_report": {
+            "schema_version": "2.5",
+            "program_path": "/tmp/headless-test",
+            "language": "rust",
+            "frameworks": [],
+            "weak_points": [],
+            "statistics": {
+                "total_lines": 10,
+                "unsafe_blocks": 0,
+                "panic_sites": 0,
+                "unwrap_calls": 0,
+                "allocation_sites": 0,
+                "io_operations": 0,
+                "threading_constructs": 0
+            },
+            "file_statistics": [],
+            "recommended_attacks": []
+        },
+        "attack_results": [],
+        "total_crashes": 0,
+        "total_signatures": 0,
+        "overall_assessment": {
+            "robustness_score": 100.0,
+            "critical_issues": [],
+            "recommendations": []
+        }
+    })
+    .to_string()
+}
+
 // ============================================================
 // Grade D (Alpha): each component runs without crashing
 // ============================================================
@@ -82,6 +119,52 @@ fn readiness_d_help_runs() {
     assert!(ok, "help should succeed: {}", stderr);
 }
 
+#[test]
+fn readiness_d_tui_headless_runs() {
+    let dir = TempDir::new().unwrap();
+    let report_path = dir.path().join("assault.json");
+    fs::write(&report_path, minimal_assault_report_json()).unwrap();
+
+    let (ok, stdout, stderr) = run(&["tui", "--headless", report_path.to_str().unwrap()]);
+    assert!(ok, "tui --headless should succeed without a TTY: {}", stderr);
+    assert!(
+        stdout.contains("PANIC-ATTACK REPORT REVIEW"),
+        "tui --headless should print report header, got: {}",
+        stdout
+    );
+    assert!(
+        stdout.contains("Assail Summary"),
+        "tui --headless should include Assail Summary section"
+    );
+}
+
+#[test]
+fn readiness_d_gui_headless_runs() {
+    let dir = TempDir::new().unwrap();
+    let report_path = dir.path().join("assault.json");
+    fs::write(&report_path, minimal_assault_report_json()).unwrap();
+
+    let (ok, stdout, stderr) = run(&["gui", "--headless", report_path.to_str().unwrap()]);
+    assert!(
+        ok,
+        "gui --headless should succeed without a display server: {}",
+        stderr
+    );
+    assert!(
+        stdout.contains("PANIC-ATTACK GUI REPORT"),
+        "gui --headless should print GUI report header, got: {}",
+        stdout
+    );
+    assert!(
+        stdout.contains("Summary"),
+        "gui --headless should include Summary panel"
+    );
+    assert!(
+        stdout.contains("Assessment"),
+        "gui --headless should include Assessment panel"
+    );
+}
+
 // ============================================================
 // Grade C (Beta): components produce correct output
 // ============================================================