fix: aofctl serve now produces visible startup output (#93)

gouravjshah · claude · web-flow · commit 0bbeddacd861 · 2025-12-28T18:02:15.000+05:30
Changed critical startup messages from tracing macros to println/eprintln so they are always visible regardless of log level. The CLI's default log level is "error", which was suppressing all info-level startup messages. - Server bind address, registered platforms, loaded agents/flows now shown - Error messages use stderr for proper output separation - Updated docs with expected startup output section 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Fixed
+- `aofctl serve` now produces visible startup output
+  - Changed from tracing (default level: error) to println for critical startup messages
+  - Users can now see server bind address, registered platforms, loaded agents/flows
+  - Error messages use stderr for proper output separation
+
 ## [0.3.1-beta] - 2025-12-26
 
 ### Added
diff --git a/crates/aofctl/src/commands/serve.rs b/crates/aofctl/src/commands/serve.rs
@@ -23,7 +23,6 @@ use aof_triggers::{
 };
 use serde::{Deserialize, Serialize};
 use tokio::sync::RwLock;
-use tracing::{info, warn, error};
 
 /// Server configuration loaded from YAML
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -309,7 +308,7 @@ pub async fn execute(
 ) -> anyhow::Result<()> {
     // Load configuration
     let config = if let Some(config_path) = config_file {
-        info!("Loading configuration from: {}", config_path);
+        println!("Loading configuration from: {}", config_path);
         let content = std::fs::read_to_string(config_path)?;
         serde_yaml::from_str::<ServeConfig>(&content)?
     } else {
@@ -351,8 +350,8 @@ pub async fn execute(
         .parse()
         .map_err(|e| anyhow::anyhow!("Invalid bind address: {}", e))?;
 
-    info!("Starting AOF Trigger Server");
-    info!("  Bind address: {}", bind_addr);
+    println!("Starting AOF Trigger Server");
+    println!("  Bind address: {}", bind_addr);
 
     // Create runtime orchestrator
     let orchestrator = Arc::new(
@@ -370,7 +369,7 @@ pub async fn execute(
     };
 
     if let Some(ref agent) = config.spec.runtime.default_agent {
-        info!("  Default agent for natural language: {}", agent);
+        println!("  Default agent for natural language: {}", agent);
     }
 
     // Create trigger handler
@@ -408,15 +407,15 @@ pub async fn execute(
                 match SlackPlatform::new_with_auto_detection(platform_config).await {
                     Ok(platform) => {
                         handler.register_platform(Arc::new(platform));
-                        info!("  Registered platform: slack");
+                        println!("  Registered platform: slack");
                         platforms_registered += 1;
                     }
                     Err(e) => {
-                        warn!("  Failed to create Slack platform: {}", e);
+                        eprintln!("  Failed to create Slack platform: {}", e);
                     }
                 }
             } else {
-                warn!("  Slack enabled but missing bot_token or signing_secret");
+                eprintln!("  Slack enabled but missing bot_token or signing_secret");
             }
         }
     }
@@ -438,10 +437,10 @@ pub async fn execute(
                 };
                 let platform = Arc::new(DiscordPlatform::new(platform_config));
                 handler.register_platform(platform);
-                info!("  Registered platform: discord");
+                println!("  Registered platform: discord");
                 platforms_registered += 1;
             } else {
-                warn!("  Discord enabled but missing bot_token");
+                eprintln!("  Discord enabled but missing bot_token");
             }
         }
     }
@@ -466,15 +465,15 @@ pub async fn execute(
                 match TelegramPlatform::new(platform_config) {
                     Ok(platform) => {
                         handler.register_platform(Arc::new(platform));
-                        info!("  Registered platform: telegram");
+                        println!("  Registered platform: telegram");
                         platforms_registered += 1;
                     }
                     Err(e) => {
-                        warn!("  Failed to create Telegram platform: {}", e);
+                        eprintln!("  Failed to create Telegram platform: {}", e);
                     }
                 }
             } else {
-                warn!("  Telegram enabled but missing bot_token");
+                eprintln!("  Telegram enabled but missing bot_token");
             }
         }
     }
@@ -500,15 +499,15 @@ pub async fn execute(
                 match WhatsAppPlatform::new(platform_config) {
                     Ok(platform) => {
                         handler.register_platform(Arc::new(platform));
-                        info!("  Registered platform: whatsapp");
+                        println!("  Registered platform: whatsapp");
                         platforms_registered += 1;
                     }
                     Err(e) => {
-                        warn!("  Failed to create WhatsApp platform: {}", e);
+                        eprintln!("  Failed to create WhatsApp platform: {}", e);
                     }
                 }
             } else {
-                warn!("  WhatsApp enabled but missing access_token");
+                eprintln!("  WhatsApp enabled but missing access_token");
             }
         }
     }
@@ -519,13 +518,13 @@ pub async fn execute(
         .or_else(|| config.spec.triggers.directory.clone());
 
     if let Some(ref triggers_path) = triggers_dir_path {
-        info!("Loading Triggers from: {}", triggers_path.display());
+        println!("Loading Triggers from: {}", triggers_path.display());
         let mut trigger_registry = TriggerRegistry::new();
 
         match trigger_registry.load_directory(triggers_path) {
             Ok(count) => {
                 if count > 0 {
-                    info!("  Loaded {} triggers: {:?}", count, trigger_registry.names());
+                    println!("  Loaded {} triggers: {:?}", count, trigger_registry.names());
 
                     // Register platforms for each trigger type
                     for trigger in trigger_registry.get_all() {
@@ -539,7 +538,7 @@ pub async fn execute(
                                         .unwrap_or_default();
 
                                     if token.is_empty() {
-                                        warn!("  GitHub trigger '{}': GITHUB_TOKEN not set, API features disabled", trigger.name());
+                                        eprintln!("  GitHub trigger '{}': GITHUB_TOKEN not set, API features disabled", trigger.name());
                                     }
 
                                     let github_config = GitHubConfig {
@@ -558,15 +557,15 @@ pub async fn execute(
                                     match GitHubPlatform::new(github_config) {
                                         Ok(platform) => {
                                             handler.register_platform(Arc::new(platform));
-                                            info!("  Registered platform: github (from trigger '{}')", trigger.name());
+                                            println!("  Registered platform: github (from trigger '{}')", trigger.name());
                                             platforms_registered += 1;
                                         }
                                         Err(e) => {
-                                            warn!("  Failed to create GitHub platform: {}", e);
+                                            eprintln!("  Failed to create GitHub platform: {}", e);
                                         }
                                     }
                                 } else {
-                                    warn!("  GitHub trigger '{}' missing webhook_secret", trigger.name());
+                                    eprintln!("  GitHub trigger '{}' missing webhook_secret", trigger.name());
                                 }
                             }
                             // Other trigger types use platforms registered from config
@@ -588,32 +587,32 @@ pub async fn execute(
                             handler.register_command_binding(cmd_name.clone(), handler_binding);
 
                             if let Some(ref agent) = binding.agent {
-                                info!("  Registered command '{}' -> agent '{}'", cmd, agent);
+                                println!("  Registered command '{}' -> agent '{}'", cmd, agent);
                             } else if let Some(ref fleet) = binding.fleet {
-                                info!("  Registered command '{}' -> fleet '{}'", cmd, fleet);
+                                println!("  Registered command '{}' -> fleet '{}'", cmd, fleet);
                             } else if let Some(ref flow) = binding.flow {
-                                info!("  Registered command '{}' -> flow '{}'", cmd, flow);
+                                println!("  Registered command '{}' -> flow '{}'", cmd, flow);
                             }
                         }
 
                         // Set default agent if specified in trigger
                         if let Some(ref default_agent) = trigger.spec.default_agent {
-                            info!("  Default agent for trigger '{}': {}", trigger.name(), default_agent);
+                            println!("  Default agent for trigger '{}': {}", trigger.name(), default_agent);
                         }
                     }
                 } else {
-                    info!("  No Trigger files found in {}", triggers_path.display());
+                    println!("  No Trigger files found in {}", triggers_path.display());
                 }
             }
             Err(e) => {
-                warn!("  Failed to load triggers from {}: {}", triggers_path.display(), e);
+                eprintln!("  Failed to load triggers from {}: {}", triggers_path.display(), e);
             }
         }
     }
 
     if platforms_registered == 0 {
-        warn!("No platforms registered! Server will start but won't process any webhooks.");
-        warn!("Configure platforms in your config file or set environment variables.");
+        eprintln!("Warning: No platforms registered! Server will start but won't process any webhooks.");
+        eprintln!("Configure platforms in your config file or set environment variables.");
     }
 
     // Load AgentFlows and set up FlowRouter
@@ -626,7 +625,7 @@ pub async fn execute(
 
     if config.spec.flows.enabled {
         if let Some(ref flows_path) = flows_dir_path {
-            info!("Loading AgentFlows from: {}", flows_path.display());
+            println!("Loading AgentFlows from: {}", flows_path.display());
 
             match FlowRegistry::from_directory(flows_path).await {
                 Ok(registry) => {
@@ -653,27 +652,27 @@ pub async fn execute(
                         if let Some(ref ap) = agents_path {
                             match handler.load_agents_from_directory(ap).await {
                                 Ok(count) => {
-                                    info!("  Pre-loaded {} agents from {:?}", count, ap);
+                                    println!("  Pre-loaded {} agents from {:?}", count, ap);
                                     agents_loaded = true;
                                 }
-                                Err(e) => warn!("  Failed to pre-load agents: {}", e),
+                                Err(e) => eprintln!("  Failed to pre-load agents: {}", e),
                             }
                         }
 
-                        info!("  Loaded {} AgentFlows: {:?}", flow_count, flow_names);
+                        println!("  Loaded {} AgentFlows: {:?}", flow_count, flow_names);
                     } else {
-                        info!("  No AgentFlow files found in {}", flows_path.display());
+                        println!("  No AgentFlow files found in {}", flows_path.display());
                     }
                 }
                 Err(e) => {
-                    warn!("  Failed to load AgentFlows from {}: {}", flows_path.display(), e);
+                    eprintln!("  Failed to load AgentFlows from {}: {}", flows_path.display(), e);
                 }
             }
         } else {
-            info!("  No flows directory configured - using default agent routing");
+            println!("  No flows directory configured - using default agent routing");
         }
     } else {
-        info!("  Flow-based routing disabled");
+        println!("  Flow-based routing disabled");
     }
 
     // Pre-load agents from directory if not already done
@@ -687,8 +686,8 @@ pub async fn execute(
             let runtime = Arc::new(RwLock::new(Runtime::new()));
             handler.set_runtime(runtime);
             match handler.load_agents_from_directory(ap).await {
-                Ok(count) => info!("  Pre-loaded {} agents from {:?}", count, ap),
-                Err(e) => warn!("  Failed to pre-load agents: {}", e),
+                Ok(count) => println!("  Pre-loaded {} agents from {:?}", count, ap),
+                Err(e) => eprintln!("  Failed to pre-load agents: {}", e),
             }
         }
     }
@@ -704,28 +703,28 @@ pub async fn execute(
     // Create and start server
     let server = TriggerServer::with_config(Arc::new(handler), server_config);
 
-    info!("Server starting...");
-    info!("  Health check: http://{}/health", bind_addr);
-    info!("  Webhook endpoint: http://{}/webhook/{{platform}}", bind_addr);
-    info!("Press Ctrl+C to stop");
+    println!("Server starting...");
+    println!("  Health check: http://{}/health", bind_addr);
+    println!("  Webhook endpoint: http://{}/webhook/{{platform}}", bind_addr);
+    println!("Press Ctrl+C to stop");
 
     // Handle graceful shutdown
     let shutdown_signal = async {
         tokio::signal::ctrl_c()
             .await
             .expect("Failed to install Ctrl+C handler");
-        info!("Shutdown signal received, stopping server...");
+        println!("\nShutdown signal received, stopping server...");
     };
 
     tokio::select! {
         result = server.serve() => {
             if let Err(e) = result {
-                error!("Server error: {}", e);
+                eprintln!("Server error: {}", e);
                 return Err(anyhow::anyhow!("Server error: {}", e));
             }
         }
         _ = shutdown_signal => {
-            info!("Server stopped gracefully");
+            println!("Server stopped gracefully");
         }
     }
 
diff --git a/docs/reference/daemon-config.md b/docs/reference/daemon-config.md
@@ -421,6 +421,26 @@ aofctl serve \
 aofctl serve --config daemon-config.yaml --port 3000
 ```
 
+### Expected Startup Output
+
+When the server starts successfully, you'll see:
+
+```
+Loading configuration from: daemon-config.yaml
+Starting AOF Trigger Server
+  Bind address: 0.0.0.0:3000
+  Default agent for natural language: devops
+  Registered platform: slack
+  Registered platform: telegram
+Loading AgentFlows from: ./flows/
+  Pre-loaded 19 agents from "./agents/"
+  Loaded 3 AgentFlows: ["k8s-health-check", "docker-troubleshoot", "data-pipeline"]
+Server starting...
+  Health check: http://0.0.0.0:3000/health
+  Webhook endpoint: http://0.0.0.0:3000/webhook/{platform}
+Press Ctrl+C to stop
+```
+
 ---
 
 ## Platform Safety

Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,6 @@ use aof_triggers::{`
`23`	`23`	`};`
`24`	`24`	`use serde::{Deserialize, Serialize};`
`25`	`25`	`use tokio::sync::RwLock;`
`26`		`-use tracing::{info, warn, error};`
`27`	`26`
`28`	`27`	`/// Server configuration loaded from YAML`
`29`	`28`	`#[derive(Debug, Clone, Serialize, Deserialize)]`
`@@ -309,7 +308,7 @@ pub async fn execute(`
`309`	`308`	`) -> anyhow::Result<()> {`
`310`	`309`	`// Load configuration`
`311`	`310`	`let config = if let Some(config_path) = config_file {`
`312`		`- info!("Loading configuration from: {}", config_path);`
	`311`	`+ println!("Loading configuration from: {}", config_path);`
`313`	`312`	`let content = std::fs::read_to_string(config_path)?;`
`314`	`313`	`serde_yaml::from_str::<ServeConfig>(&content)?`
`315`	`314`	`} else {`
`@@ -351,8 +350,8 @@ pub async fn execute(`
`351`	`350`	`.parse()`
`352`	`351`	`.map_err(\|e\| anyhow::anyhow!("Invalid bind address: {}", e))?;`
`353`	`352`
`354`		`- info!("Starting AOF Trigger Server");`
`355`		`- info!(" Bind address: {}", bind_addr);`
	`353`	`+ println!("Starting AOF Trigger Server");`
	`354`	`+ println!(" Bind address: {}", bind_addr);`
`356`	`355`
`357`	`356`	`// Create runtime orchestrator`
`358`	`357`	`let orchestrator = Arc::new(`
`@@ -370,7 +369,7 @@ pub async fn execute(`
`370`	`369`	`};`
`371`	`370`
`372`	`371`	`if let Some(ref agent) = config.spec.runtime.default_agent {`
`373`		`- info!(" Default agent for natural language: {}", agent);`
	`372`	`+ println!(" Default agent for natural language: {}", agent);`
`374`	`373`	`}`
`375`	`374`
`376`	`375`	`// Create trigger handler`
`@@ -408,15 +407,15 @@ pub async fn execute(`
`408`	`407`	`match SlackPlatform::new_with_auto_detection(platform_config).await {`
`409`	`408`	`Ok(platform) => {`
`410`	`409`	`handler.register_platform(Arc::new(platform));`
`411`		`- info!(" Registered platform: slack");`
	`410`	`+ println!(" Registered platform: slack");`
`412`	`411`	`platforms_registered += 1;`
`413`	`412`	`}`
`414`	`413`	`Err(e) => {`
`415`		`- warn!(" Failed to create Slack platform: {}", e);`
	`414`	`+ eprintln!(" Failed to create Slack platform: {}", e);`
`416`	`415`	`}`
`417`	`416`	`}`
`418`	`417`	`} else {`
`419`		`- warn!(" Slack enabled but missing bot_token or signing_secret");`
	`418`	`+ eprintln!(" Slack enabled but missing bot_token or signing_secret");`
`420`	`419`	`}`
`421`	`420`	`}`
`422`	`421`	`}`
`@@ -438,10 +437,10 @@ pub async fn execute(`
`438`	`437`	`};`
`439`	`438`	`let platform = Arc::new(DiscordPlatform::new(platform_config));`
`440`	`439`	`handler.register_platform(platform);`
`441`		`- info!(" Registered platform: discord");`
	`440`	`+ println!(" Registered platform: discord");`
`442`	`441`	`platforms_registered += 1;`
`443`	`442`	`} else {`
`444`		`- warn!(" Discord enabled but missing bot_token");`
	`443`	`+ eprintln!(" Discord enabled but missing bot_token");`
`445`	`444`	`}`
`446`	`445`	`}`
`447`	`446`	`}`
`@@ -466,15 +465,15 @@ pub async fn execute(`
`466`	`465`	`match TelegramPlatform::new(platform_config) {`
`467`	`466`	`Ok(platform) => {`
`468`	`467`	`handler.register_platform(Arc::new(platform));`
`469`		`- info!(" Registered platform: telegram");`
	`468`	`+ println!(" Registered platform: telegram");`
`470`	`469`	`platforms_registered += 1;`
`471`	`470`	`}`
`472`	`471`	`Err(e) => {`
`473`		`- warn!(" Failed to create Telegram platform: {}", e);`
	`472`	`+ eprintln!(" Failed to create Telegram platform: {}", e);`
`474`	`473`	`}`
`475`	`474`	`}`
`476`	`475`	`} else {`
`477`		`- warn!(" Telegram enabled but missing bot_token");`
	`476`	`+ eprintln!(" Telegram enabled but missing bot_token");`
`478`	`477`	`}`
`479`	`478`	`}`
`480`	`479`	`}`
`@@ -500,15 +499,15 @@ pub async fn execute(`
`500`	`499`	`match WhatsAppPlatform::new(platform_config) {`
`501`	`500`	`Ok(platform) => {`
`502`	`501`	`handler.register_platform(Arc::new(platform));`
`503`		`- info!(" Registered platform: whatsapp");`
	`502`	`+ println!(" Registered platform: whatsapp");`
`504`	`503`	`platforms_registered += 1;`
`505`	`504`	`}`
`506`	`505`	`Err(e) => {`
`507`		`- warn!(" Failed to create WhatsApp platform: {}", e);`
	`506`	`+ eprintln!(" Failed to create WhatsApp platform: {}", e);`
`508`	`507`	`}`
`509`	`508`	`}`
`510`	`509`	`} else {`
`511`		`- warn!(" WhatsApp enabled but missing access_token");`
	`510`	`+ eprintln!(" WhatsApp enabled but missing access_token");`
`512`	`511`	`}`
`513`	`512`	`}`
`514`	`513`	`}`
`@@ -519,13 +518,13 @@ pub async fn execute(`
`519`	`518`	`.or_else(\|\| config.spec.triggers.directory.clone());`
`520`	`519`
`521`	`520`	`if let Some(ref triggers_path) = triggers_dir_path {`
`522`		`- info!("Loading Triggers from: {}", triggers_path.display());`
	`521`	`+ println!("Loading Triggers from: {}", triggers_path.display());`
`523`	`522`	`let mut trigger_registry = TriggerRegistry::new();`
`524`	`523`
`525`	`524`	`match trigger_registry.load_directory(triggers_path) {`
`526`	`525`	`Ok(count) => {`
`527`	`526`	`if count > 0 {`
`528`		`- info!(" Loaded {} triggers: {:?}", count, trigger_registry.names());`
	`527`	`+ println!(" Loaded {} triggers: {:?}", count, trigger_registry.names());`
`529`	`528`
`530`	`529`	`// Register platforms for each trigger type`
`531`	`530`	`for trigger in trigger_registry.get_all() {`
`@@ -539,7 +538,7 @@ pub async fn execute(`
`539`	`538`	`.unwrap_or_default();`
`540`	`539`
`541`	`540`	`if token.is_empty() {`
`542`		`- warn!(" GitHub trigger '{}': GITHUB_TOKEN not set, API features disabled", trigger.name());`
	`541`	`+ eprintln!(" GitHub trigger '{}': GITHUB_TOKEN not set, API features disabled", trigger.name());`
`543`	`542`	`}`
`544`	`543`
`545`	`544`	`let github_config = GitHubConfig {`
`@@ -558,15 +557,15 @@ pub async fn execute(`
`558`	`557`	`match GitHubPlatform::new(github_config) {`
`559`	`558`	`Ok(platform) => {`
`560`	`559`	`handler.register_platform(Arc::new(platform));`
`561`		`- info!(" Registered platform: github (from trigger '{}')", trigger.name());`
	`560`	`+ println!(" Registered platform: github (from trigger '{}')", trigger.name());`
`562`	`561`	`platforms_registered += 1;`
`563`	`562`	`}`
`564`	`563`	`Err(e) => {`
`565`		`- warn!(" Failed to create GitHub platform: {}", e);`
	`564`	`+ eprintln!(" Failed to create GitHub platform: {}", e);`
`566`	`565`	`}`
`567`	`566`	`}`
`568`	`567`	`} else {`
`569`		`- warn!(" GitHub trigger '{}' missing webhook_secret", trigger.name());`
	`568`	`+ eprintln!(" GitHub trigger '{}' missing webhook_secret", trigger.name());`
`570`	`569`	`}`
`571`	`570`	`}`
`572`	`571`	`// Other trigger types use platforms registered from config`
`@@ -588,32 +587,32 @@ pub async fn execute(`
`588`	`587`	`handler.register_command_binding(cmd_name.clone(), handler_binding);`
`589`	`588`
`590`	`589`	`if let Some(ref agent) = binding.agent {`
`591`		`- info!(" Registered command '{}' -> agent '{}'", cmd, agent);`
	`590`	`+ println!(" Registered command '{}' -> agent '{}'", cmd, agent);`
`592`	`591`	`} else if let Some(ref fleet) = binding.fleet {`
`593`		`- info!(" Registered command '{}' -> fleet '{}'", cmd, fleet);`
	`592`	`+ println!(" Registered command '{}' -> fleet '{}'", cmd, fleet);`
`594`	`593`	`} else if let Some(ref flow) = binding.flow {`
`595`		`- info!(" Registered command '{}' -> flow '{}'", cmd, flow);`
	`594`	`+ println!(" Registered command '{}' -> flow '{}'", cmd, flow);`
`596`	`595`	`}`
`597`	`596`	`}`
`598`	`597`
`599`	`598`	`// Set default agent if specified in trigger`
`600`	`599`	`if let Some(ref default_agent) = trigger.spec.default_agent {`
`601`		`- info!(" Default agent for trigger '{}': {}", trigger.name(), default_agent);`
	`600`	`+ println!(" Default agent for trigger '{}': {}", trigger.name(), default_agent);`
`602`	`601`	`}`
`603`	`602`	`}`
`604`	`603`	`} else {`
`605`		`- info!(" No Trigger files found in {}", triggers_path.display());`
	`604`	`+ println!(" No Trigger files found in {}", triggers_path.display());`
`606`	`605`	`}`
`607`	`606`	`}`
`608`	`607`	`Err(e) => {`
`609`		`- warn!(" Failed to load triggers from {}: {}", triggers_path.display(), e);`
	`608`	`+ eprintln!(" Failed to load triggers from {}: {}", triggers_path.display(), e);`
`610`	`609`	`}`
`611`	`610`	`}`
`612`	`611`	`}`
`613`	`612`
`614`	`613`	`if platforms_registered == 0 {`
`615`		`- warn!("No platforms registered! Server will start but won't process any webhooks.");`
`616`		`- warn!("Configure platforms in your config file or set environment variables.");`
	`614`	`+ eprintln!("Warning: No platforms registered! Server will start but won't process any webhooks.");`
	`615`	`+ eprintln!("Configure platforms in your config file or set environment variables.");`
`617`	`616`	`}`
`618`	`617`
`619`	`618`	`// Load AgentFlows and set up FlowRouter`
`@@ -626,7 +625,7 @@ pub async fn execute(`
`626`	`625`
`627`	`626`	`if config.spec.flows.enabled {`
`628`	`627`	`if let Some(ref flows_path) = flows_dir_path {`
`629`		`- info!("Loading AgentFlows from: {}", flows_path.display());`
	`628`	`+ println!("Loading AgentFlows from: {}", flows_path.display());`
`630`	`629`
`631`	`630`	`match FlowRegistry::from_directory(flows_path).await {`
`632`	`631`	`Ok(registry) => {`
`@@ -653,27 +652,27 @@ pub async fn execute(`
`653`	`652`	`if let Some(ref ap) = agents_path {`
`654`	`653`	`match handler.load_agents_from_directory(ap).await {`
`655`	`654`	`Ok(count) => {`
`656`		`- info!(" Pre-loaded {} agents from {:?}", count, ap);`
	`655`	`+ println!(" Pre-loaded {} agents from {:?}", count, ap);`
`657`	`656`	`agents_loaded = true;`
`658`	`657`	`}`
`659`		`- Err(e) => warn!(" Failed to pre-load agents: {}", e),`
	`658`	`+ Err(e) => eprintln!(" Failed to pre-load agents: {}", e),`
`660`	`659`	`}`
`661`	`660`	`}`
`662`	`661`
`663`		`- info!(" Loaded {} AgentFlows: {:?}", flow_count, flow_names);`
	`662`	`+ println!(" Loaded {} AgentFlows: {:?}", flow_count, flow_names);`
`664`	`663`	`} else {`
`665`		`- info!(" No AgentFlow files found in {}", flows_path.display());`
	`664`	`+ println!(" No AgentFlow files found in {}", flows_path.display());`
`666`	`665`	`}`
`667`	`666`	`}`
`668`	`667`	`Err(e) => {`
`669`		`- warn!(" Failed to load AgentFlows from {}: {}", flows_path.display(), e);`
	`668`	`+ eprintln!(" Failed to load AgentFlows from {}: {}", flows_path.display(), e);`
`670`	`669`	`}`
`671`	`670`	`}`
`672`	`671`	`} else {`
`673`		`- info!(" No flows directory configured - using default agent routing");`
	`672`	`+ println!(" No flows directory configured - using default agent routing");`
`674`	`673`	`}`
`675`	`674`	`} else {`
`676`		`- info!(" Flow-based routing disabled");`
	`675`	`+ println!(" Flow-based routing disabled");`
`677`	`676`	`}`
`678`	`677`
`679`	`678`	`// Pre-load agents from directory if not already done`
`@@ -687,8 +686,8 @@ pub async fn execute(`
`687`	`686`	`let runtime = Arc::new(RwLock::new(Runtime::new()));`
`688`	`687`	`handler.set_runtime(runtime);`
`689`	`688`	`match handler.load_agents_from_directory(ap).await {`
`690`		`- Ok(count) => info!(" Pre-loaded {} agents from {:?}", count, ap),`
`691`		`- Err(e) => warn!(" Failed to pre-load agents: {}", e),`
	`689`	`+ Ok(count) => println!(" Pre-loaded {} agents from {:?}", count, ap),`
	`690`	`+ Err(e) => eprintln!(" Failed to pre-load agents: {}", e),`
`692`	`691`	`}`
`693`	`692`	`}`
`694`	`693`	`}`
`@@ -704,28 +703,28 @@ pub async fn execute(`
`704`	`703`	`// Create and start server`
`705`	`704`	`let server = TriggerServer::with_config(Arc::new(handler), server_config);`
`706`	`705`
`707`		`- info!("Server starting...");`
`708`		`- info!(" Health check: http://{}/health", bind_addr);`
`709`		`- info!(" Webhook endpoint: http://{}/webhook/{{platform}}", bind_addr);`
`710`		`- info!("Press Ctrl+C to stop");`
	`706`	`+ println!("Server starting...");`
	`707`	`+ println!(" Health check: http://{}/health", bind_addr);`
	`708`	`+ println!(" Webhook endpoint: http://{}/webhook/{{platform}}", bind_addr);`
	`709`	`+ println!("Press Ctrl+C to stop");`
`711`	`710`
`712`	`711`	`// Handle graceful shutdown`
`713`	`712`	`let shutdown_signal = async {`
`714`	`713`	`tokio::signal::ctrl_c()`
`715`	`714`	`.await`
`716`	`715`	`.expect("Failed to install Ctrl+C handler");`
`717`		`- info!("Shutdown signal received, stopping server...");`
	`716`	`+ println!("\nShutdown signal received, stopping server...");`
`718`	`717`	`};`
`719`	`718`
`720`	`719`	`tokio::select! {`
`721`	`720`	`result = server.serve() => {`
`722`	`721`	`if let Err(e) = result {`
`723`		`- error!("Server error: {}", e);`
	`722`	`+ eprintln!("Server error: {}", e);`
`724`	`723`	`return Err(anyhow::anyhow!("Server error: {}", e));`
`725`	`724`	`}`
`726`	`725`	`}`
`727`	`726`	`_ = shutdown_signal => {`
`728`		`- info!("Server stopped gracefully");`
	`727`	`+ println!("Server stopped gracefully");`
`729`	`728`	`}`
`730`	`729`	`}`
`731`	`730`