@pheem49/mint 1.16.0 → 1.17.0

package/crates/mint-core/src/orchestration/trajectory_schema.rs

@@ -0,0 +1,353 @@
+//! Standardized Trajectory Schema v1.0
+//!
+//! Provides a typed, versioned schema for agent execution trajectories compliant with
+//! SWE-bench and OpenTelemetry / Agent Protocol standards. Facilitates deterministic
+//! session replays, benchmark evaluations, and multi-platform telemetry export.
+
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+use super::AgentProgress;
+
+/// Token usage metadata for an individual trajectory step.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct StepTokens {
+    #[serde(default)]
+    pub input_tokens: u64,
+    #[serde(default)]
+    pub generated_tokens: u64,
+}
+
+/// A discrete, typed execution step within an agent run.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct StandardTrajectoryStep {
+    /// 1-based step counter
+    pub step: usize,
+    /// RFC3339 timestamp of step completion
+    pub timestamp: String,
+    /// Model reasoning or thought preceding action
+    pub thought: String,
+    /// Tool or action invoked (e.g. "apply_patch", "run_shell", "finish")
+    pub action: String,
+    /// Canonical JSON arguments supplied to the action
+    pub input: Value,
+    /// Observation returned by environment / harness
+    pub observation: String,
+    /// Step outcome status ("success", "failed", "intercepted", "skipped")
+    pub status: String,
+    /// Wall-clock execution duration in milliseconds
+    pub duration_ms: u64,
+    /// Step token metrics
+    pub tokens: StepTokens,
+}
+
+/// Complete execution trajectory for an agent run, compliant with SWE-bench & Agent Protocol v1.0.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct StandardTrajectoryRun {
+    /// Schema version, e.g. "1.0"
+    pub schema_version: String,
+    /// Unique identifier for this run
+    pub run_id: String,
+    /// Chat session identifier
+    pub chat_id: String,
+    /// High-level user prompt or task specification
+    pub task: String,
+    /// Active model name
+    pub model: String,
+    /// Model provider name
+    pub provider: String,
+    /// RFC3339 timestamp when run started
+    pub started_at: String,
+    /// RFC3339 timestamp when run finished
+    pub completed_at: String,
+    /// Final status outcome ("SUCCESS", "VERIFIED", "PARTIAL", "FAILED", "ROLLED_BACK")
+    pub outcome: String,
+    /// Total number of steps executed
+    pub total_steps: usize,
+    /// Total tokens consumed across all steps
+    pub total_tokens: u64,
+    /// Wall-clock duration in seconds
+    pub duration_secs: f64,
+    /// List of file paths created during the run
+    pub files_created: Vec<String>,
+    /// List of file paths modified during the run
+    pub files_modified: Vec<String>,
+    /// Chronological list of steps executed
+    pub trajectory: Vec<StandardTrajectoryStep>,
+}
+
+impl StandardTrajectoryRun {
+    /// Initializes a new StandardTrajectoryRun with default 1.0 schema version.
+    pub fn new(
+        run_id: impl Into<String>,
+        chat_id: impl Into<String>,
+        task: impl Into<String>,
+        model: impl Into<String>,
+        provider: impl Into<String>,
+    ) -> Self {
+        let now = chrono::Utc::now().to_rfc3339();
+        Self {
+            schema_version: "1.0".to_string(),
+            run_id: run_id.into(),
+            chat_id: chat_id.into(),
+            task: task.into(),
+            model: model.into(),
+            provider: provider.into(),
+            started_at: now.clone(),
+            completed_at: now,
+            outcome: "PENDING".to_string(),
+            total_steps: 0,
+            total_tokens: 0,
+            duration_secs: 0.0,
+            files_created: Vec::new(),
+            files_modified: Vec::new(),
+            trajectory: Vec::new(),
+        }
+    }
+
+    /// Records an executed trajectory step and updates total_steps.
+    pub fn record_step(&mut self, step: StandardTrajectoryStep) {
+        self.trajectory.push(step);
+        self.total_steps = self.trajectory.len();
+    }
+
+    /// Finalizes the trajectory run metadata upon completion.
+    pub fn finish(
+        &mut self,
+        outcome: impl Into<String>,
+        total_tokens: u64,
+        duration_secs: f64,
+        files_created: Vec<String>,
+        files_modified: Vec<String>,
+    ) {
+        self.outcome = outcome.into();
+        self.total_tokens = total_tokens;
+        self.duration_secs = duration_secs;
+        self.files_created = files_created;
+        self.files_modified = files_modified;
+        self.completed_at = chrono::Utc::now().to_rfc3339();
+        self.total_steps = self.trajectory.len();
+    }
+
+    /// Serializes the run into SWE-bench compliant pretty-printed JSON.
+    pub fn to_json_pretty(&self) -> Result<String, serde_json::Error> {
+        serde_json::to_string_pretty(self)
+    }
+
+    /// Deserializes a run from JSON.
+    pub fn from_json(json: &str) -> Result<Self, serde_json::Error> {
+        serde_json::from_str(json)
+    }
+
+    /// Reconstructs a `StandardTrajectoryRun` from an event stream (`AgentProgress`).
+    /// Useful for historical runs or external consumers where only events were preserved.
+    pub fn from_agent_activity(
+        chat_id: &str,
+        run_id: &str,
+        task: &str,
+        model: &str,
+        provider: &str,
+        events: &[AgentProgress],
+    ) -> Self {
+        // First check if a RunCompleted event already has an embedded trajectory
+        for event in events {
+            if let AgentProgress::RunCompleted { summary } = event {
+                if let Some(existing) = &summary.trajectory {
+                    return existing.clone();
+                }
+            }
+        }
+
+        let mut run = Self::new(run_id, chat_id, task, model, provider);
+        let mut latest_thought = String::new();
+        let mut step_counter = 1;
+
+        for event in events {
+            match event {
+                AgentProgress::Thought { thought } => {
+                    latest_thought = thought.clone();
+                }
+                AgentProgress::ExtendedThinking { thought, .. } => {
+                    latest_thought = thought.clone();
+                }
+                AgentProgress::ToolEnd {
+                    action,
+                    input,
+                    result,
+                    elapsed_ms,
+                    status,
+                    ..
+                } => {
+                    let status_str = match status {
+                        Some(crate::integrations::mcp_result::ToolStatus::Success) => "success",
+                        Some(crate::integrations::mcp_result::ToolStatus::Failed) => "failed",
+                        Some(crate::integrations::mcp_result::ToolStatus::TimedOut) => "timed_out",
+                        Some(crate::integrations::mcp_result::ToolStatus::Cancelled) => "cancelled",
+                        Some(crate::integrations::mcp_result::ToolStatus::Skipped) => "skipped",
+                        _ => {
+                            if result.starts_with("Error") || result.contains("failed") {
+                                "failed"
+                            } else {
+                                "success"
+                            }
+                        }
+                    };
+
+                    run.record_step(StandardTrajectoryStep {
+                        step: step_counter,
+                        timestamp: chrono::Utc::now().to_rfc3339(),
+                        thought: std::mem::take(&mut latest_thought),
+                        action: action.clone(),
+                        input: input.clone(),
+                        observation: result.clone(),
+                        status: status_str.to_string(),
+                        duration_ms: elapsed_ms.unwrap_or(0),
+                        tokens: StepTokens::default(),
+                    });
+                    step_counter += 1;
+                }
+                AgentProgress::RunCompleted { summary } => {
+                    if !summary.run_id.is_empty() {
+                        run.run_id = summary.run_id.clone();
+                    }
+                    if !summary.task.is_empty() {
+                        run.task = summary.task.clone();
+                    }
+                    run.finish(
+                        &summary.outcome,
+                        summary.total_tokens as u64,
+                        summary.duration_secs,
+                        summary.files_created.clone(),
+                        summary.files_changed.clone(),
+                    );
+                }
+                _ => {}
+            }
+        }
+
+        run
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn serializes_canonical_v1_schema() {
+        let mut run = StandardTrajectoryRun::new(
+            "run-101",
+            "chat-abc",
+            "Fix bug in parser",
+            "claude-3-7-sonnet",
+            "anthropic",
+        );
+        run.record_step(StandardTrajectoryStep {
+            step: 1,
+            timestamp: "2026-10-26T12:00:00Z".to_string(),
+            thought: "I need to inspect the parser code".to_string(),
+            action: "read_file".to_string(),
+            input: json!({"path": "src/parser.rs"}),
+            observation: "pub fn parse() {}".to_string(),
+            status: "success".to_string(),
+            duration_ms: 125,
+            tokens: StepTokens {
+                input_tokens: 1500,
+                generated_tokens: 65,
+            },
+        });
+        run.finish(
+            "SUCCESS",
+            1565,
+            2.5,
+            vec![],
+            vec!["src/parser.rs".to_string()],
+        );
+
+        let json = run.to_json_pretty().expect("must serialize");
+        assert!(json.contains("\"schemaVersion\": \"1.0\""));
+        assert!(json.contains("\"runId\": \"run-101\""));
+        assert!(json.contains("\"chatId\": \"chat-abc\""));
+        assert!(json.contains("\"inputTokens\": 1500"));
+        assert!(json.contains("\"durationMs\": 125"));
+        assert!(json.contains("\"outcome\": \"SUCCESS\""));
+    }
+
+    #[test]
+    fn roundtrip_json_parity() {
+        let mut run =
+            StandardTrajectoryRun::new("run-202", "chat-xyz", "Add feature", "gpt-4o", "openai");
+        run.record_step(StandardTrajectoryStep {
+            step: 1,
+            timestamp: "2026-10-26T12:01:00Z".to_string(),
+            thought: "Checking dir".to_string(),
+            action: "list_files".to_string(),
+            input: json!({"path": "."}),
+            observation: "Cargo.toml\nsrc/".to_string(),
+            status: "success".to_string(),
+            duration_ms: 42,
+            tokens: StepTokens::default(),
+        });
+        run.finish("VERIFIED", 300, 1.2, vec!["Cargo.toml".to_string()], vec![]);
+
+        let json_str = run.to_json_pretty().expect("must serialize");
+        let parsed = StandardTrajectoryRun::from_json(&json_str).expect("must deserialize");
+        assert_eq!(run, parsed);
+    }
+
+    #[test]
+    fn reconstructs_from_agent_activity() {
+        let events = vec![
+            AgentProgress::Thought {
+                thought: "Locating function".to_string(),
+            },
+            AgentProgress::ToolEnd {
+                call_id: Some("call-1".to_string()),
+                action: "grep".to_string(),
+                input: json!({"query": "fn test"}),
+                result: "src/lib.rs:10: fn test()".to_string(),
+                status: Some(crate::integrations::mcp_result::ToolStatus::Success),
+                elapsed_ms: Some(85),
+                subagent: None,
+            },
+            AgentProgress::RunCompleted {
+                summary: crate::orchestration::RunTelemetrySummary {
+                    run_id: "run-303".to_string(),
+                    task: "Find function".to_string(),
+                    outcome: "SUCCESS".to_string(),
+                    total_tokens: 1200,
+                    tool_calls_count: 1,
+                    files_changed: vec![],
+                    files_created: vec![],
+                    duration_secs: 1.5,
+                    tool_timeline: vec![],
+                    retries_count: 0,
+                    trajectory: None,
+                },
+            },
+        ];
+
+        let run = StandardTrajectoryRun::from_agent_activity(
+            "chat-999",
+            "run-303",
+            "Find function",
+            "gemini-2.5-pro",
+            "google",
+            &events,
+        );
+
+        assert_eq!(run.schema_version, "1.0");
+        assert_eq!(run.run_id, "run-303");
+        assert_eq!(run.chat_id, "chat-999");
+        assert_eq!(run.outcome, "SUCCESS");
+        assert_eq!(run.total_steps, 1);
+        assert_eq!(run.trajectory[0].action, "grep");
+        assert_eq!(run.trajectory[0].thought, "Locating function");
+        assert_eq!(run.trajectory[0].duration_ms, 85);
+        assert_eq!(run.trajectory[0].status, "success");
+    }
+}

package/crates/mint-core/src/orchestration/truncation.rs

@@ -0,0 +1,211 @@
+//! Line-aware Head-Tail Observation Truncation Harness
+//!
+//! Preserves the top execution context (command invocation, parameters, early progress)
+//! and trailing execution context (stack traces, compiler errors, exit summaries)
+//! while omitting intermediate verbose output with a structured diagnostic banner.
+
+/// Configuration bounds for head-tail truncation.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct TruncationConfig {
+    /// Maximum total characters permitted in the output (including banner).
+    pub max_total_chars: usize,
+    /// Maximum line count threshold before line-based truncation triggers.
+    pub max_total_lines: usize,
+    /// Number of initial lines to preserve from the beginning of output.
+    pub head_lines: usize,
+    /// Number of trailing lines to preserve from the end of output.
+    pub tail_lines: usize,
+}
+
+impl Default for TruncationConfig {
+    fn default() -> Self {
+        Self {
+            max_total_chars: 8_000,
+            max_total_lines: 150,
+            head_lines: 35,
+            tail_lines: 75,
+        }
+    }
+}
+
+impl TruncationConfig {
+    /// Compact configuration for text-rendered context previews and transcript exports.
+    pub const COMPACT: Self = Self {
+        max_total_chars: 2_500,
+        max_total_lines: 60,
+        head_lines: 15,
+        tail_lines: 35,
+    };
+}
+
+/// Truncates `text` using an industry-standard line-aware Head-Tail strategy.
+///
+/// If `text` fits within both `max_total_chars` and `max_total_lines`, it is returned unchanged.
+/// Otherwise, the first `head_lines` and last `tail_lines` are preserved, separated by a
+/// clear omission marker indicating the omitted line and character counts.
+pub fn head_tail_truncate(text: &str, config: TruncationConfig) -> String {
+    if text.is_empty() {
+        return String::new();
+    }
+
+    let char_count = text.chars().count();
+    let lines: Vec<&str> = text.lines().collect();
+    let total_lines = lines.len();
+
+    // Fast path: text is already within both character and line bounds
+    if char_count <= config.max_total_chars && total_lines <= config.max_total_lines {
+        return text.to_owned();
+    }
+
+    // If total lines are fewer than or equal to head + tail, but char count is still exceeded,
+    // we perform character-based head-tail truncation.
+    if total_lines <= config.head_lines + config.tail_lines {
+        return char_head_tail_truncate(text, config.max_total_chars);
+    }
+
+    let head_count = config.head_lines.min(total_lines);
+    let tail_count = config
+        .tail_lines
+        .min(total_lines.saturating_sub(head_count));
+    let omitted_lines = total_lines.saturating_sub(head_count + tail_count);
+
+    let head_text = lines[..head_count].join("\n");
+    let tail_text = lines[total_lines - tail_count..].join("\n");
+
+    let omitted_chars =
+        char_count.saturating_sub(head_text.chars().count() + tail_text.chars().count());
+
+    let banner = format!(
+        "\n\n[... Truncated {omitted_lines} lines ({omitted_chars} chars) to preserve context window — showing initial {head_count} and trailing {tail_count} lines ...]\n\n"
+    );
+
+    let combined_chars =
+        head_text.chars().count() + banner.chars().count() + tail_text.chars().count();
+    if combined_chars <= config.max_total_chars {
+        let mut result = String::with_capacity(head_text.len() + banner.len() + tail_text.len());
+        result.push_str(&head_text);
+        result.push_str(&banner);
+        result.push_str(&tail_text);
+        result
+    } else {
+        // If head + banner + tail still exceeds char limit, enforce character budget on the combined text
+        let remaining_for_tail = config
+            .max_total_chars
+            .saturating_sub(head_text.chars().count() + banner.chars().count());
+        let trimmed_tail: String = if remaining_for_tail > 0 {
+            // Keep the very end of tail
+            let tail_chars_count = tail_text.chars().count();
+            let skip_chars = tail_chars_count.saturating_sub(remaining_for_tail);
+            tail_text.chars().skip(skip_chars).collect()
+        } else {
+            String::new()
+        };
+
+        let mut result = String::with_capacity(head_text.len() + banner.len() + trimmed_tail.len());
+        result.push_str(&head_text);
+        result.push_str(&banner);
+        result.push_str(&trimmed_tail);
+        result
+    }
+}
+
+/// Fallback character-based head-tail truncation when line count is small but individual lines are huge.
+fn char_head_tail_truncate(text: &str, max_chars: usize) -> String {
+    let char_count = text.chars().count();
+    if char_count <= max_chars {
+        return text.to_owned();
+    }
+
+    let head_budget = (max_chars / 3).min(1_000);
+    let head: String = text.chars().take(head_budget).collect();
+
+    let banner_placeholder_len = 100;
+    let tail_budget = max_chars.saturating_sub(head_budget + banner_placeholder_len);
+    let skip_count = char_count.saturating_sub(tail_budget);
+    let tail: String = text.chars().skip(skip_count).collect();
+
+    let omitted_chars = char_count.saturating_sub(head.chars().count() + tail.chars().count());
+    let banner = format!(
+        "\n\n[... Truncated {omitted_chars} chars to preserve context window — showing head and tail ...]\n\n"
+    );
+
+    let mut result = String::with_capacity(head.len() + banner.len() + tail.len());
+    result.push_str(&head);
+    result.push_str(&banner);
+    result.push_str(&tail);
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn leaves_short_text_untouched() {
+        let short = "Line 1\nLine 2\nLine 3";
+        assert_eq!(
+            head_tail_truncate(short, TruncationConfig::default()),
+            short
+        );
+    }
+
+    #[test]
+    fn truncates_oversized_line_counts_preserving_head_and_tail() {
+        let mut lines = Vec::new();
+        for i in 1..=300 {
+            lines.push(format!("Step log line {i}: details here"));
+        }
+        let input = lines.join("\n");
+
+        let config = TruncationConfig {
+            max_total_chars: 10_000,
+            max_total_lines: 100,
+            head_lines: 10,
+            tail_lines: 20,
+        };
+
+        let result = head_tail_truncate(&input, config);
+        assert!(result.starts_with("Step log line 1:"));
+        assert!(result.contains("Step log line 10:"));
+        assert!(result.contains("Truncated 270 lines"));
+        assert!(result.contains("Step log line 281:"));
+        assert!(result.ends_with("Step log line 300: details here"));
+    }
+
+    #[test]
+    fn preserves_utf8_multibyte_safety() {
+        let thai_line = "การทำงานขั้นตอนที่สำคัญมากสำหรับการทดสอบระบบ";
+        let mut lines = Vec::new();
+        for i in 1..=200 {
+            lines.push(format!("{i}. {thai_line}"));
+        }
+        let input = lines.join("\n");
+
+        let config = TruncationConfig {
+            max_total_chars: 2_000,
+            max_total_lines: 50,
+            head_lines: 5,
+            tail_lines: 5,
+        };
+
+        let result = head_tail_truncate(&input, config);
+        assert!(result.contains("1. การทำงานขั้นตอน"));
+        assert!(result.contains("200. การทำงานขั้นตอน"));
+        assert!(result.contains("Truncated"));
+    }
+
+    #[test]
+    fn handles_single_huge_line_gracefully() {
+        let huge_line = "x".repeat(15_000);
+        let config = TruncationConfig {
+            max_total_chars: 1_000,
+            max_total_lines: 100,
+            head_lines: 10,
+            tail_lines: 10,
+        };
+
+        let result = head_tail_truncate(&huge_line, config);
+        assert!(result.len() < 2_000);
+        assert!(result.contains("Truncated"));
+    }
+}

package/crates/mint-core/src/orchestration/verification.rs

@@ -13,6 +13,7 @@ pub(super) fn looks_skill_worthy(step: usize, action_counts: &BTreeMap<String, u
         "browser_open",
         "browser_click",
         "browser_type",
+        "dispatch_agents",
         "dispatch_subagent",
     ];
     step >= 3
@@ -25,17 +26,17 @@ pub(super) fn looks_skill_worthy(step: usize, action_counts: &BTreeMap<String, u
 
 /// Whether `finish` should be rejected because the run modified a file
 /// (`apply_patch`/`write_file`) without a subsequent `verify` call and without
-/// an explicit written reason in the `finish` action's `verification` field.
+/// a subsequent check. An explanation cannot stand in for execution evidence.
 pub(super) fn unverified_modification(
     last_modify_step: Option<usize>,
     last_verify_step: Option<usize>,
-    verification_field: &str,
+    _verification_field: &str,
 ) -> bool {
     let Some(modify_step) = last_modify_step else {
         return false;
     };
     let verified_since = last_verify_step.is_some_and(|verify_step| verify_step >= modify_step);
-    !verified_since && meaningful_verification(verification_field).is_empty()
+    !verified_since
 }
 
 /// Whether any `run_shell`/`verify` command in `result` — which may join
@@ -46,7 +47,7 @@ pub(super) fn unverified_modification(
 pub(super) fn shell_result_failed(result: &str) -> bool {
     result.lines().any(|line| {
         line.strip_prefix("exit: ")
-            .is_some_and(|code| !matches!(code.trim(), "0" | "unknown"))
+            .is_some_and(|code| code.trim() != "0")
     })
 }
 
@@ -61,9 +62,9 @@ pub(super) fn shell_result_failed(result: &str) -> bool {
 /// run has nobody watching live to catch it.
 pub(super) fn unacknowledged_verify_failure(
     last_verify_failed: Option<bool>,
-    verification_field: &str,
+    _verification_field: &str,
 ) -> bool {
-    last_verify_failed == Some(true) && meaningful_verification(verification_field).is_empty()
+    last_verify_failed == Some(true)
 }
 
 pub(super) fn meaningful_verification(value: &str) -> &str {
@@ -84,3 +85,32 @@ pub(super) fn meaningful_verification(value: &str) -> &str {
         value
     }
 }
+
+#[cfg(test)]
+mod reliability_regressions {
+    use super::*;
+
+    #[test]
+    fn success_prose_cannot_override_a_failed_check() {
+        assert!(unacknowledged_verify_failure(
+            Some(true),
+            "All tests passed."
+        ));
+    }
+
+    #[test]
+    fn success_prose_cannot_verify_an_unchecked_edit() {
+        assert!(unverified_modification(
+            Some(2),
+            None,
+            "Verified successfully."
+        ));
+    }
+
+    #[test]
+    fn an_unknown_exit_is_not_a_passed_check() {
+        assert!(shell_result_failed(
+            "exit: unknown\nCommand moved to the background"
+        ));
+    }
+}