feat(create-pr): align with gh-aw create-pull-request implementation

Cargo.toml

@@ -30,6 +30,9 @@ terminal_size = "0.4.3"
 url = "2.5.8"
 axum = { version = "0.8.8", features = ["tokio"] }
 subtle = "2.6.1"
+rand = "0.10.1"
+base64 = "0.22.1"
+glob-match = "0.2.1"
 
 [dev-dependencies]
 reqwest = { version = "0.12", features = ["blocking"] }

src/execute.rs

@@ -156,7 +156,15 @@ pub async fn execute_safe_outputs(
 
         match execute_safe_output(entry, ctx).await {
             Ok((tool_name, result)) => {
-                if result.success {
+                if result.is_warning() {
+                    warn!(
+                        "[{}/{}] {} warning: {}",
+                        i + 1,
+                        entries.len(),
+                        tool_name,
+                        result.message
+                    );
+                } else if result.success {
                     info!(
                         "[{}/{}] {} succeeded: {}",
                         i + 1,
@@ -173,12 +181,13 @@ pub async fn execute_safe_outputs(
                         result.message
                     );
                 }
+                let symbol = if result.is_warning() { "⚠" } else if result.success { "✓" } else { "✗" };
                 println!(
                     "[{}/{}] {} - {} - {}",
                     i + 1,
                     entries.len(),
                     tool_name,
-                    if result.success { "✓" } else { "✗" },
+                    symbol,
                     result.message
                 );
                 results.push(result);
@@ -193,11 +202,12 @@ pub async fn execute_safe_outputs(
     }
 
     // Log final summary
-    let success_count = results.iter().filter(|r| r.success).count();
-    let failure_count = results.len() - success_count;
+    let success_count = results.iter().filter(|r| r.success && !r.is_warning()).count();
+    let warning_count = results.iter().filter(|r| r.is_warning()).count();
+    let failure_count = results.iter().filter(|r| !r.success).count();
     info!(
-        "Stage 2 execution complete: {} succeeded, {} failed",
-        success_count, failure_count
+        "Stage 2 execution complete: {} succeeded, {} warnings, {} failed",
+        success_count, warning_count, failure_count
     );
 
     Ok(results)

src/main.rs

@@ -254,19 +254,25 @@ async fn main() -> Result<()> {
                 }
 
                 // Print summary
-                let success_count = results.iter().filter(|r| r.success).count();
-                let failure_count = results.len() - success_count;
+                let success_count = results.iter().filter(|r| r.success && !r.is_warning()).count();
+                let warning_count = results.iter().filter(|r| r.is_warning()).count();
+                let failure_count = results.iter().filter(|r| !r.success).count();
 
                 println!("\n--- Execution Summary ---");
                 println!(
-                    "Total: {} | Success: {} | Failed: {}",
+                    "Total: {} | Success: {} | Warnings: {} | Failed: {}",
                     results.len(),
                     success_count,
+                    warning_count,
                     failure_count
                 );
 
                 if failure_count > 0 {
                     std::process::exit(1);
+                } else if warning_count > 0 {
+                    // Exit code 2 signals "succeeded with issues" — the pipeline
+                    // step wraps this to emit ##vso[task.complete result=SucceededWithIssues;]
+                    std::process::exit(2);
                 }
             }
             Commands::Proxy { allowed_hosts } => {