turn: unify run_turn / compact_session via TurnFiles
new TurnFiles bundle (mcp_config + settings + system_prompt + flavor) materialised once per harness boot, passed to drive_turn and compact_session alike. operator-initiated /compact now uses the exact same session shape as a normal turn — same MCP surface, same allowed tools, same role prompt — only the stdin payload differs (/compact vs the wake-up body). web_ui's AppState carries the TurnFiles instead of (label + socket + flavor + ad-hoc file writes per click). bin/hive-ag3nt and bin/hive-m1nd prepare TurnFiles before spawning the web UI and pass them to both surfaces. web_ui::Flavor folds into a type alias for mcp::Flavor — no two-stage enum mapping. removes ClaudeMode + the run_claude variant fork (system prompt was Option, mcp args were skipped on Compact). dead 'mode' plumbing gone.
This commit is contained in:
müde
parent
87c7b05b05
commit
d94712bde8
4 changed files with 109 additions and 163 deletions
|
|
@ -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<Mutex<LoginState>>,
|
||||
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<AgentResponse> =
|
||||
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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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<ManagerResponse> =
|
||||
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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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<Self> {
|
||||
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 <path>`.
|
||||
/// `socket` is the hyperhive per-container socket (forwarded to the child
|
||||
/// as `--socket <path>`); `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<Mutex<LoginState>>, 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<bool> {
|
||||
async fn run_claude(prompt: &str, files: &TurnFiles, bus: &Bus) -> Result<bool> {
|
||||
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())
|
||||
|
|
|
|||
|
|
@ -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<Mutex<Option<Arc<LoginSession>>>>,
|
||||
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<AppState>) -> axum::Json<StateSnapshot> {
|
|||
.ok()
|
||||
.and_then(|s| s.parse::<u16>().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<AppState>, Form(form): Form<SendForm>) ->
|
|||
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<AppState>, Form(form): Form<ModelFor
|
|||
|
||||
async fn post_compact(State(state): State<AppState>) -> 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!(
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue