chore: restore checker CI gate

crates/cph-cli/src/main.rs

@@ -51,12 +51,12 @@ enum Command {
     /// completion file, e.g. `cph completions zsh > ~/.zfunc/_cph`.
     Completions {
         /// Which shell to generate completions for.
-        shell: Shell,
+        shell: CompletionTarget,
     },
 }
 
 #[derive(Debug, Clone, Copy, clap::ValueEnum)]
-enum Shell {
+enum CompletionTarget {
     Bash,
     Zsh,
     Fish,
@@ -82,16 +82,16 @@ fn main() -> ExitCode {
 /// Emit a shell-completion script for `shell` to stdout. The script is built
 /// from the same `Cli` clap definition above, so it tracks subcommands/flags as
 /// they evolve.
-fn run_completions(shell: Shell) -> ExitCode {
+fn run_completions(shell: CompletionTarget) -> ExitCode {
     use clap::CommandFactory;
     use clap_complete::Shell as CompShell;
 
     let sh = match shell {
-        Shell::Bash => CompShell::Bash,
-        Shell::Zsh => CompShell::Zsh,
-        Shell::Fish => CompShell::Fish,
-        Shell::PowerShell => CompShell::PowerShell,
-        Shell::Elvish => CompShell::Elvish,
+        CompletionTarget::Bash => CompShell::Bash,
+        CompletionTarget::Zsh => CompShell::Zsh,
+        CompletionTarget::Fish => CompShell::Fish,
+        CompletionTarget::PowerShell => CompShell::PowerShell,
+        CompletionTarget::Elvish => CompShell::Elvish,
     };
     let mut cmd = Cli::command();
     clap_complete::generate(sh, &mut cmd, "cph", &mut std::io::stdout());
@@ -188,7 +188,10 @@ fn run_build(
 /// explicit `cph build --target <name>`, and each command is printed before it
 /// runs so the user sees exactly what is executed.
 fn run_shell_build(path: &std::path::Path, engine: &Engine, target: &str) -> ExitCode {
-    eprintln!("running shell-step target '{target}' (commands execute in {})", path.display());
+    eprintln!(
+        "running shell-step target '{target}' (commands execute in {})",
+        path.display()
+    );
     let report = cph_check::run_shell_target(path, engine, target);
     print_diagnostics(&report.check);
 
@@ -196,7 +199,10 @@ fn run_shell_build(path: &std::path::Path, engine: &Engine, target: &str) -> Exi
         // Refused before running anything (check errors / unknown target / no
         // shell steps): the diagnostics above explain why.
         if report.check.has_errors() {
-            eprintln!("build refused: {} errors (fix the lesson first)", report.check.error_count());
+            eprintln!(
+                "build refused: {} errors (fix the lesson first)",
+                report.check.error_count()
+            );
         } else {
             eprintln!("build failed: target '{target}' has no shell steps to run");
         }
@@ -212,13 +218,19 @@ fn run_shell_build(path: &std::path::Path, engine: &Engine, target: &str) -> Exi
             eprint!("{}", outcome.stderr);
             eprintln!(
                 "step failed (exit {})",
-                outcome.status.map(|c| c.to_string()).unwrap_or_else(|| "signal".into())
+                outcome
+                    .status
+                    .map(|c| c.to_string())
+                    .unwrap_or_else(|| "signal".into())
             );
         }
     }
 
     if report.ok {
-        println!("shell-step target '{target}' completed: {} step(s) ok", report.outcomes.len());
+        println!(
+            "shell-step target '{target}' completed: {} step(s) ok",
+            report.outcomes.len()
+        );
         ExitCode::SUCCESS
     } else {
         eprintln!("shell-step target '{target}' failed");
@@ -231,13 +243,19 @@ fn run_shell_build(path: &std::path::Path, engine: &Engine, target: &str) -> Exi
 /// shell path, this is opt-in — only on an explicit `cph build --target <name>`,
 /// and never in `check`.
 fn run_markdown_assemble_build(path: &std::path::Path, engine: &Engine, target: &str) -> ExitCode {
-    eprintln!("assembling markdown target '{target}' (reading parts under {})", path.display());
+    eprintln!(
+        "assembling markdown target '{target}' (reading parts under {})",
+        path.display()
+    );
     let report = cph_check::run_markdown_assemble_target(path, engine, target);
     print_diagnostics(&report.check);
 
     if report.outcomes.is_empty() && !report.ok {
         if report.check.has_errors() {
-            eprintln!("build refused: {} errors (fix the lesson first)", report.check.error_count());
+            eprintln!(
+                "build refused: {} errors (fix the lesson first)",
+                report.check.error_count()
+            );
         } else {
             eprintln!("build failed: target '{target}' has no assemble-markdown steps to run");
         }
@@ -250,7 +268,11 @@ fn run_markdown_assemble_build(path: &std::path::Path, engine: &Engine, target:
             outcome.field, outcome.parts_read
         );
         if let Some(out_rel) = &outcome.written {
-            println!("wrote {} ({} bytes)", path.join(out_rel).display(), outcome.body.len());
+            println!(
+                "wrote {} ({} bytes)",
+                path.join(out_rel).display(),
+                outcome.body.len()
+            );
         }
         if let Some(err) = &outcome.error {
             eprintln!("assemble failed: {err}");
@@ -258,7 +280,10 @@ fn run_markdown_assemble_build(path: &std::path::Path, engine: &Engine, target:
     }
 
     if report.ok {
-        println!("assemble-markdown target '{target}' completed: {} step(s) ok", report.outcomes.len());
+        println!(
+            "assemble-markdown target '{target}' completed: {} step(s) ok",
+            report.outcomes.len()
+        );
         ExitCode::SUCCESS
     } else {
         eprintln!("assemble-markdown target '{target}' failed");