diff --git a/hive-ag3nt/src/bin/hive-ag3nt.rs b/hive-ag3nt/src/bin/hive-ag3nt.rs index 7c661a0..ee77d29 100644 --- a/hive-ag3nt/src/bin/hive-ag3nt.rs +++ b/hive-ag3nt/src/bin/hive-ag3nt.rs @@ -56,24 +56,16 @@ async fn main() -> Result<()> { let initial = LoginState::from_dir(&claude_dir); tracing::info!(state = ?initial, claude_dir = %claude_dir.display(), "harness boot"); let login_state = Arc::new(Mutex::new(initial)); - let ui_state = login_state.clone(); let bus = Bus::new(); - let ui_bus = bus.clone(); - let ui_socket = cli.socket.clone(); - tokio::spawn(async move { - if let Err(e) = web_ui::serve( - label, - port, - ui_state, - ui_bus, - ui_socket, - web_ui::Flavor::Agent, - ) - .await - { - tracing::error!(error = ?e, "web ui failed"); - } - }); + let files = turn::TurnFiles::prepare(&cli.socket, &label, mcp::Flavor::Agent).await?; + tokio::spawn(web_ui::serve( + label, + port, + login_state.clone(), + bus.clone(), + cli.socket.clone(), + files.clone(), + )); match initial { LoginState::Online => { serve( @@ -81,6 +73,7 @@ async fn main() -> Result<()> { Duration::from_millis(poll_ms), login_state, bus, + &files, ) .await } @@ -94,6 +87,7 @@ async fn main() -> Result<()> { Duration::from_millis(poll_ms), login_state, bus, + &files, ) .await } @@ -108,13 +102,10 @@ async fn serve( interval: Duration, state: Arc>, bus: Bus, + files: &turn::TurnFiles, ) -> Result<()> { tracing::info!(socket = %socket.display(), "hive-ag3nt serve"); let _ = state; // reserved for future state transitions (turn-loop -> needs-login) - let mcp_config = turn::write_mcp_config(socket).await?; - let settings = turn::write_settings(socket).await?; - let label = std::env::var("HIVE_LABEL").unwrap_or_else(|_| "hive-ag3nt".into()); - let system_prompt = turn::write_system_prompt(socket, &label, mcp::Flavor::Agent).await?; loop { let recv: Result = client::request(socket, &AgentRequest::Recv { wait_seconds: None }).await; @@ -129,15 +120,7 @@ async fn serve( }); bus.set_state(TurnState::Thinking); let prompt = format_wake_prompt(&from, &body, unread); - let outcome = turn::drive_turn( - &prompt, - &mcp_config, - &system_prompt, - &settings, - &bus, - mcp::Flavor::Agent, - ) - .await; + let outcome = turn::drive_turn(&prompt, files, &bus).await; turn::emit_turn_end(&bus, &outcome); bus.set_state(TurnState::Idle); } diff --git a/hive-ag3nt/src/bin/hive-m1nd.rs b/hive-ag3nt/src/bin/hive-m1nd.rs index bf99716..9e50806 100644 --- a/hive-ag3nt/src/bin/hive-m1nd.rs +++ b/hive-ag3nt/src/bin/hive-m1nd.rs @@ -59,29 +59,23 @@ async fn main() -> Result<()> { let initial = LoginState::from_dir(&claude_dir); tracing::info!(state = ?initial, claude_dir = %claude_dir.display(), "hm1nd boot"); let login_state = Arc::new(Mutex::new(initial)); - let ui_state = login_state.clone(); let bus = Bus::new(); - let ui_bus = bus.clone(); - let ui_socket = cli.socket.clone(); - tokio::spawn(async move { - if let Err(e) = web_ui::serve( - label, - port, - ui_state, - ui_bus, - ui_socket, - web_ui::Flavor::Manager, - ) - .await - { - tracing::error!(error = ?e, "web ui failed"); - } - }); + let files = turn::TurnFiles::prepare(&cli.socket, &label, mcp::Flavor::Manager).await?; + tokio::spawn(web_ui::serve( + label, + port, + login_state.clone(), + bus.clone(), + cli.socket.clone(), + files.clone(), + )); match initial { - LoginState::Online => serve(&cli.socket, Duration::from_millis(poll_ms), bus).await, + LoginState::Online => { + serve(&cli.socket, Duration::from_millis(poll_ms), bus, &files).await + } LoginState::NeedsLogin => { turn::wait_for_login(&claude_dir, login_state, poll_ms).await; - serve(&cli.socket, Duration::from_millis(poll_ms), bus).await + serve(&cli.socket, Duration::from_millis(poll_ms), bus, &files).await } } } @@ -89,12 +83,13 @@ async fn main() -> Result<()> { } } -async fn serve(socket: &Path, interval: Duration, bus: Bus) -> Result<()> { +async fn serve( + socket: &Path, + interval: Duration, + bus: Bus, + files: &turn::TurnFiles, +) -> Result<()> { tracing::info!(socket = %socket.display(), "hive-m1nd serve"); - let mcp_config = turn::write_mcp_config(socket).await?; - let settings = turn::write_settings(socket).await?; - let label = std::env::var("HIVE_LABEL").unwrap_or_else(|_| "hm1nd".into()); - let system_prompt = turn::write_system_prompt(socket, &label, mcp::Flavor::Manager).await?; loop { let recv: Result = client::request(socket, &ManagerRequest::Recv { wait_seconds: None }).await; @@ -126,15 +121,7 @@ async fn serve(socket: &Path, interval: Duration, bus: Bus) -> Result<()> { }); let prompt = format_wake_prompt(&from, &body, unread); bus.set_state(TurnState::Thinking); - let outcome = turn::drive_turn( - &prompt, - &mcp_config, - &system_prompt, - &settings, - &bus, - mcp::Flavor::Manager, - ) - .await; + let outcome = turn::drive_turn(&prompt, files, &bus).await; turn::emit_turn_end(&bus, &outcome); bus.set_state(TurnState::Idle); } diff --git a/hive-ag3nt/src/turn.rs b/hive-ag3nt/src/turn.rs index 1c49981..d85ef8c 100644 --- a/hive-ag3nt/src/turn.rs +++ b/hive-ag3nt/src/turn.rs @@ -33,6 +33,34 @@ const CLAUDE_SETTINGS: &str = include_str!("../prompts/claude-settings.json"); /// claude exit with a useful error in the live view. const PROMPT_TOO_LONG_MARKER: &str = "Prompt is too long"; +/// The set of files claude reads on every invocation: the MCP server +/// config (`--mcp-config`), static settings (`--settings`), and the +/// pre-rendered role/tools system prompt (`--system-prompt-file`). +/// Materialised once at harness startup; shared between the turn loop +/// and the operator-driven `/compact` path so both invocations look +/// identical to claude (same MCP surface, same allowed tools, same +/// role prompt — only the stdin payload differs). +#[derive(Clone)] +pub struct TurnFiles { + pub mcp_config: PathBuf, + pub settings: PathBuf, + pub system_prompt: PathBuf, + pub flavor: mcp::Flavor, +} + +impl TurnFiles { + /// Write all three files into the per-agent runtime dir alongside + /// `socket`. Idempotent — overwrites whatever was there. + pub async fn prepare(socket: &Path, label: &str, flavor: mcp::Flavor) -> Result { + Ok(Self { + mcp_config: write_mcp_config(socket).await?, + settings: write_settings(socket).await?, + system_prompt: write_system_prompt(socket, label, flavor).await?, + flavor, + }) + } +} + /// Drop the MCP config blob claude reads from `--mcp-config `. /// `socket` is the hyperhive per-container socket (forwarded to the child /// as `--socket `); `binary_subcommand` is e.g. `"mcp"` for sub-agents @@ -99,21 +127,14 @@ pub enum TurnOutcome { /// Drive one turn end-to-end, transparently compacting + retrying once on /// `Prompt is too long`. Both the sub-agent and manager loops call this. -pub async fn drive_turn( - prompt: &str, - mcp_config: &Path, - system_prompt: &Path, - settings: &Path, - bus: &Bus, - flavor: mcp::Flavor, -) -> TurnOutcome { - match run_turn(prompt, mcp_config, system_prompt, settings, bus, flavor).await { +pub async fn drive_turn(prompt: &str, files: &TurnFiles, bus: &Bus) -> TurnOutcome { + match run_turn(prompt, files, bus).await { TurnOutcome::PromptTooLong => { - if let Err(e) = compact_session(settings, bus).await { + if let Err(e) = compact_session(files, bus).await { tracing::warn!(error = %format!("{e:#}"), "compact failed"); return TurnOutcome::Failed(e); } - run_turn(prompt, mcp_config, system_prompt, settings, bus, flavor).await + run_turn(prompt, files, bus).await } other => other, } @@ -166,25 +187,8 @@ pub async fn wait_for_login(claude_dir: &Path, state: Arc>, po /// prompt). The session is persistent across turns via `--continue` and /// claude's in-session auto-compact is disabled via `--settings` so it /// doesn't stall mid-turn — hyperhive owns compaction. -pub async fn run_turn( - prompt: &str, - mcp_config: &Path, - system_prompt: &Path, - settings: &Path, - bus: &Bus, - flavor: mcp::Flavor, -) -> TurnOutcome { - match run_claude( - prompt, - mcp_config, - Some(system_prompt), - settings, - bus, - flavor, - ClaudeMode::Turn, - ) - .await - { +pub async fn run_turn(prompt: &str, files: &TurnFiles, bus: &Bus) -> TurnOutcome { + match run_claude(prompt, files, bus).await { Ok(too_long) if too_long => TurnOutcome::PromptTooLong, Ok(_) => TurnOutcome::Ok, Err(e) => TurnOutcome::Failed(e), @@ -192,49 +196,23 @@ pub async fn run_turn( } /// Run claude's built-in `/compact` slash command on the persistent -/// session so the next turn can fit. No MCP tools needed; we just feed -/// `/compact` over stdin and let claude rewrite its own history. -pub async fn compact_session(settings: &Path, bus: &Bus) -> Result<()> { +/// session. Takes the *same* params as `run_turn` because compact +/// re-initialises claude with the full session shape — same MCP +/// surface, same system prompt, same allowed-tools — so the post- +/// compact state matches a normal turn's. Only the prompt over stdin +/// differs (`/compact` vs the wake-up payload). +pub async fn compact_session(files: &TurnFiles, bus: &Bus) -> Result<()> { bus.emit(LiveEvent::Note( "context overflow — running /compact on the persistent session".into(), )); - let _ = run_claude( - "/compact", - Path::new("/dev/null"), - None, - settings, - bus, - mcp::Flavor::Agent, // tool surface unused for /compact - ClaudeMode::Compact, - ) - .await?; + let _ = run_claude("/compact", files, bus).await?; bus.emit(LiveEvent::Note("/compact done".into())); Ok(()) } -#[derive(Clone, Copy)] -enum ClaudeMode { - Turn, - Compact, -} - -async fn run_claude( - prompt: &str, - mcp_config: &Path, - system_prompt: Option<&Path>, - settings: &Path, - bus: &Bus, - flavor: mcp::Flavor, - mode: ClaudeMode, -) -> Result { +async fn run_claude(prompt: &str, files: &TurnFiles, bus: &Bus) -> Result { let model = bus.model(); - // /compact must always run against the existing session — otherwise - // there's nothing to compact. Only normal turns honor the - // operator's "new session" one-shot flag. - let resume = match mode { - ClaudeMode::Turn => !bus.take_skip_continue(), - ClaudeMode::Compact => true, - }; + let resume = !bus.take_skip_continue(); if !resume { bus.emit(LiveEvent::Note( "fresh session (--continue suppressed for this turn)".into(), @@ -258,22 +236,18 @@ async fn run_claude( .arg("--model") .arg(&model) .arg("--settings") - .arg(settings); + .arg(&files.settings); if resume { cmd.arg("--continue"); } - if let Some(p) = system_prompt { - cmd.arg("--system-prompt-file").arg(p); - } - if let ClaudeMode::Turn = mode { - cmd.arg("--mcp-config") - .arg(mcp_config) - .arg("--strict-mcp-config") - .arg("--tools") - .arg(mcp::builtin_tools_arg()) - .arg("--allowedTools") - .arg(mcp::allowed_tools_arg(flavor)); - } + cmd.arg("--system-prompt-file").arg(&files.system_prompt); + cmd.arg("--mcp-config") + .arg(&files.mcp_config) + .arg("--strict-mcp-config") + .arg("--tools") + .arg(mcp::builtin_tools_arg()) + .arg("--allowedTools") + .arg(mcp::allowed_tools_arg(files.flavor)); let mut child = cmd .stdin(Stdio::piped()) .stdout(Stdio::piped()) diff --git a/hive-ag3nt/src/web_ui.rs b/hive-ag3nt/src/web_ui.rs index c9d759e..931ec2d 100644 --- a/hive-ag3nt/src/web_ui.rs +++ b/hive-ag3nt/src/web_ui.rs @@ -28,6 +28,8 @@ use crate::client; use crate::events::Bus; use crate::login::LoginState; use crate::login_session::{LoginSession, drop_if_finished}; +use crate::mcp; +use crate::turn::TurnFiles; /// Live login state for the web UI. The harness updates this in place as it /// transitions between `NeedsLogin` and `Online`; the UI reads on each @@ -41,16 +43,25 @@ struct AppState { session: Arc>>>, bus: Bus, socket: PathBuf, - flavor: Flavor, + /// Same `TurnFiles` the harness's turn loop uses. Shared so + /// `/api/compact` re-uses the exact MCP config / system prompt / + /// settings claude saw on the last regular turn — keeps the + /// session shape identical across compact + normal turns. + files: TurnFiles, +} + +impl AppState { + fn flavor(&self) -> Flavor { + self.files.flavor + } } /// Which wire protocol the per-agent UI's `/send` handler should speak. -/// Sub-agent → `AgentRequest::OperatorMsg`; manager → `ManagerRequest::OperatorMsg`. -#[derive(Debug, Clone, Copy)] -pub enum Flavor { - Agent, - Manager, -} +/// Sub-agent → `AgentRequest::OperatorMsg`; manager → +/// `ManagerRequest::OperatorMsg`. Reuses the MCP-side enum so a +/// single value drives both the send protocol and (in +/// `post_compact`) the allowed-tools surface claude sees. +pub type Flavor = mcp::Flavor; pub async fn serve( label: String, @@ -58,7 +69,7 @@ pub async fn serve( login: LoginStateCell, bus: Bus, socket: PathBuf, - flavor: Flavor, + files: TurnFiles, ) -> Result<()> { let state = AppState { label, @@ -66,7 +77,7 @@ pub async fn serve( session: Arc::new(Mutex::new(None)), bus, socket, - flavor, + files, }; let app = Router::new() .route("/", get(serve_index)) @@ -208,7 +219,7 @@ async fn api_state(State(state): State) -> axum::Json { .ok() .and_then(|s| s.parse::().ok()) .unwrap_or(7000); - let inbox = recent_inbox(&state.socket, state.flavor).await; + let inbox = recent_inbox(&state.socket, state.flavor()).await; let (turn_state, turn_state_since) = state.bus.state_snapshot(); let model = state.bus.model(); axum::Json(StateSnapshot { @@ -268,7 +279,7 @@ async fn post_send(State(state): State, Form(form): Form) -> if body.is_empty() { return error_response("send: `body` required"); } - let result = match state.flavor { + let result = match state.flavor() { Flavor::Agent => match client::request::<_, hive_sh4re::AgentResponse>( &state.socket, &hive_sh4re::AgentRequest::OperatorMsg { body }, @@ -396,22 +407,13 @@ async fn post_set_model(State(state): State, Form(form): Form) -> Response { let bus = state.bus.clone(); - let socket = state.socket.clone(); + let files = state.files.clone(); tokio::spawn(async move { bus.emit(crate::events::LiveEvent::Note( "operator: /compact — running on persistent session".into(), )); - let settings = match crate::turn::write_settings(&socket).await { - Ok(p) => p, - Err(e) => { - bus.emit(crate::events::LiveEvent::Note(format!( - "/compact failed: settings write — {e:#}" - ))); - return; - } - }; bus.set_state(crate::events::TurnState::Compacting); - let r = crate::turn::compact_session(&settings, &bus).await; + let r = crate::turn::compact_session(&files, &bus).await; bus.set_state(crate::events::TurnState::Idle); if let Err(e) = r { bus.emit(crate::events::LiveEvent::Note(format!(