@masyv/relay 0.2.0 → 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/session.rs

@@ -3,6 +3,10 @@
 //! 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 {
@@ -143,7 +147,7 @@ fn parse_session_transcript(path: &std::path::Path) -> SessionInfo {
 
                                     conversation.push(ConversationTurn {
                                         role: "tool_result".into(),
-                                        content: truncate(&result_text, 600),
+                                        content: truncate(&result_text, 200),
                                     });
                                 }
                             }
@@ -168,7 +172,7 @@ fn parse_session_transcript(path: &std::path::Path) -> SessionInfo {
                         }
                         conversation.push(ConversationTurn {
                             role: "user".into(),
-                            content: truncate(&user_text, 400),
+                            content: truncate(&user_text, 300),
                         });
                     }
                 }
@@ -185,7 +189,7 @@ fn parse_session_transcript(path: &std::path::Path) -> SessionInfo {
                                 if !text.is_empty() {
                                     conversation.push(ConversationTurn {
                                         role: "assistant".into(),
-                                        content: truncate(text, 500),
+                                        content: truncate(text, 200),
                                     });
                                     // Extract decisions
                                     for line in text.lines() {
@@ -230,8 +234,8 @@ fn parse_session_transcript(path: &std::path::Path) -> SessionInfo {
     decisions.dedup();
     decisions.truncate(15);
 
-    // Keep last N conversation turns to fit context — prioritize recent
-    let max_turns = 80;
+    // 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();

package/core/src/handoff/mod.rs

@@ -135,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/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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@masyv/relay",
-  "version": "0.2.0",
+  "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",