feat: Add progress update emissions to TwoPassDebateWorkflow

Enable real-time status updates for workflow execution via broadcast channel.

Changes:
- Add ProgressUpdate type for status updates
- Add progress_tx field and with_progress_sender() builder method
- Add emit_progress() helper to send status updates
- Emit progress at all workflow milestones

Related: zestic-ai/truthforge#45

Author: Terraphim AI

Cargo.toml

@@ -21,3 +21,6 @@ async-trait = "0.1"
 thiserror = "1.0"
 anyhow = "1.0"
 log = "0.4"
+
+[patch.crates-io]
+genai = { git = "https://github.com/terraphim/rust-genai.git", branch = "main" }

crates/terraphim_truthforge/src/workflows/two_pass_debate.rs

@@ -4,12 +4,26 @@ use crate::agents::omission_detector::{OmissionDetectorAgent, OmissionDetectorCo
 use crate::agents::taxonomy_linker::{TaxonomyLinkerAgent, TaxonomyLinkerConfig};
 use crate::error::{Result, TruthForgeError};
 use crate::types::*;
+use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 use terraphim_multi_agent::{GenAiLlmClient, LlmMessage, LlmRequest};
+use tokio::sync::broadcast;
 use tokio::task::JoinSet;
 use tracing::{debug, info, warn};
 use uuid::Uuid;
 
+/// Progress update for WebSocket streaming
+/// This is a simplified version to avoid cross-repository dependencies
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ProgressUpdate {
+    pub session_id: Uuid,
+    pub pillar: Option<String>,
+    pub stage: String,
+    pub progress: f32,
+    pub message: String,
+    pub timestamp: chrono::DateTime<chrono::Utc>,
+}
+
 enum PassOneAgentResult {
     OmissionCatalog(OmissionCatalog),
     BiasAnalysis(BiasAnalysis),
@@ -724,6 +738,7 @@ pub struct TwoPassDebateWorkflow {
     pass_two: PassTwoOptimizer,
     response_generator: ResponseGenerator,
     llm_client: Option<Arc<GenAiLlmClient>>,
+    progress_tx: Option<broadcast::Sender<ProgressUpdate>>,
 }
 
 impl TwoPassDebateWorkflow {
@@ -733,6 +748,7 @@ impl TwoPassDebateWorkflow {
             pass_two: PassTwoOptimizer::new(),
             response_generator: ResponseGenerator::new(),
             llm_client: None,
+            progress_tx: None,
         }
     }
 
@@ -744,17 +760,67 @@ impl TwoPassDebateWorkflow {
         self
     }
 
+    pub fn with_progress_sender(mut self, tx: broadcast::Sender<ProgressUpdate>) -> Self {
+        self.progress_tx = Some(tx);
+        self
+    }
+
+    fn emit_progress(&self, session_id: Uuid, stage: &str, message: &str, progress: f32) {
+        if let Some(tx) = &self.progress_tx {
+            let update = ProgressUpdate {
+                session_id,
+                pillar: None,
+                stage: stage.to_string(),
+                progress,
+                message: message.to_string(),
+                timestamp: chrono::Utc::now(),
+            };
+            let _ = tx.send(update);
+        }
+    }
+
     pub async fn execute(&self, narrative: &NarrativeInput) -> Result<TruthForgeAnalysisResult> {
         let start_time = std::time::Instant::now();
 
         info!(
             "Starting TwoPassDebateWorkflow for session {}",
             narrative.session_id
         );
+        self.emit_progress(
+            narrative.session_id,
+            "workflow_start",
+            "Starting TwoPassDebateWorkflow",
+            0.0,
+        );
+
+        self.emit_progress(
+            narrative.session_id,
+            "pass_1_start",
+            "Starting Pass 1 Orchestration",
+            0.1,
+        );
 
         let pass_one_result = self.pass_one.execute(narrative).await?;
 
+        let omissions_count = pass_one_result.omission_catalog.omissions.len();
+        self.emit_progress(
+            narrative.session_id,
+            "pass_1_complete",
+            &format!(
+                "Pass 1: Analysis complete, {} omissions identified",
+                omissions_count
+            ),
+            0.4,
+        );
+
         info!("Pass 1 complete, generating Pass 1 debate");
+        self.emit_progress(
+            narrative.session_id,
+            "pass_1_debate",
+            "Generating Pass 1 debate",
+            0.45,
+        );
+
         let pass_one_debate = if self.llm_client.is_some() {
             self.generate_pass_one_debate(narrative, &pass_one_result)
                 .await?
@@ -764,15 +830,29 @@ impl TwoPassDebateWorkflow {
         };
 
         info!("Pass 1 debate complete, starting Pass 2 exploitation");
+        self.emit_progress(
+            narrative.session_id,
+            "pass_2_start",
+            "Pass 1 debate complete, starting Pass 2 exploitation",
+            0.5,
+        );
+
         let pass_two_result = self
             .pass_two
             .execute(narrative, &pass_one_result, &pass_one_debate)
             .await?;
 
         info!("Pass 2 complete, generating cumulative analysis");
-
-        let omissions_count = pass_one_result.omission_catalog.omissions.len();
         let exploited_count = pass_two_result.exploited_vulnerabilities.len();
+        self.emit_progress(
+            narrative.session_id,
+            "pass_2_complete",
+            &format!(
+                "Pass 2 complete, {} vulnerabilities identified",
+                exploited_count
+            ),
+            0.7,
+        );
 
         let cumulative_analysis = self
             .generate_cumulative_analysis_mock(
@@ -785,6 +865,13 @@ impl TwoPassDebateWorkflow {
         let risk_level = cumulative_analysis.strategic_risk_level.clone();
 
         info!("Cumulative analysis complete, generating response strategies");
+        self.emit_progress(
+            narrative.session_id,
+            "response_generation",
+            "Generating response strategies",
+            0.8,
+        );
+
         let response_strategies = self
             .response_generator
             .generate_strategies(
@@ -798,6 +885,15 @@ impl TwoPassDebateWorkflow {
             "Response strategies generated: {} strategies",
             response_strategies.len()
         );
+        self.emit_progress(
+            narrative.session_id,
+            "strategies_complete",
+            &format!(
+                "Response strategies generated: {} strategies",
+                response_strategies.len()
+            ),
+            0.9,
+        );
 
         let result = TruthForgeAnalysisResult {
             session_id: narrative.session_id,
@@ -824,6 +920,15 @@ impl TwoPassDebateWorkflow {
             "TwoPassDebateWorkflow complete for session {} in {}ms",
             narrative.session_id, result.processing_time_ms
         );
+        self.emit_progress(
+            narrative.session_id,
+            "workflow_complete",
+            &format!(
+                "TwoPassDebateWorkflow complete in {}ms",
+                result.processing_time_ms
+            ),
+            1.0,
+        );
 
         Ok(result)
     }