feat(pa15): complete P2-A15 must-items — schema_version, headless, adjust.ncl, seam tests

Schema versioning (AmuckReport, AbductReport, AxialReport):
- Add schema_version "2.5" with serde default to the three remaining
  report types (AmuckReport, AbductReport, AxialReport); old reports
  without the field deserialize cleanly via #[serde(default = "...")]

Seam contract tests (20 total, 9 new):
- Add schema_version pin + backward-compat round-trip tests for
  AmuckReport, AbductReport, AxialReport in tests/seam_contract_tests.rs

ADJUST contractile (6th verb, trident complete):
- Add .machine_readable/contractiles/adjust/adjust.ncl runner — 8 checks
  covering threshold wiring, safe-unwrap tracking, FP suppression rules,
  schema consistency, seam test presence. Trident is now complete.

Headless flag (assail subcommand):
- Wire --headless flag in assail arm of run_main(); JSON goes to stdout
  when either --quiet or --headless is set (CI callers use --headless
  without having to pass --quiet)

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

Author: hyperpolymath

.machine_readable/contractiles/adjust/adjust.ncl

@@ -0,0 +1,31 @@
+# SPDX-License-Identifier: PMPL-1.0-or-later
+# adjust.ncl — runner for the ADJUST contractile (calibration and tuning)
+# Copyright (c) 2026 Jonathan D.A. Jewell (hyperpolymath)
+#
+# Pairs with: Adjustfile.a2ml (same directory)
+# Verb:       adjust
+# Semantics:  verify that declared detector thresholds and calibration
+#             values are still wired into the source code. Flags threshold
+#             drift (declared ≠ live) so it can be resolved consciously.
+# CLI:        `contractile adjust check`  → list calibration checks + status
+
+let checks = [
+  { name = "adjustfile-present",
+    cmd = "test -f .machine_readable/contractiles/adjust/Adjustfile.a2ml" },
+  { name = "panic-path-unwrap-threshold-wired",
+    cmd = "grep -qE 'unwrap_threshold|unwrap_calls > [0-9]' src/assail/analyzer.rs src/report/generator.rs 2>/dev/null" },
+  { name = "panic-path-panic-threshold-wired",
+    cmd = "grep -qE 'panic_threshold|panic_sites > [0-9]' src/assail/analyzer.rs 2>/dev/null" },
+  { name = "safe-unwrap-excluded-from-pa006",
+    cmd = "grep -q 'safe_unwrap_calls' src/assail/analyzer.rs" },
+  { name = "safe-unwrap-field-in-statistics",
+    cmd = "grep -q 'safe_unwrap_calls' src/types.rs" },
+  { name = "fp-suppression-rules-present",
+    cmd = "grep -qE 'suppression_rule|load_suppression_rules|SuppressionRule' src/kanren/core.rs 2>/dev/null" },
+  { name = "schema-version-consistent-across-reports",
+    cmd = "grep -l '\"2\\.5\"' src/types.rs src/assemblyline.rs src/adjudicate/mod.rs src/amuck/mod.rs src/abduct/mod.rs src/axial/mod.rs 2>/dev/null | wc -l | grep -qE '^[6-9]|^[1-9][0-9]'" },
+  { name = "seam-contract-tests-exist",
+    cmd = "test -f tests/seam_contract_tests.rs" },
+] in
+
+checks

src/abduct/mod.rs

@@ -54,6 +54,7 @@ fn abduct_schema_version() -> String {
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct AbductReport {
+    /// Schema version for forward compatibility. Consumers check this before parsing.
     #[serde(default = "abduct_schema_version")]
     pub schema_version: String,
     pub created_at: String,
@@ -227,7 +228,7 @@ pub fn run(config: AbductConfig) -> Result<AbductReport> {
     }
 
     Ok(AbductReport {
-        schema_version: "2.5".to_string(),
+        schema_version: abduct_schema_version(),
         created_at: chrono::Utc::now().to_rfc3339(),
         target,
         source_root,

src/amuck/mod.rs

@@ -74,6 +74,7 @@ fn amuck_schema_version() -> String {
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct AmuckReport {
+    /// Schema version for forward compatibility. Consumers check this before parsing.
     #[serde(default = "amuck_schema_version")]
     pub schema_version: String,
     pub created_at: String,
@@ -225,7 +226,7 @@ pub fn run(config: AmuckConfig) -> Result<AmuckReport> {
 
     let combinations_run = outcomes.iter().filter(|o| o.mutated_file.is_some()).count();
     let report = AmuckReport {
-        schema_version: "2.5".to_string(),
+        schema_version: amuck_schema_version(),
         created_at: chrono::Utc::now().to_rfc3339(),
         target: config.target,
         source_spec: config.spec_path,

src/axial/mod.rs

@@ -58,6 +58,7 @@ fn axial_schema_version() -> String {
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct AxialReport {
+    /// Schema version for forward compatibility. Consumers check this before parsing.
     #[serde(default = "axial_schema_version")]
     pub schema_version: String,
     pub created_at: String,
@@ -256,7 +257,7 @@ pub fn run(config: AxialConfig) -> Result<AxialReport> {
     };
 
     Ok(AxialReport {
-        schema_version: "2.5".to_string(),
+        schema_version: axial_schema_version(),
         created_at: chrono::Utc::now().to_rfc3339(),
         target: config.target,
         executed_program: config.execute.as_ref().map(|e| e.program.clone()),
@@ -897,6 +898,7 @@ mod tests {
 
         let path = dir.path().join("amuck.json");
         let report = AmuckReport {
+            schema_version: "2.5".to_string(),
             created_at: chrono::Utc::now().to_rfc3339(),
             target: target.clone(),
             source_spec: None,

src/main.rs

@@ -140,6 +140,10 @@ enum Commands {
         /// Browser extension mode: ignore DevTools API eval() usage
         #[arg(long, default_value_t = false)]
         browser_extension: bool,
+
+        /// Headless mode: emit JSON to stdout, suppress interactive prompts (CI-safe)
+        #[arg(long, default_value_t = false)]
+        headless: bool,
     },
 
     /// Execute a single attack on a target program
@@ -1113,7 +1117,7 @@ fn run_main() -> Result<()> {
             attest,
             signing_key,
             browser_extension,
-            ..
+            headless,
         } => {
             qprintln!(
                 cli.quiet,
@@ -1169,9 +1173,9 @@ fn run_main() -> Result<()> {
             if let Some(output_path) = &output {
                 fs::write(output_path, &report_json)?;
                 qprintln!(cli.quiet, "Report saved to: {}", output_path.display());
-            } else if cli.quiet {
-                // Machine-readable mode: print JSON to stdout for pipeline consumers
-                // (e.g. the Chapel mass-panic orchestrator reads this via subprocess pipe)
+            } else if cli.quiet || headless {
+                // Machine-readable mode: emit JSON to stdout for pipeline consumers.
+                // `--headless` makes this explicit for CI callers that cannot pass --quiet.
                 println!("{report_json}");
             } else {
                 println!("\nAssail Summary:");

tests/regression_tests.rs

@@ -3,7 +3,7 @@
 //! Regression tests against known codebases
 
 use panic_attack::assail;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 fn repos_dir() -> PathBuf {
     std::env::var("REPOS_DIR")

tests/seam_contract_tests.rs

@@ -22,9 +22,9 @@
 //! - **Schema version sentinel** (all consumers):
 //!   reads `schema_version` to detect incompatible changes
 
-use panic_attack::abduct;
-use panic_attack::amuck;
-use panic_attack::axial;
+use panic_attack::abduct::{self, AbductReport};
+use panic_attack::amuck::{self, AmuckReport};
+use panic_attack::axial::{self, AxialReport};
 use panic_attack::types::*;
 use serde_json::Value;
 
@@ -291,6 +291,7 @@ fn old_report_without_schema_version_deserializes_with_default() {
     );
 }
 
+<<<<<<< HEAD
 // ─── schema_version on subsidiary report types ───────────────────────────
 
 #[test]
@@ -366,10 +367,23 @@ fn abduct_report_has_schema_version() {
         source_root: std::path::PathBuf::from("."),
         workspace_dir: std::path::PathBuf::from("runtime/abduct"),
         dependency_scope: "direct".to_string(),
+=======
+// ─── AbductReport schema pin ─────────────────────────────────────────────
+
+fn minimal_abduct_report() -> AbductReport {
+    AbductReport {
+        schema_version: "2.5".to_string(),
+        created_at: "2026-01-01T00:00:00Z".to_string(),
+        target: std::path::PathBuf::from("src/main.rs"),
+        source_root: std::path::PathBuf::from("src"),
+        workspace_dir: std::path::PathBuf::from("runtime/abduct/test"),
+        dependency_scope: "none".to_string(),
+>>>>>>> 87578d9 (feat(pa15): complete P2-A15 must-items — schema_version, headless, adjust.ncl, seam tests)
         selected_files: 0,
         locked_files: 0,
         mtime_shifted_files: 0,
         mtime_offset_days: 0,
+<<<<<<< HEAD
         time_mode: "real".to_string(),
         time_scale: None,
         virtual_now: None,
@@ -380,4 +394,165 @@ fn abduct_report_has_schema_version() {
     let json: Value = serde_json::to_value(&r).expect("serialize");
     assert_eq!(json["schema_version"].as_str(), Some("2.5"),
         "AbductReport must carry schema_version");
+=======
+        time_mode: "normal".to_string(),
+        time_scale: None,
+        virtual_now: None,
+        notes: vec![],
+        files: vec![],
+        execution: None,
+    }
+}
+
+#[test]
+fn abduct_report_has_schema_version() {
+    let report = minimal_abduct_report();
+    let json: Value = serde_json::to_value(&report).expect("serialize");
+    assert_eq!(
+        json["schema_version"].as_str(),
+        Some("2.5"),
+        "AbductReport schema_version must be '2.5'"
+    );
+}
+
+#[test]
+fn abduct_report_schema_version_round_trip() {
+    let report = minimal_abduct_report();
+    let json_str = serde_json::to_string(&report).expect("serialize");
+    let back: AbductReport = serde_json::from_str(&json_str).expect("deserialize");
+    assert_eq!(back.schema_version, "2.5");
+}
+
+#[test]
+fn old_abduct_report_without_schema_version_deserializes_with_default() {
+    let json_str = r#"{
+        "created_at": "2026-01-01T00:00:00Z",
+        "target": "src/main.rs",
+        "source_root": "src",
+        "workspace_dir": "runtime/abduct/test",
+        "dependency_scope": "none",
+        "selected_files": 0,
+        "locked_files": 0,
+        "mtime_shifted_files": 0,
+        "mtime_offset_days": 0,
+        "time_mode": "normal"
+    }"#;
+    let report: AbductReport =
+        serde_json::from_str(json_str).expect("deserialize old abduct report");
+    assert_eq!(
+        report.schema_version, "2.5",
+        "old AbductReport missing schema_version must default to '2.5'"
+    );
+}
+
+// ─── AmuckReport schema pin ──────────────────────────────────────────────
+
+fn minimal_amuck_report() -> AmuckReport {
+    AmuckReport {
+        schema_version: "2.5".to_string(),
+        created_at: "2026-01-01T00:00:00Z".to_string(),
+        target: std::path::PathBuf::from("src/main.rs"),
+        source_spec: None,
+        preset: "light".to_string(),
+        max_combinations: 0,
+        output_dir: std::path::PathBuf::from("runtime/amuck"),
+        combinations_planned: 0,
+        combinations_run: 0,
+        outcomes: vec![],
+    }
+}
+
+#[test]
+fn amuck_report_has_schema_version() {
+    let report = minimal_amuck_report();
+    let json: Value = serde_json::to_value(&report).expect("serialize");
+    assert_eq!(
+        json["schema_version"].as_str(),
+        Some("2.5"),
+        "AmuckReport schema_version must be '2.5'"
+    );
+}
+
+#[test]
+fn amuck_report_schema_version_round_trip() {
+    let report = minimal_amuck_report();
+    let json_str = serde_json::to_string(&report).expect("serialize");
+    let back: AmuckReport = serde_json::from_str(&json_str).expect("deserialize");
+    assert_eq!(back.schema_version, "2.5");
+}
+
+#[test]
+fn old_amuck_report_without_schema_version_deserializes_with_default() {
+    let json_str = r#"{
+        "created_at": "2026-01-01T00:00:00Z",
+        "target": "src/main.rs",
+        "preset": "light",
+        "max_combinations": 0,
+        "output_dir": "runtime/amuck",
+        "combinations_planned": 0,
+        "combinations_run": 0,
+        "outcomes": []
+    }"#;
+    let report: AmuckReport = serde_json::from_str(json_str).expect("deserialize old amuck report");
+    assert_eq!(
+        report.schema_version, "2.5",
+        "old AmuckReport missing schema_version must default to '2.5'"
+    );
+}
+
+// ─── AxialReport schema pin ──────────────────────────────────────────────
+
+fn minimal_axial_report() -> AxialReport {
+    AxialReport {
+        schema_version: "2.5".to_string(),
+        created_at: "2026-01-01T00:00:00Z".to_string(),
+        target: std::path::PathBuf::from("src/main.rs"),
+        executed_program: None,
+        repeat: 0,
+        observed_runs: 0,
+        observed_reports: 0,
+        language: "en".to_string(),
+        run_observations: vec![],
+        report_observations: vec![],
+        signal_counts: std::collections::BTreeMap::new(),
+        recommendations: vec![],
+        aspell: None,
+    }
+}
+
+#[test]
+fn axial_report_has_schema_version() {
+    let report = minimal_axial_report();
+    let json: Value = serde_json::to_value(&report).expect("serialize");
+    assert_eq!(
+        json["schema_version"].as_str(),
+        Some("2.5"),
+        "AxialReport schema_version must be '2.5'"
+    );
+}
+
+#[test]
+fn axial_report_schema_version_round_trip() {
+    let report = minimal_axial_report();
+    let json_str = serde_json::to_string(&report).expect("serialize");
+    let back: AxialReport = serde_json::from_str(&json_str).expect("deserialize");
+    assert_eq!(back.schema_version, "2.5");
+}
+
+#[test]
+fn old_axial_report_without_schema_version_deserializes_with_default() {
+    let json_str = r#"{
+        "created_at": "2026-01-01T00:00:00Z",
+        "target": "src/main.rs",
+        "repeat": 0,
+        "observed_runs": 0,
+        "observed_reports": 0,
+        "language": "en"
+    }"#;
+    let report: AxialReport = serde_json::from_str(json_str).expect("deserialize old axial report");
+    assert_eq!(
+        report.schema_version, "2.5",
+        "old AxialReport missing schema_version must default to '2.5'"
+    );
+>>>>>>> 87578d9 (feat(pa15): complete P2-A15 must-items — schema_version, headless, adjust.ncl, seam tests)
 }