Merge pull request #561 from cloudyli/codex/pr4-transition-gates

feat: extend kanban transition gates

Author: phodal

crates/routa-core/src/models/kanban.rs

@@ -14,6 +14,34 @@ pub enum KanbanTransport {
     A2a,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
+#[serde(rename_all = "lowercase")]
+pub enum KanbanTransitionGateMode {
+    #[default]
+    Blocking,
+    Warning,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct KanbanContractRules {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub require_canonical_story: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub loop_breaker_threshold: Option<i64>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct KanbanDeliveryRules {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub require_committed_changes: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub require_clean_worktree: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub require_pull_request_ready: Option<bool>,
+}
+
 /// Automation configuration for a Kanban column.
 /// When a card is moved to this column, the automation can trigger an agent session.
 #[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq)]
@@ -72,6 +100,24 @@ pub struct KanbanColumnAutomation {
     /// Required task fields before advancing
     #[serde(skip_serializing_if = "Option::is_none")]
     pub required_task_fields: Option<Vec<String>>,
+    /// Canonical story contract requirements
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub contract_rules: Option<KanbanContractRules>,
+    /// Delivery-readiness requirements
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub delivery_rules: Option<KanbanDeliveryRules>,
+    /// Required checked checklist labels before advancing
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub required_checklist: Option<Vec<String>>,
+    /// Require an explicit approved verification verdict before advancing
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub required_human_approval: Option<bool>,
+    /// Declarative validator command that must be represented in verification evidence
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub validator_command: Option<String>,
+    /// Whether unmet transition gates block movement or leave an audit warning
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub gate_mode: Option<KanbanTransitionGateMode>,
     /// Automatically advance card on session success
     #[serde(skip_serializing_if = "Option::is_none")]
     pub auto_advance_on_success: Option<bool>,
@@ -364,6 +410,12 @@ fn build_recommended_automation(
         auto_advance_on_success: Some(auto_advance_on_success),
         required_artifacts: None,
         required_task_fields: None,
+        contract_rules: None,
+        delivery_rules: None,
+        required_checklist: None,
+        required_human_approval: None,
+        validator_command: None,
+        gate_mode: None,
         provider_id: None,
         role: None,
         specialist_id: None,
@@ -580,6 +632,12 @@ pub fn apply_recommended_automation_to_columns(columns: Vec<KanbanColumn>) -> Ve
                                     .or(normalized_recommended.required_artifacts.clone())
                             },
                             required_task_fields: current.required_task_fields,
+                            contract_rules: current.contract_rules,
+                            delivery_rules: current.delivery_rules,
+                            required_checklist: current.required_checklist,
+                            required_human_approval: current.required_human_approval,
+                            validator_command: current.validator_command,
+                            gate_mode: current.gate_mode,
                             auto_advance_on_success: normalized_recommended.auto_advance_on_success,
                         };
 

crates/routa-core/src/models/kanban_config.rs

@@ -4,6 +4,7 @@ use super::kanban::KanbanColumnAutomation;
 
 const VALID_STAGES: &[&str] = &["backlog", "todo", "dev", "review", "blocked", "done"];
 const VALID_TRANSITION_TYPES: &[&str] = &["entry", "exit", "both"];
+const VALID_GATE_MODES: &[&str] = &["blocking", "warning"];
 const VALID_ARTIFACTS: &[&str] = &["screenshot", "test_results", "code_diff"];
 const VALID_REQUIRED_TASK_FIELDS: &[&str] = &[
     "scope",
@@ -134,6 +135,18 @@ impl KanbanConfig {
                             ));
                         }
                     }
+                    if let Some(mode) = &auto.gate_mode {
+                        let mode = match mode {
+                            super::kanban::KanbanTransitionGateMode::Blocking => "blocking",
+                            super::kanban::KanbanTransitionGateMode::Warning => "warning",
+                        };
+                        if !VALID_GATE_MODES.contains(&mode) {
+                            errors.push(format!(
+                                "{auto_prefix}.gateMode '{mode}' is invalid, expected one of: {}",
+                                VALID_GATE_MODES.join(", ")
+                            ));
+                        }
+                    }
                     if let Some(artifacts) = &auto.required_artifacts {
                         for art in artifacts {
                             if !VALID_ARTIFACTS.contains(&art.as_str()) {
@@ -156,6 +169,20 @@ impl KanbanConfig {
                             }
                         }
                     }
+                    if let Some(checklist) = &auto.required_checklist {
+                        for item in checklist {
+                            if item.trim().is_empty() {
+                                errors.push(format!(
+                                    "{auto_prefix}.requiredChecklist contains a blank item"
+                                ));
+                            }
+                        }
+                    }
+                    if let Some(command) = &auto.validator_command {
+                        if command.trim().is_empty() {
+                            errors.push(format!("{auto_prefix}.validatorCommand is blank"));
+                        }
+                    }
                 }
             }
         }
@@ -222,6 +249,11 @@ boards:
           requiredTaskFields:
             - scope
             - verification_plan
+          requiredChecklist:
+            - browser smoke
+          requiredHumanApproval: true
+          validatorCommand: npm test
+          gateMode: warning
           autoAdvanceOnSuccess: false
 "#;
         let config = KanbanConfig::from_yaml(yaml).unwrap();
@@ -231,6 +263,16 @@ boards:
         assert_eq!(auto.provider_id.as_deref(), Some("routa-native"));
         assert_eq!(auto.required_artifacts.as_ref().unwrap().len(), 2);
         assert_eq!(auto.required_task_fields.as_ref().unwrap().len(), 2);
+        assert_eq!(
+            auto.required_checklist.as_ref().unwrap(),
+            &vec!["browser smoke".to_string()]
+        );
+        assert_eq!(auto.required_human_approval, Some(true));
+        assert_eq!(auto.validator_command.as_deref(), Some("npm test"));
+        assert_eq!(
+            auto.gate_mode,
+            Some(super::super::kanban::KanbanTransitionGateMode::Warning)
+        );
         assert!(config.validate().is_ok());
     }