feat: add tangent mode duration tracking telemetry (#2710)

- Track time spent in tangent mode sessions
- Send duration metric when exiting tangent mode via /tangent command
- Use codewhispererterminal_chatSlashCommandExecuted metric with:
  - command: 'tangent'
  - subcommand: 'exit'
  - value: duration in seconds
- Add comprehensive tests for duration calculation
- Enables analytics on tangent mode usage patterns

Author: abhraina-aws

crates/chat-cli/src/cli/chat/cli/tangent.rs

@@ -18,7 +18,25 @@ pub struct TangentArgs;
 impl TangentArgs {
     pub async fn execute(self, os: &Os, session: &mut ChatSession) -> Result<ChatState, ChatError> {
         if session.conversation.is_in_tangent_mode() {
+            // Get duration before exiting tangent mode
+            let duration_seconds = session.conversation.get_tangent_duration_seconds().unwrap_or(0);
+
             session.conversation.exit_tangent_mode();
+
+            // Send telemetry for tangent mode session
+            if let Err(err) = os
+                .telemetry
+                .send_tangent_mode_session(
+                    &os.database,
+                    session.conversation.conversation_id().to_string(),
+                    crate::telemetry::TelemetryResult::Succeeded,
+                    crate::telemetry::core::TangentModeSessionArgs { duration_seconds },
+                )
+                .await
+            {
+                tracing::warn!(?err, "Failed to send tangent mode session telemetry");
+            }
+
             execute!(
                 session.stderr,
                 style::SetForegroundColor(Color::DarkGrey),
@@ -69,3 +87,43 @@ impl TangentArgs {
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::cli::agent::Agents;
+    use crate::cli::chat::conversation::ConversationState;
+    use crate::cli::chat::tool_manager::ToolManager;
+    use crate::os::Os;
+
+    #[tokio::test]
+    async fn test_tangent_mode_duration_tracking() {
+        let mut os = Os::new().await.unwrap();
+        let agents = Agents::default();
+        let mut tool_manager = ToolManager::default();
+        let mut conversation = ConversationState::new(
+            "test_conv_id",
+            agents,
+            tool_manager.load_tools(&mut os, &mut vec![]).await.unwrap(),
+            tool_manager,
+            None,
+            &os,
+            false, // mcp_enabled
+        )
+        .await;
+
+        // Test entering tangent mode
+        assert!(!conversation.is_in_tangent_mode());
+        conversation.enter_tangent_mode();
+        assert!(conversation.is_in_tangent_mode());
+
+        // Should have a duration
+        let duration = conversation.get_tangent_duration_seconds();
+        assert!(duration.is_some());
+        assert!(duration.unwrap() >= 0);
+
+        // Test exiting tangent mode
+        conversation.exit_tangent_mode();
+        assert!(!conversation.is_in_tangent_mode());
+        assert!(conversation.get_tangent_duration_seconds().is_none());
+    }
+}

crates/chat-cli/src/cli/chat/conversation.rs

@@ -139,6 +139,9 @@ struct ConversationCheckpoint {
     main_next_message: Option<UserMessage>,
     /// Main conversation transcript
     main_transcript: VecDeque<String>,
+    /// Timestamp when tangent mode was entered (milliseconds since epoch)
+    #[serde(default = "time::OffsetDateTime::now_utc")]
+    tangent_start_time: time::OffsetDateTime,
 }
 
 impl ConversationState {
@@ -229,6 +232,7 @@ impl ConversationState {
             main_history: self.history.clone(),
             main_next_message: self.next_message.clone(),
             main_transcript: self.transcript.clone(),
+            tangent_start_time: time::OffsetDateTime::now_utc(),
         }
     }
 
@@ -247,6 +251,14 @@ impl ConversationState {
         }
     }
 
+    /// Get tangent mode duration in seconds if currently in tangent mode
+    pub fn get_tangent_duration_seconds(&self) -> Option<i64> {
+        self.tangent_state.as_ref().map(|checkpoint| {
+            let now = time::OffsetDateTime::now_utc();
+            (now - checkpoint.tangent_start_time).whole_seconds()
+        })
+    }
+
     /// Exit tangent mode - restore from checkpoint
     pub fn exit_tangent_mode(&mut self) {
         if let Some(checkpoint) = self.tangent_state.take() {
@@ -1412,4 +1424,40 @@ mod tests {
         conversation.exit_tangent_mode();
         assert!(!conversation.is_in_tangent_mode());
     }
+
+    #[tokio::test]
+    async fn test_tangent_mode_duration() {
+        let mut os = Os::new().await.unwrap();
+        let agents = Agents::default();
+        let mut tool_manager = ToolManager::default();
+        let mut conversation = ConversationState::new(
+            "fake_conv_id",
+            agents,
+            tool_manager.load_tools(&mut os, &mut vec![]).await.unwrap(),
+            tool_manager,
+            None,
+            &os,
+            false, // mcp_enabled
+        )
+        .await;
+
+        // Initially not in tangent mode, no duration
+        assert!(conversation.get_tangent_duration_seconds().is_none());
+
+        // Enter tangent mode
+        conversation.enter_tangent_mode();
+        assert!(conversation.is_in_tangent_mode());
+
+        // Should have a duration (likely 0 seconds since it just started)
+        let duration = conversation.get_tangent_duration_seconds();
+        assert!(duration.is_some());
+        assert!(duration.unwrap() >= 0);
+
+        // Exit tangent mode
+        conversation.exit_tangent_mode();
+        assert!(!conversation.is_in_tangent_mode());
+
+        // No duration when not in tangent mode
+        assert!(conversation.get_tangent_duration_seconds().is_none());
+    }
 }

crates/chat-cli/src/telemetry/core.rs

@@ -286,6 +286,25 @@ impl Event {
                 }
                 .into_metric_datum(),
             ),
+            EventType::TangentModeSession {
+                conversation_id,
+                result,
+                args: TangentModeSessionArgs { duration_seconds },
+            } => Some(
+                CodewhispererterminalChatSlashCommandExecuted {
+                    create_time: self.created_time,
+                    value: Some(duration_seconds as f64),
+                    credential_start_url: self.credential_start_url.map(Into::into),
+                    sso_region: self.sso_region.map(Into::into),
+                    amazonq_conversation_id: Some(conversation_id.into()),
+                    codewhispererterminal_chat_slash_command: Some("tangent".to_string().into()),
+                    codewhispererterminal_chat_slash_subcommand: Some("exit".to_string().into()),
+                    result: Some(result.to_string().into()),
+                    reason: None,
+                    codewhispererterminal_in_cloudshell: None,
+                }
+                .into_metric_datum(),
+            ),
             EventType::ToolUseSuggested {
                 conversation_id,
                 utterance_id,
@@ -528,6 +547,13 @@ pub struct ChatAddedMessageParams {
     pub message_meta_tags: Vec<MessageMetaTag>,
 }
 
+/// Optional fields for tangent mode session telemetry event.
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, Default)]
+pub struct TangentModeSessionArgs {
+    /// Duration of tangent mode session in seconds
+    pub duration_seconds: i64,
+}
+
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, Default)]
 pub struct RecordUserTurnCompletionArgs {
     pub request_ids: Vec<Option<String>>,
@@ -592,6 +618,11 @@ pub enum EventType {
         result: TelemetryResult,
         args: RecordUserTurnCompletionArgs,
     },
+    TangentModeSession {
+        conversation_id: String,
+        result: TelemetryResult,
+        args: TangentModeSessionArgs,
+    },
     ToolUseSuggested {
         conversation_id: String,
         utterance_id: Option<String>,

crates/chat-cli/src/telemetry/mod.rs

@@ -8,6 +8,7 @@ use core::{
     AgentConfigInitArgs,
     ChatAddedMessageParams,
     RecordUserTurnCompletionArgs,
+    TangentModeSessionArgs,
     ToolUseEventBuilder,
 };
 use std::str::FromStr;
@@ -322,6 +323,22 @@ impl TelemetryThread {
         Ok(self.tx.send(telemetry_event)?)
     }
 
+    pub async fn send_tangent_mode_session(
+        &self,
+        database: &Database,
+        conversation_id: String,
+        result: TelemetryResult,
+        args: TangentModeSessionArgs,
+    ) -> Result<(), TelemetryError> {
+        let mut telemetry_event = Event::new(EventType::TangentModeSession {
+            conversation_id,
+            result,
+            args,
+        });
+        set_event_metadata(database, &mut telemetry_event).await;
+        Ok(self.tx.send(telemetry_event)?)
+    }
+
     pub async fn send_tool_use_suggested(
         &self,
         database: &Database,