Files
luxe/crates/luxe-core/tests/integration_capstone_engine.rs
Evan Whittaker a0666d6c81 luxe 0.1.4: remembered models, wheel-driven lists, and a steadier phone app
- luxe starts on the model you last chose in this project, then the last one anywhere. Signing in
  opens the model picker instead of choosing for you.
- Every list in a modal takes the mouse wheel and a draggable scrollbar.
- The phone app shows reasoning in full, stays put while you read back through a long session, and
  shows a question's answer on its card.
- On Windows, luxe update replaces the running luxe, and a signed-in install no longer sees setup
  again.
- The file tree no longer shows "engine busy" in a large project, loop output is easier to follow,
  and the name is written lowercase.

The CHANGELOG has the full list.
2026-10-20 13:51:34 -05:00

313 lines
12 KiB
Rust

//! Capstone engine integration test — spawns an Engine with a manually-built P16 hook registry + MockProvider.
//!
//! Verifies end-to-end: self-continuation (engine re-drives on agent_end via ContinueLoop),
//! multi-turn iteration through a mock two-phase project, and that the loop terminates
//! via runaway guards when max_turns_per_run is reached.
#![allow(clippy::unwrap_used)]
mod common;
use futures::stream;
use futures::stream::BoxStream;
use luxe_core::engine::{Engine, EngineConfig};
use luxe_core::event::Event;
use luxe_core::message::ContentBlock;
use luxe_core::provider::{CompletionRequest, Provider, ProviderError, ProviderEvent, StopReason};
use luxe_core::session::JsonlSessionStore;
use luxe_core::session::SessionStore;
use luxe_core::tool::ToolRegistry;
use std::sync::Arc;
use tempfile::tempdir;
use tokio::sync::RwLock;
/// Mock provider that simulates a simple two-phase project:
/// Phase 0: "Bootstrap done" → end turn
/// Phase 1: "Core types done" → end turn
struct MockProvider {
turn_count: Arc<RwLock<usize>>,
}
impl MockProvider {
fn new() -> Self {
Self { turn_count: Arc::new(RwLock::new(0)) }
}
}
#[async_trait::async_trait]
impl Provider for MockProvider {
fn name(&self) -> &str {
"mock"
}
async fn stream(
&self,
_req: CompletionRequest,
_cancel: tokio::sync::watch::Receiver<bool>,
) -> Result<BoxStream<'static, ProviderEvent>, ProviderError> {
let mut turn_count = self.turn_count.write().await;
*turn_count += 1;
let current_turn = *turn_count;
let events = if current_turn <= 2 {
// First two turns claim a phase the way a real agent does — by calling `loop_control`,
// not by saying so in prose. Before the review integrator moved to `LoopControl`, the
// phase advanced on any turn at all and this test passed without the call.
vec![
ProviderEvent::Start,
ProviderEvent::TextStart { index: 0 },
ProviderEvent::TextDelta {
index: 0,
delta: format!("Phase {} complete", current_turn / 2),
},
ProviderEvent::TextEnd { index: 0 },
ProviderEvent::ToolCallStart {
index: 1,
id: format!("call-{current_turn}"),
name: "loop_control".into(),
},
ProviderEvent::ToolCallDelta {
index: 1,
json_delta: r#"{"action":"progress"}"#.into(),
},
ProviderEvent::ToolCallEnd { index: 1 },
ProviderEvent::Done { reason: StopReason::ToolCall },
]
} else {
// Subsequent turns: stop the loop
vec![
ProviderEvent::Start,
ProviderEvent::TextStart { index: 0 },
ProviderEvent::TextDelta {
index: 0,
delta: "All phases complete. Stopping loop.".to_string(),
},
ProviderEvent::TextEnd { index: 0 },
ProviderEvent::Done { reason: StopReason::EndTurn },
]
};
Ok(Box::pin(stream::iter(events)))
}
}
#[tokio::test]
async fn test_capstone_engine_end_to_end() {
let dir = tempdir().unwrap();
let repo_root = dir.path().to_path_buf();
// Create mock PROJECT.md and PLAN.md.
tokio::fs::write(
repo_root.join("PROJECT.md"),
"# Test Project\n\n## Phases\n- Phase 0: Bootstrap\n- Phase 1: Core types\n",
)
.await
.unwrap();
tokio::fs::write(
repo_root.join("PLAN.md"),
"# Plan\n\n## Phase 0\nBootstrap.\n\n## Phase 1\nCore types.",
)
.await
.unwrap();
// Set up state paths.
let state_path = repo_root.join(".luxe").join("loop_state.json");
let stop_path = repo_root.join(".luxe").join("STOP");
let journal_path = repo_root.join(".luxe").join("loop").join("PROGRESS.md");
let archive_path = repo_root.join(".luxe").join("loop").join("PROGRESS.archive.md");
tokio::fs::create_dir_all(repo_root.join(".luxe")).await.unwrap();
tokio::fs::create_dir_all(repo_root.join(".luxe").join("loop")).await.unwrap();
// Create a mock PROGRESS.md (small).
tokio::fs::write(&journal_path, "# Progress\n\n## Phase 0\nDone.\n\n## Phase 1\nIn progress.")
.await
.unwrap();
// Build the hook registry and controller.
let controller = Arc::new(luxe_core::loop_controller::LoopController::new(
state_path.clone(),
stop_path.clone(),
));
// A review gate whose acceptance command always passes, so the test is about the loop.
let review_gate_hook =
Arc::new(luxe_core::hooks::review_gate::ReviewGateHook::with_commands(vec![
common::always_succeeds(),
]));
// Build the hook registry manually to use our custom review gate hook.
let mut hook_registry = luxe_core::hook::HookRegistry::new();
hook_registry.register(Arc::new(
luxe_core::hooks::self_continuation::SelfContinuationHook::new(controller.clone()),
));
hook_registry.register(Arc::new(
luxe_core::hooks::context_aware_termination::ContextAwareTerminationHook::new(
controller.clone(),
),
));
hook_registry.register(Arc::new(luxe_core::hooks::journal_bounding::JournalBoundingHook::new(
journal_path.clone(),
archive_path.clone(),
24,
)));
let integrator =
luxe_core::hooks::review_integrator::ReviewIntegratorHook::new(controller.clone())
.with_gate(Arc::new(
luxe_core::phase_gate::PhaseGate::new().with_commands(review_gate_hook),
));
hook_registry.register(Arc::new(integrator));
hook_registry.register(Arc::new(
luxe_core::hooks::completion_challenger::CompletionChallengerHook::new(controller.clone())
.await,
));
hook_registry.register(Arc::new(luxe_core::hooks::runaway_guards::RunawayGuardsHook::new(
controller.clone(),
)));
hook_registry.register(Arc::new(luxe_core::hooks::fresh::FreshHook::new(journal_path.clone())));
// Create a tool registry (empty for this test).
// The loop's phase gate is reached through a tool call, so the registry needs the tool the
// mock calls. `loop_control` itself lives in `luxe-tools`, which depends on this crate.
let mut tool_registry = ToolRegistry::new();
tool_registry.register(Arc::new(common::LoopControlStub));
// Create the session in the store.
let mut store = JsonlSessionStore::new(repo_root.join(".luxe").join("sessions"));
let session_id = store.create("/tmp/test").unwrap();
// Build the engine config.
let config = EngineConfig {
session_store: std::sync::RwLock::new(Box::new(store)),
provider: Arc::new(MockProvider::new()),
providers: std::collections::HashMap::new(),
model: luxe_core::provider::ModelInfo::default(),
tool_registry,
hook_registry,
session_id,
system_prompt: None,
todo_store: None,
compaction_settings: luxe_core::compaction::CompactionSettings::default(),
permission: Default::default(),
modes: Default::default(),
reviewer: None,
formatter_registry: None,
spend_sink: None,
guided_review_project_root: None,
invoked_from: None,
external_work: None,
review_context_files: Vec::new(),
review_exclude: Vec::new(),
remember_choices_in: None,
cache_warming: luxe_core::cache_warming::CacheWarming::Off,
review_insight_provider: None,
github: None,
permissions_file: None,
max_tool_iterations: luxe_core::engine::DEFAULT_MAX_TOOL_ITERATIONS,
startup_notices: Vec::new(),
action_tx: None,
};
// Spawn the engine.
let (action_tx, mut event_rx) = Engine::spawn(config);
// Start the loop controller.
controller.start().await.unwrap();
// Set max_turns_per_run to 5 so the loop self-terminates via runaway guards.
controller
.update_state(|state| {
state.max_turns_per_run = 5;
})
.await;
// Submit a user message to trigger the loop.
action_tx
.send(luxe_core::engine::Action::SubmitUserMessage {
content: "Start the continuous loop and run phases 0 and 1".to_string(),
images: vec![],
remediation: None,
})
.await
.unwrap();
// Collect events for a few seconds to simulate loop execution.
let mut events_collected = 0;
let mut turns_completed = 0;
let timeout = tokio::time::Duration::from_secs(5);
let start = tokio::time::Instant::now();
while start.elapsed() < timeout {
tokio::select! {
event = event_rx.recv() => {
match event {
Some(Event::StateChanged(state)) => {
println!("State changed: {:?}", state);
events_collected += 1;
}
Some(Event::TurnEnded { reason }) => {
println!("Turn ended: {:?}", reason);
turns_completed += 1;
events_collected += 1;
}
Some(Event::TokenDelta { block, delta }) => {
println!("Token delta (block {}): {}", block, &delta[..delta.len().min(50)]);
events_collected += 1;
}
Some(Event::ToolStarted { call_id, name }) => {
println!("Tool started: {} ({})", name, call_id);
events_collected += 1;
}
Some(Event::MessageCommitted { message: msg, .. }) => {
println!("Message committed: {:?}", msg.content.iter().map(|c| match c { ContentBlock::Text(t) => t.clone(), _ => String::new() }).collect::<Vec<_>>());
events_collected += 1;
}
Some(other) => {
println!("Other event: {:?}", other);
events_collected += 1;
}
None => {
println!("Event channel closed");
break;
}
}
}
_ = tokio::time::sleep(tokio::time::Duration::from_millis(100)) => {}
}
// Break after max_turns_per_run turns (5) to avoid waiting for the full timeout.
if turns_completed >= 5 {
break;
}
}
// Assert multi-turn iteration happened.
assert!(
turns_completed >= 3,
"Expected at least 3 turns (Phase 0, Phase 1, stop), got {}",
turns_completed
);
assert!(events_collected >= 5, "Expected at least 5 events, got {}", events_collected);
// Assert phase tracking advanced.
let state = controller.get_state().await;
assert!(
state.current_phase >= 1,
"Expected phase to advance to at least 1, got {}",
state.current_phase
);
// Assert the loop stopped itself (is_running() == false) — proves runaway guards fired.
let state = controller.get_state().await;
assert!(
!state.running,
"Expected loop to stop on its own (max_turns_per_run=5), but is_running() is still true"
);
println!(
"Capstone engine test passed: {} turns, {} events, loop self-terminated",
turns_completed, events_collected
);
}