@masyv/relay 0.2.0 → 0.4.0

package/core/src/agents/aider.rs

@@ -0,0 +1,75 @@
+//! Aider agent adapter — launches the aider TUI interactively.
+//! https://github.com/paul-gauthier/aider
+
+use super::Agent;
+use crate::{AgentStatus, HandoffResult};
+use anyhow::Result;
+use std::process::Command;
+
+pub struct AiderAgent {
+    model: String,
+}
+
+impl AiderAgent {
+    pub fn new(model: Option<&str>) -> Self {
+        Self {
+            model: model.unwrap_or("sonnet").to_string(),
+        }
+    }
+
+    fn find_binary() -> Option<String> {
+        let output = Command::new("which").arg("aider").output().ok()?;
+        if output.status.success() {
+            Some(String::from_utf8_lossy(&output.stdout).trim().to_string())
+        } else {
+            None
+        }
+    }
+}
+
+impl Agent for AiderAgent {
+    fn name(&self) -> &str { "aider" }
+
+    fn check_available(&self) -> AgentStatus {
+        match Self::find_binary() {
+            Some(path) => AgentStatus {
+                name: "aider".into(),
+                available: true,
+                reason: format!("Found at {path}"),
+                version: Command::new(&path).arg("--version").output().ok()
+                    .filter(|o| o.status.success())
+                    .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string()),
+            },
+            None => AgentStatus {
+                name: "aider".into(),
+                available: false,
+                reason: "Not found. Install: pip install aider-chat".into(),
+                version: None,
+            },
+        }
+    }
+
+    fn execute(&self, handoff_prompt: &str, project_dir: &str) -> Result<HandoffResult> {
+        let binary = Self::find_binary().unwrap_or("aider".into());
+        let tmp = std::env::temp_dir().join("relay_handoff.md");
+        std::fs::write(&tmp, handoff_prompt)?;
+
+        let status = Command::new(&binary)
+            .current_dir(project_dir)
+            .arg("--model")
+            .arg(&self.model)
+            .arg("--message")
+            .arg(handoff_prompt)
+            .stdin(std::process::Stdio::inherit())
+            .stdout(std::process::Stdio::inherit())
+            .stderr(std::process::Stdio::inherit())
+            .status()?;
+
+        Ok(HandoffResult {
+            agent: "aider".into(),
+            success: status.success(),
+            message: format!("Aider ({}) session ended", self.model),
+            handoff_file: Some(tmp.to_string_lossy().to_string()),
+        })
+    }
+}

package/core/src/agents/claude.rs

@@ -0,0 +1,68 @@
+//! Claude CLI agent — starts a new Claude Code session with full context.
+//! Useful when the rate limit resets or you have a second subscription.
+
+use super::Agent;
+use crate::{AgentStatus, HandoffResult};
+use anyhow::Result;
+use std::process::Command;
+
+pub struct ClaudeAgent;
+
+impl ClaudeAgent {
+    pub fn new() -> Self { Self }
+
+    fn find_binary() -> Option<String> {
+        let output = Command::new("which").arg("claude").output().ok()?;
+        if output.status.success() {
+            Some(String::from_utf8_lossy(&output.stdout).trim().to_string())
+        } else {
+            None
+        }
+    }
+}
+
+impl Agent for ClaudeAgent {
+    fn name(&self) -> &str { "claude" }
+
+    fn check_available(&self) -> AgentStatus {
+        match Self::find_binary() {
+            Some(path) => AgentStatus {
+                name: "claude".into(),
+                available: true,
+                reason: format!("Found at {path}"),
+                version: Command::new(&path).arg("--version").output().ok()
+                    .filter(|o| o.status.success())
+                    .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string()),
+            },
+            None => AgentStatus {
+                name: "claude".into(),
+                available: false,
+                reason: "Not found. Install: npm install -g @anthropic-ai/claude-code".into(),
+                version: None,
+            },
+        }
+    }
+
+    fn execute(&self, handoff_prompt: &str, project_dir: &str) -> Result<HandoffResult> {
+        let binary = Self::find_binary().unwrap_or("claude".into());
+        let tmp = std::env::temp_dir().join("relay_handoff.md");
+        std::fs::write(&tmp, handoff_prompt)?;
+
+        // Launch Claude interactively with the handoff as initial prompt
+        let status = Command::new(&binary)
+            .current_dir(project_dir)
+            .arg("--resume")
+            .arg(handoff_prompt)
+            .stdin(std::process::Stdio::inherit())
+            .stdout(std::process::Stdio::inherit())
+            .stderr(std::process::Stdio::inherit())
+            .status()?;
+
+        Ok(HandoffResult {
+            agent: "claude".into(),
+            success: status.success(),
+            message: "Claude session ended".into(),
+            handoff_file: Some(tmp.to_string_lossy().to_string()),
+        })
+    }
+}

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/agents/copilot.rs

@@ -0,0 +1,63 @@
+//! GitHub Copilot CLI agent adapter.
+
+use super::Agent;
+use crate::{AgentStatus, HandoffResult};
+use anyhow::Result;
+use std::process::Command;
+
+pub struct CopilotAgent;
+
+impl CopilotAgent {
+    pub fn new() -> Self { Self }
+
+    fn find_binary() -> Option<String> {
+        let output = Command::new("which").arg("copilot").output().ok()?;
+        if output.status.success() {
+            Some(String::from_utf8_lossy(&output.stdout).trim().to_string())
+        } else {
+            None
+        }
+    }
+}
+
+impl Agent for CopilotAgent {
+    fn name(&self) -> &str { "copilot" }
+
+    fn check_available(&self) -> AgentStatus {
+        match Self::find_binary() {
+            Some(path) => AgentStatus {
+                name: "copilot".into(),
+                available: true,
+                reason: format!("Found at {path}"),
+                version: None, // copilot --version hangs, skip it
+            },
+            None => AgentStatus {
+                name: "copilot".into(),
+                available: false,
+                reason: "Not found. Install: gh extension install github/gh-copilot".into(),
+                version: None,
+            },
+        }
+    }
+
+    fn execute(&self, handoff_prompt: &str, project_dir: &str) -> Result<HandoffResult> {
+        let binary = Self::find_binary().unwrap_or("copilot".into());
+        let tmp = std::env::temp_dir().join("relay_handoff.md");
+        std::fs::write(&tmp, handoff_prompt)?;
+
+        let status = Command::new(&binary)
+            .current_dir(project_dir)
+            .arg(handoff_prompt)
+            .stdin(std::process::Stdio::inherit())
+            .stdout(std::process::Stdio::inherit())
+            .stderr(std::process::Stdio::inherit())
+            .status()?;
+
+        Ok(HandoffResult {
+            agent: "copilot".into(),
+            success: status.success(),
+            message: "Copilot session ended".into(),
+            handoff_file: Some(tmp.to_string_lossy().to_string()),
+        })
+    }
+}

package/core/src/agents/mod.rs

@@ -1,7 +1,11 @@
+pub mod aider;
+pub mod claude;
 pub mod codex;
+pub mod copilot;
 pub mod gemini;
 pub mod ollama;
 pub mod openai;
+pub mod opencode;
 
 use crate::{AgentStatus, Config, HandoffResult};
 use anyhow::Result;
@@ -18,10 +22,14 @@ pub fn get_agents(config: &Config) -> Vec<Box<dyn Agent>> {
     let mut agents: Vec<Box<dyn Agent>> = Vec::new();
     for name in &config.general.priority {
         match name.as_str() {
-            "codex"  => agents.push(Box::new(codex::CodexAgent::new(&config.agents.codex))),
-            "gemini" => agents.push(Box::new(gemini::GeminiAgent::new(&config.agents.gemini))),
-            "ollama" => agents.push(Box::new(ollama::OllamaAgent::new(&config.agents.ollama))),
-            "openai" => agents.push(Box::new(openai::OpenAIAgent::new(&config.agents.openai))),
+            "codex"    => agents.push(Box::new(codex::CodexAgent::new(&config.agents.codex))),
+            "gemini"   => agents.push(Box::new(gemini::GeminiAgent::new(&config.agents.gemini))),
+            "ollama"   => agents.push(Box::new(ollama::OllamaAgent::new(&config.agents.ollama))),
+            "openai"   => agents.push(Box::new(openai::OpenAIAgent::new(&config.agents.openai))),
+            "aider"    => agents.push(Box::new(aider::AiderAgent::new(None))),
+            "claude"   => agents.push(Box::new(claude::ClaudeAgent::new())),
+            "copilot"  => agents.push(Box::new(copilot::CopilotAgent::new())),
+            "opencode" => agents.push(Box::new(opencode::OpenCodeAgent::new())),
             _ => {} // unknown agent, skip
         }
     }

package/core/src/agents/ollama.rs

@@ -3,6 +3,7 @@
 use super::Agent;
 use crate::{AgentStatus, HandoffResult, OllamaConfig};
 use anyhow::Result;
+use std::process::Command;
 
 pub struct OllamaAgent {
     url: String,
@@ -22,43 +23,24 @@ impl Agent for OllamaAgent {
     fn name(&self) -> &str { "ollama" }
 
     fn check_available(&self) -> AgentStatus {
-        // Ping Ollama's API
+        // Use curl with a 2s timeout — avoids ureq hanging on refused connections
         let tag_url = format!("{}/api/tags", self.url);
-        match ureq::get(&tag_url).call() {
-            Ok(resp) => {
-                let body: serde_json::Value = resp.into_json().unwrap_or_default();
-                let models = body.get("models")
-                    .and_then(|m| m.as_array())
-                    .map(|a| a.len())
-                    .unwrap_or(0);
+        let output = Command::new("curl")
+            .args(["--silent", "--max-time", "2", &tag_url])
+            .output();
 
-                // Check if our target model is available
-                let has_model = body.get("models")
-                    .and_then(|m| m.as_array())
-                    .map(|arr| arr.iter().any(|m| {
-                        m.get("name").and_then(|n| n.as_str())
-                            .map(|n| n.starts_with(&self.model))
-                            .unwrap_or(false)
-                    }))
-                    .unwrap_or(false);
-
-                if has_model {
-                    AgentStatus {
-                        name: "ollama".into(),
-                        available: true,
-                        reason: format!("Running at {}, {} models, '{}' available", self.url, models, self.model),
-                        version: Some(self.model.clone()),
-                    }
-                } else {
-                    AgentStatus {
-                        name: "ollama".into(),
-                        available: true,
-                        reason: format!("Running but model '{}' not pulled. {} models available", self.model, models),
-                        version: None,
-                    }
+        match output {
+            Ok(o) if o.status.success() => {
+                let body: serde_json::Value = serde_json::from_slice(&o.stdout).unwrap_or_default();
+                let models = body.get("models").and_then(|m| m.as_array()).map(|a| a.len()).unwrap_or(0);
+                AgentStatus {
+                    name: "ollama".into(),
+                    available: true,
+                    reason: format!("Running at {}, {} models available", self.url, models),
+                    version: Some(self.model.clone()),
                 }
             }
-            Err(_) => AgentStatus {
+            _ => AgentStatus {
                 name: "ollama".into(),
                 available: false,
                 reason: format!("Not reachable at {}", self.url),
@@ -69,7 +51,6 @@ impl Agent for OllamaAgent {
 
     fn execute(&self, handoff_prompt: &str, _project_dir: &str) -> Result<HandoffResult> {
         let url = format!("{}/api/generate", self.url);
-
         let body = serde_json::json!({
             "model": self.model,
             "prompt": handoff_prompt,
@@ -81,11 +62,7 @@ impl Agent for OllamaAgent {
             .send_json(&body)?;
 
         let resp_json: serde_json::Value = resp.into_json()?;
-        let text = resp_json
-            .get("response")
-            .and_then(|r| r.as_str())
-            .unwrap_or("(no response)");
-
+        let text = resp_json.get("response").and_then(|r| r.as_str()).unwrap_or("(no response)");
         println!("{text}");
 
         Ok(HandoffResult {

package/core/src/agents/opencode.rs

@@ -0,0 +1,66 @@
+//! OpenCode agent adapter — Go-based coding agent.
+//! https://github.com/opencode-ai/opencode
+
+use super::Agent;
+use crate::{AgentStatus, HandoffResult};
+use anyhow::Result;
+use std::process::Command;
+
+pub struct OpenCodeAgent;
+
+impl OpenCodeAgent {
+    pub fn new() -> Self { Self }
+
+    fn find_binary() -> Option<String> {
+        let output = Command::new("which").arg("opencode").output().ok()?;
+        if output.status.success() {
+            Some(String::from_utf8_lossy(&output.stdout).trim().to_string())
+        } else {
+            None
+        }
+    }
+}
+
+impl Agent for OpenCodeAgent {
+    fn name(&self) -> &str { "opencode" }
+
+    fn check_available(&self) -> AgentStatus {
+        match Self::find_binary() {
+            Some(path) => AgentStatus {
+                name: "opencode".into(),
+                available: true,
+                reason: format!("Found at {path}"),
+                version: Command::new(&path).arg("--version").output().ok()
+                    .filter(|o| o.status.success())
+                    .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string()),
+            },
+            None => AgentStatus {
+                name: "opencode".into(),
+                available: false,
+                reason: "Not found. Install: go install github.com/opencode-ai/opencode@latest".into(),
+                version: None,
+            },
+        }
+    }
+
+    fn execute(&self, handoff_prompt: &str, project_dir: &str) -> Result<HandoffResult> {
+        let binary = Self::find_binary().unwrap_or("opencode".into());
+        let tmp = std::env::temp_dir().join("relay_handoff.md");
+        std::fs::write(&tmp, handoff_prompt)?;
+
+        let status = Command::new(&binary)
+            .current_dir(project_dir)
+            .arg(handoff_prompt)
+            .stdin(std::process::Stdio::inherit())
+            .stdout(std::process::Stdio::inherit())
+            .stderr(std::process::Stdio::inherit())
+            .status()?;
+
+        Ok(HandoffResult {
+            agent: "opencode".into(),
+            success: status.success(),
+            message: "OpenCode session ended".into(),
+            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

@@ -117,29 +117,40 @@ pub fn build_handoff(
     }
 
     // ── Instructions for agent ─────────────────────────────────
+    let deadline_note = if snapshot.deadline.is_some() {
+        "\nIMPORTANT: There is a DEADLINE. If the user asks you to continue, prioritise the current task."
+    } else { "" };
+
     let instructions = format!(
         "## INSTRUCTIONS\n\n\
-        You are continuing work that was started in a Claude Code session.\n\
-        The session was interrupted by a rate limit.\n\
-        Pick up EXACTLY where it left off. Do NOT re-explain context.\n\
-        The user is waiting — be efficient and direct.\n\
+        You have been given the full context from a Claude Code session.\n\
+        The context above shows what was being worked on, what decisions were made,\n\
+        what files were changed, and what the last state was.\n\
+        \n\
+        DO NOT immediately start working on anything.\n\
+        Instead, briefly confirm you have the context by saying something like:\n\
+        \"Context restored from your Claude session. I can see you were working on [brief summary]. What would you like me to do?\"\n\
         \n\
-        Working directory: {}\n\
+        Then WAIT for the user to tell you what to do next.\n\
+        \n\
+        Working directory: {}\
         {}",
         snapshot.project_dir,
-        if snapshot.deadline.is_some() {
-            "THERE IS A DEADLINE. Prioritise completing the current task."
-        } else { "" }
+        deadline_note
     );
     sections.push(instructions);
 
     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

@@ -43,7 +43,11 @@ impl Default for GeneralConfig {
 fn default_priority() -> Vec<String> {
     vec![
         "codex".into(),
+        "claude".into(),
+        "aider".into(),
         "gemini".into(),
+        "copilot".into(),
+        "opencode".into(),
         "ollama".into(),
         "openai".into(),
     ]

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.4.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",