dedupe: lift drive_turn/emit_turn_end/wait_for_login into hive_ag3nt::turn

hive-ag3nt/src/turn.rs

@@ -5,14 +5,16 @@
 
 use std::path::{Path, PathBuf};
 use std::process::Stdio;
-use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
 
 use anyhow::{Result, bail};
 use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
 use tokio::process::Command;
 
 use crate::events::{Bus, LiveEvent};
+use crate::login::{self, LoginState};
 use crate::mcp;
 
 /// Inline `--settings` JSON applied to every claude invocation. We turn off
@@ -59,6 +61,67 @@ pub enum TurnOutcome {
     Failed(anyhow::Error),
 }
 
+/// 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,
+    bus: &Bus,
+    flavor: mcp::Flavor,
+) -> TurnOutcome {
+    match run_turn(prompt, mcp_config, bus, flavor).await {
+        TurnOutcome::PromptTooLong => {
+            if let Err(e) = compact_session(bus).await {
+                tracing::warn!(error = %format!("{e:#}"), "compact failed");
+                return TurnOutcome::Failed(e);
+            }
+            run_turn(prompt, mcp_config, bus, flavor).await
+        }
+        other => other,
+    }
+}
+
+/// Emit the per-turn `TurnEnd` event + log line. Single owner so the
+/// agent and manager loops agree on outcome semantics.
+pub fn emit_turn_end(bus: &Bus, outcome: &TurnOutcome) {
+    match outcome {
+        TurnOutcome::Ok | TurnOutcome::PromptTooLong => {
+            bus.emit(LiveEvent::TurnEnd {
+                ok: true,
+                note: None,
+            });
+            tracing::info!("turn finished");
+        }
+        TurnOutcome::Failed(e) => {
+            let note = format!("{e:#}");
+            bus.emit(LiveEvent::TurnEnd {
+                ok: false,
+                note: Some(note.clone()),
+            });
+            tracing::warn!(error = %note, "turn failed");
+        }
+    }
+}
+
+/// Block until the bound `~/.claude/` dir contains a session, polling
+/// `claude_dir` on a `poll_ms` interval (min 2s). Flips `state` to
+/// `Online` when login lands; caller resumes its serve loop.
+pub async fn wait_for_login(claude_dir: &Path, state: Arc<Mutex<LoginState>>, poll_ms: u64) {
+    tracing::warn!(
+        claude_dir = %claude_dir.display(),
+        "no claude session — staying in partial-run mode (web UI only)"
+    );
+    let probe = Duration::from_millis(poll_ms.max(2000));
+    loop {
+        tokio::time::sleep(probe).await;
+        if login::has_session(claude_dir) {
+            tracing::info!("claude session detected — entering turn loop");
+            *state.lock().unwrap() = LoginState::Online;
+            return;
+        }
+    }
+}
+
 /// Spawn `claude` for one turn and pump `stream-json` stdout into the
 /// live event bus. Prompt goes over stdin (variadic
 /// `--allowedTools`/`--tools` would otherwise eat a trailing positional