@masyv/relay 0.1.1 → 0.3.0

package/core/src/agents/codex.rs

@@ -69,33 +69,27 @@ impl Agent for CodexAgent {
         let tmp = std::env::temp_dir().join("relay_handoff.md");
         std::fs::write(&tmp, handoff_prompt)?;
 
-        // Use `codex exec --full-auto` for non-interactive auto-approval
-        let output = Command::new(&binary)
+        // Launch Codex INTERACTIVELY with the handoff as the initial prompt.
+        // This opens the Codex TUI so the user can keep working with it.
+        // stdin/stdout/stderr are inherited so the user sees the Codex UI.
+        let status = Command::new(&binary)
             .current_dir(project_dir)
-            .arg("exec")
             .arg("--full-auto")
             .arg("-m")
             .arg(&self.model)
             .arg(handoff_prompt)
-            .output()?;
-
-        let stdout = String::from_utf8_lossy(&output.stdout);
-        let stderr = String::from_utf8_lossy(&output.stderr);
-
-        if !stdout.is_empty() {
-            println!("{stdout}");
-        }
-        if !stderr.is_empty() {
-            eprintln!("{stderr}");
-        }
+            .stdin(std::process::Stdio::inherit())
+            .stdout(std::process::Stdio::inherit())
+            .stderr(std::process::Stdio::inherit())
+            .status()?;
 
         Ok(HandoffResult {
             agent: "codex".into(),
-            success: output.status.success(),
-            message: if output.status.success() {
-                format!("Codex ({}) completed handoff task", self.model)
+            success: status.success(),
+            message: if status.success() {
+                format!("Codex ({}) session ended", self.model)
             } else {
-                format!("Codex exited with code {:?}", output.status.code())
+                format!("Codex exited with code {:?}", status.code())
             },
             handoff_file: Some(tmp.to_string_lossy().to_string()),
         })

package/core/src/capture/mod.rs

@@ -26,6 +26,15 @@ pub fn capture_snapshot(
 
     let timestamp = chrono::Local::now().format("%Y-%m-%d %H:%M:%S").to_string();
 
+    // Convert conversation turns
+    let conversation: Vec<crate::ConversationTurn> = session_info.conversation
+        .into_iter()
+        .map(|t| crate::ConversationTurn {
+            role: t.role,
+            content: t.content,
+        })
+        .collect();
+
     Ok(SessionSnapshot {
         current_task: session_info.current_task,
         todos,
@@ -37,5 +46,6 @@ pub fn capture_snapshot(
         recent_files,
         timestamp,
         deadline: deadline.map(String::from),
+        conversation,
     })
 }

package/core/src/capture/session.rs

@@ -1,6 +1,12 @@
 //! Read Claude Code session state from .jsonl transcript files.
+//! Extracts the FULL conversation context — user messages, assistant reasoning,
+//! tool calls with results, errors, and decisions.
 
 use std::path::Path;
+use std::sync::atomic::AtomicUsize;
+
+/// Controls how many conversation turns to keep. Set before calling read_latest_session.
+pub static MAX_CONVERSATION_TURNS: AtomicUsize = AtomicUsize::new(25);
 
 /// Extracted session info from Claude's transcript.
 pub struct SessionInfo {
@@ -8,13 +14,19 @@ pub struct SessionInfo {
     pub decisions: Vec<String>,
     pub last_error: Option<String>,
     pub last_output: Option<String>,
+    /// Full conversation turns (compressed) — the real context
+    pub conversation: Vec<ConversationTurn>,
 }
 
-/// Read the latest Claude session transcript and extract state.
-pub fn read_latest_session(project_dir: &Path) -> SessionInfo {
-    // Claude stores transcripts in ~/.claude/projects/<project_hash>/<session>.jsonl
-    // Try to find and parse the latest one
+/// A single turn in the conversation.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct ConversationTurn {
+    pub role: String, // "user", "assistant", "tool_result"
+    pub content: String,
+}
 
+/// Read the latest Claude session transcript and extract full context.
+pub fn read_latest_session(project_dir: &Path) -> SessionInfo {
     let claude_dir = find_claude_project_dir(project_dir);
 
     if let Some(dir) = claude_dir {
@@ -29,17 +41,18 @@ pub fn read_latest_session(project_dir: &Path) -> SessionInfo {
         decisions: Vec::new(),
         last_error: None,
         last_output: None,
+        conversation: Vec::new(),
     }
 }
 
-fn find_claude_project_dir(project_dir: &Path) -> Option<std::path::PathBuf> {
+pub fn find_claude_project_dir(project_dir: &Path) -> Option<std::path::PathBuf> {
     let home = std::env::var("HOME").ok()?;
     let claude_projects = std::path::PathBuf::from(&home).join(".claude/projects");
     if !claude_projects.exists() {
         return None;
     }
 
-    // Claude encodes the project path: /Users/user/myproject -> -Users-user-myproject
+    // Claude encodes: /Users/user/myproject -> -Users-user-myproject
     let proj_str = project_dir.to_string_lossy().replace('/', "-");
     let candidate = claude_projects.join(&proj_str);
     if candidate.exists() {
@@ -48,10 +61,10 @@ fn find_claude_project_dir(project_dir: &Path) -> Option<std::path::PathBuf> {
 
     // Try matching by suffix
     if let Ok(entries) = std::fs::read_dir(&claude_projects) {
-        let dir_name = project_dir.file_name()?.to_string_lossy();
+        let dir_name = project_dir.file_name()?.to_string_lossy().to_string();
         for entry in entries.flatten() {
             let name = entry.file_name().to_string_lossy().to_string();
-            if name.ends_with(&*dir_name) && entry.path().is_dir() {
+            if name.ends_with(&dir_name) && entry.path().is_dir() {
                 return Some(entry.path());
             }
         }
@@ -85,82 +98,131 @@ fn parse_session_transcript(path: &std::path::Path) -> SessionInfo {
         Err(_) => return default_session_info(),
     };
 
+    let lines: Vec<&str> = content.lines().collect();
+
     let mut current_task = String::new();
     let mut decisions = Vec::new();
     let mut last_error = None;
     let mut last_output = None;
+    let mut conversation: Vec<ConversationTurn> = Vec::new();
 
-    // Read last 200 lines of the JSONL for efficiency
-    let lines: Vec<&str> = content.lines().collect();
-    let start = lines.len().saturating_sub(200);
-
-    for line in &lines[start..] {
+    for line in &lines {
         let Ok(val) = serde_json::from_str::<serde_json::Value>(line) else { continue };
+        let msg_type = val.get("type").and_then(|v| v.as_str()).unwrap_or("");
+        let message = val.get("message").cloned().unwrap_or_default();
+        let msg_content = message.get("content");
 
-        // Extract user messages for task context
-        if val.get("type").and_then(|v| v.as_str()) == Some("human") {
-            if let Some(msg) = val.get("message").and_then(|m| {
-                m.get("content").and_then(|c| {
-                    if let Some(s) = c.as_str() {
-                        Some(s.to_string())
-                    } else if let Some(arr) = c.as_array() {
-                        arr.iter()
-                            .filter_map(|item| item.get("text").and_then(|t| t.as_str()))
-                            .last()
-                            .map(String::from)
-                    } else {
-                        None
-                    }
-                })
-            }) {
-                // Keep the last substantive user message as current task
-                if msg.len() > 10 && !msg.starts_with('/') {
-                    current_task = if msg.len() > 500 {
-                        format!("{}...", &msg[..500])
-                    } else {
-                        msg
-                    };
-                }
-            }
-        }
+        match msg_type {
+            // ── User messages ──────────────────────────────────────────
+            "user" => {
+                // Check if this is a tool result
+                if let Some(tool_result) = val.get("toolUseResult") {
+                    // Tool result content is in message.content[].content
+                    if let Some(items) = msg_content.and_then(|c| c.as_array()) {
+                        for item in items {
+                            if item.get("type").and_then(|t| t.as_str()) == Some("tool_result") {
+                                let result_text = item.get("content")
+                                    .and_then(|c| {
+                                        if let Some(s) = c.as_str() {
+                                            Some(s.to_string())
+                                        } else if let Some(arr) = c.as_array() {
+                                            Some(arr.iter()
+                                                .filter_map(|i| i.get("text").and_then(|t| t.as_str()))
+                                                .collect::<Vec<_>>()
+                                                .join("\n"))
+                                        } else {
+                                            None
+                                        }
+                                    })
+                                    .unwrap_or_default();
+
+                                if !result_text.is_empty() {
+                                    // Check for errors
+                                    let lower = result_text.to_lowercase();
+                                    if lower.contains("error") || lower.contains("failed") ||
+                                       lower.contains("panic") || lower.contains("exit code") {
+                                        last_error = Some(truncate(&result_text, 800));
+                                    }
+                                    last_output = Some(truncate(&result_text, 800));
 
-        // Extract assistant tool use for last output
-        if val.get("type").and_then(|v| v.as_str()) == Some("assistant") {
-            if let Some(content) = val.get("message").and_then(|m| m.get("content")) {
-                if let Some(arr) = content.as_array() {
-                    for item in arr {
-                        // Look for tool results
-                        if item.get("type").and_then(|t| t.as_str()) == Some("tool_result") {
-                            if let Some(output) = item.get("content").and_then(|c| c.as_str()) {
-                                // Check for errors
-                                let lower = output.to_lowercase();
-                                if lower.contains("error") || lower.contains("failed") || lower.contains("panic") {
-                                    last_error = Some(truncate(output, 500));
+                                    conversation.push(ConversationTurn {
+                                        role: "tool_result".into(),
+                                        content: truncate(&result_text, 200),
+                                    });
                                 }
-                                last_output = Some(truncate(output, 500));
                             }
                         }
-                        // Look for text content with decisions
-                        if item.get("type").and_then(|t| t.as_str()) == Some("text") {
-                            if let Some(text) = item.get("text").and_then(|t| t.as_str()) {
-                                // Extract lines that look like decisions
-                                for line in text.lines() {
-                                    let trimmed = line.trim();
-                                    if (trimmed.starts_with("I'll use") ||
-                                        trimmed.starts_with("I chose") ||
-                                        trimmed.starts_with("Decision:") ||
-                                        trimmed.starts_with("Using ") ||
-                                        trimmed.starts_with("Approach:"))
-                                        && trimmed.len() > 15
-                                    {
-                                        decisions.push(truncate(trimmed, 200));
+                    }
+                    // Also check stdout/stderr from toolUseResult
+                    let stdout = tool_result.get("stdout").and_then(|s| s.as_str()).unwrap_or("");
+                    let stderr = tool_result.get("stderr").and_then(|s| s.as_str()).unwrap_or("");
+                    if !stdout.is_empty() {
+                        last_output = Some(truncate(stdout, 800));
+                    }
+                    if !stderr.is_empty() {
+                        last_error = Some(truncate(stderr, 800));
+                    }
+                } else {
+                    // Regular user message
+                    let user_text = extract_text_content(msg_content);
+                    if !user_text.is_empty() && user_text.len() > 3 {
+                        // Update current task from the last substantive user message
+                        if user_text.len() > 10 && !user_text.starts_with('/') {
+                            current_task = truncate(&user_text, 500);
+                        }
+                        conversation.push(ConversationTurn {
+                            role: "user".into(),
+                            content: truncate(&user_text, 300),
+                        });
+                    }
+                }
+            }
+
+            // ── Assistant messages ──────────────────────────────────────
+            "assistant" => {
+                if let Some(items) = msg_content.and_then(|c| c.as_array()) {
+                    for item in items {
+                        let item_type = item.get("type").and_then(|t| t.as_str()).unwrap_or("");
+                        match item_type {
+                            "text" => {
+                                let text = item.get("text").and_then(|t| t.as_str()).unwrap_or("");
+                                if !text.is_empty() {
+                                    conversation.push(ConversationTurn {
+                                        role: "assistant".into(),
+                                        content: truncate(text, 200),
+                                    });
+                                    // Extract decisions
+                                    for line in text.lines() {
+                                        let trimmed = line.trim();
+                                        if (trimmed.starts_with("I'll ") ||
+                                            trimmed.starts_with("I chose") ||
+                                            trimmed.starts_with("Using ") ||
+                                            trimmed.starts_with("Decision:") ||
+                                            trimmed.starts_with("Approach:") ||
+                                            trimmed.starts_with("The fix is") ||
+                                            trimmed.starts_with("The issue"))
+                                            && trimmed.len() > 20
+                                        {
+                                            decisions.push(truncate(trimmed, 200));
+                                        }
                                     }
                                 }
                             }
+                            "tool_use" => {
+                                let name = item.get("name").and_then(|n| n.as_str()).unwrap_or("?");
+                                let input = item.get("input").cloned().unwrap_or_default();
+                                let summary = summarize_tool_call(name, &input);
+                                conversation.push(ConversationTurn {
+                                    role: "assistant_tool".into(),
+                                    content: summary,
+                                });
+                            }
+                            _ => {}
                         }
                     }
                 }
             }
+            _ => {} // skip system, queue-operation, etc.
         }
     }
 
@@ -168,20 +230,90 @@ fn parse_session_transcript(path: &std::path::Path) -> SessionInfo {
         current_task = "Could not determine current task from session transcript".into();
     }
 
-    // Deduplicate and limit decisions
+    // Deduplicate decisions
     decisions.dedup();
-    decisions.truncate(10);
+    decisions.truncate(15);
+
+    // Keep last N conversation turns — caller can override via max_conversation_turns
+    let max_turns = MAX_CONVERSATION_TURNS.load(std::sync::atomic::Ordering::Relaxed);
+    if conversation.len() > max_turns {
+        let skip = conversation.len() - max_turns;
+        conversation = conversation.into_iter().skip(skip).collect();
+    }
 
     SessionInfo {
         current_task,
         decisions,
         last_error,
         last_output,
+        conversation,
     }
 }
 
+/// Summarize a tool call into a human-readable line.
+fn summarize_tool_call(name: &str, input: &serde_json::Value) -> String {
+    match name {
+        "Write" => {
+            let path = input.get("file_path").and_then(|p| p.as_str()).unwrap_or("?");
+            let content_len = input.get("content").and_then(|c| c.as_str()).map(|s| s.len()).unwrap_or(0);
+            format!("[Write] {} ({} chars)", path, content_len)
+        }
+        "Edit" => {
+            let path = input.get("file_path").and_then(|p| p.as_str()).unwrap_or("?");
+            let old = input.get("old_string").and_then(|o| o.as_str()).unwrap_or("");
+            format!("[Edit] {} (replacing {} chars)", path, old.len())
+        }
+        "Read" => {
+            let path = input.get("file_path").and_then(|p| p.as_str()).unwrap_or("?");
+            format!("[Read] {}", path)
+        }
+        "Bash" => {
+            let cmd = input.get("command").and_then(|c| c.as_str()).unwrap_or("?");
+            format!("[Bash] {}", truncate(cmd, 120))
+        }
+        "Glob" => {
+            let pat = input.get("pattern").and_then(|p| p.as_str()).unwrap_or("?");
+            format!("[Glob] {}", pat)
+        }
+        "Grep" => {
+            let pat = input.get("pattern").and_then(|p| p.as_str()).unwrap_or("?");
+            format!("[Grep] {}", pat)
+        }
+        "TodoWrite" => {
+            let todos = input.get("todos").and_then(|t| t.as_array());
+            let count = todos.map(|t| t.len()).unwrap_or(0);
+            format!("[TodoWrite] {} items", count)
+        }
+        "Agent" => {
+            let desc = input.get("description").and_then(|d| d.as_str()).unwrap_or("?");
+            format!("[Agent] {}", desc)
+        }
+        _ => format!("[{}]", name),
+    }
+}
+
+/// Extract text content from a message content field.
+fn extract_text_content(content: Option<&serde_json::Value>) -> String {
+    let Some(c) = content else { return String::new() };
+    if let Some(s) = c.as_str() {
+        return s.to_string();
+    }
+    if let Some(arr) = c.as_array() {
+        let texts: Vec<&str> = arr.iter()
+            .filter_map(|item| {
+                if item.get("type").and_then(|t| t.as_str()) == Some("text") {
+                    item.get("text").and_then(|t| t.as_str())
+                } else {
+                    None
+                }
+            })
+            .collect();
+        return texts.join("\n");
+    }
+    String::new()
+}
+
 fn infer_task_from_git(project_dir: &Path) -> String {
-    // Infer from recent commit messages
     let output = std::process::Command::new("git")
         .current_dir(project_dir)
         .args(["log", "--oneline", "-1", "--no-decorate"])
@@ -201,10 +333,14 @@ fn infer_task_from_git(project_dir: &Path) -> String {
 
 fn truncate(s: &str, max: usize) -> String {
     if s.len() <= max {
-        s.to_string()
-    } else {
-        format!("{}...", &s[..max])
+        return s.to_string();
+    }
+    // Find a valid char boundary at or before max
+    let mut end = max;
+    while end > 0 && !s.is_char_boundary(end) {
+        end -= 1;
     }
+    format!("{}...", &s[..end])
 }
 
 fn default_session_info() -> SessionInfo {
@@ -213,5 +349,6 @@ fn default_session_info() -> SessionInfo {
         decisions: Vec::new(),
         last_error: None,
         last_output: None,
+        conversation: Vec::new(),
     }
 }

package/core/src/handoff/mod.rs

@@ -100,6 +100,22 @@ pub fn build_handoff(
         sections.push(files);
     }
 
+    // ── Full Conversation Context ──────────────────────────────
+    if !snapshot.conversation.is_empty() {
+        let mut convo = String::from("## CONVERSATION CONTEXT\n\nBelow is the full conversation from the Claude session (most recent turns).\nThis is the actual context that was in Claude's window when it was interrupted.\n\n");
+        for turn in &snapshot.conversation {
+            let prefix = match turn.role.as_str() {
+                "user"           => "USER",
+                "assistant"      => "CLAUDE",
+                "assistant_tool" => "CLAUDE_TOOL",
+                "tool_result"    => "TOOL_OUTPUT",
+                _                => &turn.role,
+            };
+            convo.push_str(&format!("[{prefix}] {}\n\n", turn.content));
+        }
+        sections.push(convo);
+    }
+
     // ── Instructions for agent ─────────────────────────────────
     let instructions = format!(
         "## INSTRUCTIONS\n\n\
@@ -119,11 +135,15 @@ pub fn build_handoff(
 
     let mut full = sections.join("\n\n");
 
-    // Truncate if too long (rough token estimate: chars / 3.5)
-    let estimated_tokens = full.len() as f64 / 3.5;
-    if estimated_tokens > max_tokens as f64 {
-        let max_chars = (max_tokens as f64 * 3.5) as usize;
-        full.truncate(max_chars);
+    // Hard cap at max_tokens (rough estimate: chars / 3.5)
+    let max_chars = (max_tokens as f64 * 3.5) as usize;
+    if full.len() > max_chars {
+        // Find a valid UTF-8 char boundary
+        let mut end = max_chars;
+        while end > 0 && !full.is_char_boundary(end) {
+            end -= 1;
+        }
+        full.truncate(end);
         full.push_str("\n\n[...truncated to fit context limit]");
     }
 

package/core/src/lib.rs

@@ -162,6 +162,15 @@ pub struct SessionSnapshot {
     pub timestamp: String,
     /// Deadline if set
     pub deadline: Option<String>,
+    /// FULL conversation context from Claude session transcript
+    pub conversation: Vec<ConversationTurn>,
+}
+
+/// A single turn in the conversation (user message, assistant text, or tool call/result).
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ConversationTurn {
+    pub role: String,
+    pub content: String,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]

package/core/src/main.rs

@@ -44,6 +44,14 @@ enum Commands {
         /// Don't execute — just print the handoff package
         #[arg(long)]
         dry_run: bool,
+
+        /// How many conversation turns to include (default: 25)
+        #[arg(long, default_value = "25")]
+        turns: usize,
+
+        /// What to include: all, conversation, git, todos (comma-separated)
+        #[arg(long, default_value = "all")]
+        include: String,
     },
 
     /// Show current session snapshot (what would be handed off)
@@ -84,14 +92,33 @@ fn main() -> Result<()> {
     });
 
     match cli.command {
-        Commands::Handoff { to, deadline, dry_run } => {
+        Commands::Handoff { to, deadline, dry_run, turns, include } => {
             eprintln!("{}", "⚡ Relay — capturing session state...".yellow().bold());
 
-            let snapshot = capture::capture_snapshot(
+            // Set conversation turn limit before capture
+            relay::capture::session::MAX_CONVERSATION_TURNS
+                .store(turns, std::sync::atomic::Ordering::Relaxed);
+
+            let mut snapshot = capture::capture_snapshot(
                 &project_dir,
                 deadline.as_deref(),
             )?;
 
+            // Filter sections based on --include flag
+            let includes: Vec<&str> = include.split(',').map(|s| s.trim()).collect();
+            if !includes.contains(&"all") {
+                if !includes.contains(&"conversation") {
+                    snapshot.conversation.clear();
+                }
+                if !includes.contains(&"git") {
+                    snapshot.git_state = None;
+                    snapshot.recent_files.clear();
+                }
+                if !includes.contains(&"todos") {
+                    snapshot.todos.clear();
+                }
+            }
+
             let target = to.as_deref().unwrap_or("auto");
             let handoff_text = handoff::build_handoff(
                 &snapshot,
@@ -206,6 +233,28 @@ fn main() -> Result<()> {
                 }
                 println!();
             }
+
+            if !snapshot.conversation.is_empty() {
+                println!("{}", format!("── Conversation ({} turns) ──", snapshot.conversation.len()).cyan());
+                // Show last 15 turns
+                let start = snapshot.conversation.len().saturating_sub(15);
+                for turn in &snapshot.conversation[start..] {
+                    let prefix = match turn.role.as_str() {
+                        "user"           => "👤 USER".to_string(),
+                        "assistant"      => "🤖 CLAUDE".to_string(),
+                        "assistant_tool" => "🔧 TOOL".to_string(),
+                        "tool_result"    => "📤 RESULT".to_string(),
+                        _                => turn.role.clone(),
+                    };
+                    let content = if turn.content.len() > 120 {
+                        format!("{}...", &turn.content[..117])
+                    } else {
+                        turn.content.clone()
+                    };
+                    println!("  {}: {}", prefix, content);
+                }
+                println!();
+            }
         }
 
         Commands::Agents => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@masyv/relay",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Relay — When Claude's rate limit hits, another agent picks up exactly where you left off. Captures session state and hands off to Codex, Gemini, Ollama, or GPT-4.",
   "scripts": {
     "build": "./scripts/build.sh",