pub mod ccr;
pub mod conventions;
pub(crate) mod deferred_stdio;
pub(crate) mod edit;
pub(crate) mod edit_format;
pub mod edit_hooks;
pub mod edit_plan;
pub(crate) mod edit_tools;
pub mod explore;
pub mod format;
pub mod investigation;
pub(crate) mod knowledge_curation;
pub(crate) mod knowledge_model;
pub(crate) mod knowledge_review;
pub(crate) mod knowledge_search;
pub mod prompts;
pub mod read_gate;
pub(crate) mod read_tools;
pub(crate) mod repeat;
pub mod resources;
pub mod result_status;
pub(crate) mod search_format;
pub(crate) mod search_tools;
pub use crate::knowledge::secret_dismissals;
pub(crate) mod secret_remediate;
pub mod session;
pub mod smart_query;
pub mod surface_probe;
pub(crate) mod tool_contract;
pub mod tools;
pub mod withheld;
use std::path::PathBuf;
use std::sync::Arc;
use std::time::Duration;
use parking_lot::{Mutex, RwLock};
use rmcp::RoleServer;
use rmcp::handler::server::router::prompt::PromptRouter;
use rmcp::handler::server::router::tool::ToolRouter;
use rmcp::model::{
ListResourceTemplatesResult, ListResourcesResult, ListToolsResult, PaginatedRequestParams,
ReadResourceRequestParams, ServerCapabilities, ServerConfig, Tool,
};
use rmcp::service::RequestContext;
use rmcp::{ServerHandler, tool_handler};
use crate::domain::{
CapabilityStatus, CapabilityUnavailableReason, ControlStateDir, ProjectStateDir, StatePlacement,
};
use crate::live_index::SharedIndex;
use crate::protocol::result_status::OutcomeClass;
use crate::sidecar::TokenStats;
use crate::watcher::WatcherInfo;
#[cfg(feature = "server")]
#[derive(Debug, Default)]
pub struct LedgerWriteTracker {
in_flight: std::sync::atomic::AtomicUsize,
}
#[cfg(feature = "server")]
impl LedgerWriteTracker {
fn begin(self: &std::sync::Arc<Self>) -> LedgerWriteGuard {
self.in_flight
.fetch_add(1, std::sync::atomic::Ordering::AcqRel);
LedgerWriteGuard(std::sync::Arc::clone(self))
}
fn pending(&self) -> usize {
self.in_flight.load(std::sync::atomic::Ordering::Acquire)
}
pub async fn drain(&self, timeout: std::time::Duration) {
let deadline = std::time::Instant::now() + timeout;
while self.pending() != 0 {
if std::time::Instant::now() >= deadline {
tracing::warn!(
pending = self.pending(),
"durable ledger drain timed out; some economics events may be unwritten"
);
return;
}
tokio::time::sleep(std::time::Duration::from_millis(10)).await;
}
}
}
#[cfg(feature = "server")]
struct LedgerWriteGuard(std::sync::Arc<LedgerWriteTracker>);
#[cfg(feature = "server")]
impl Drop for LedgerWriteGuard {
fn drop(&mut self) {
self.0
.in_flight
.fetch_sub(1, std::sync::atomic::Ordering::AcqRel);
}
}
#[cfg(all(test, feature = "server"))]
mod ledger_write_tracker_tests {
use super::LedgerWriteTracker;
use std::sync::Arc;
use std::time::Duration;
#[tokio::test]
async fn drain_returns_after_pending_write_completes() {
let tracker = Arc::new(LedgerWriteTracker::default());
let guard = tracker.begin();
assert_eq!(tracker.pending(), 1);
let t2 = Arc::clone(&tracker);
tokio::spawn(async move {
tokio::time::sleep(Duration::from_millis(20)).await;
drop(guard);
let _ = &t2;
});
tracker.drain(Duration::from_secs(2)).await;
assert_eq!(
tracker.pending(),
0,
"drain returned with a write still pending"
);
}
#[tokio::test]
async fn drain_times_out_without_hanging_on_a_stuck_write() {
let tracker = Arc::new(LedgerWriteTracker::default());
let _held = tracker.begin(); let start = std::time::Instant::now();
tracker.drain(Duration::from_millis(50)).await;
assert!(
start.elapsed() >= Duration::from_millis(50),
"drain returned before the timeout elapsed"
);
assert_eq!(tracker.pending(), 1, "stuck write must still be counted");
}
}
pub(crate) const DAEMON_RECONNECT_COOLDOWN: std::time::Duration =
std::time::Duration::from_secs(30);
#[derive(Default, Debug)]
pub(crate) struct DaemonDegradation {
pub degraded: bool,
pub last_failure: Option<String>,
pub last_failure_at: Option<std::time::Instant>,
pub last_endpoint: Option<String>,
pub last_reconnect_attempt: Option<std::time::Instant>,
}
#[derive(Debug, Clone)]
pub struct DaemonDegradationSnapshot {
pub endpoint: String,
pub last_failure: String,
pub retry_after_secs: u64,
}
#[derive(Clone)]
pub struct SymForgeServer {
pub(crate) index: crate::live_index::index_lifecycle::activation::ProjectRuntimeHandle,
pub(crate) tool_router: ToolRouter<Self>,
pub(crate) prompt_router: PromptRouter<Self>,
pub(crate) project_name: String,
pub(crate) watcher_info: Arc<Mutex<WatcherInfo>>,
pub(crate) watcher_handle: Arc<Mutex<Option<crate::watcher::WatcherTaskHandle>>>,
pub(crate) repo_root: Arc<RwLock<Option<PathBuf>>>,
pub(crate) state_placement: Arc<RwLock<Option<StatePlacement>>>,
pub(crate) control_state_dir: Option<ControlStateDir>,
pub(crate) persistence_health: Arc<RwLock<CapabilityStatus>>,
pub(crate) curation_coordinator: Arc<knowledge_curation::KnowledgeCurationCoordinator>,
pub(crate) token_stats: Option<Arc<TokenStats>>,
pub(crate) daemon_client: Option<Arc<tokio::sync::RwLock<crate::daemon::DaemonSessionClient>>>,
pub(crate) daemon_degraded: Arc<Mutex<DaemonDegradation>>,
pub(crate) descriptor_state_dir: Arc<RwLock<Option<ControlStateDir>>>,
pub(crate) caller_declared_root: Arc<RwLock<Option<PathBuf>>>,
pub(crate) session_context: Arc<session::SessionContext>,
pub(crate) ccr_store: Arc<Mutex<ccr::CcrStore>>,
pub(crate) stel_ledger: Arc<Mutex<crate::stel::ledger::SessionLedger>>,
pub(crate) repeat_tracker: Arc<Mutex<repeat::RepeatTracker>>,
pub(crate) transport_lane: repeat::TransportLane,
pub(crate) worktree_misuse: Arc<crate::worktree::WorktreeMisuseCounter>,
pub(crate) analytics_recorder: Arc<RwLock<crate::analytics::AnalyticsRecorder>>,
#[cfg(feature = "server")]
pub(crate) stel_ledger_store: Option<Arc<crate::stel::ledger_store::StelLedgerStore>>,
#[cfg(feature = "server")]
pub(crate) ledger_writes: Arc<LedgerWriteTracker>,
}
fn default_analytics_db_path(project_state_dir: Option<&ProjectStateDir>) -> PathBuf {
project_state_dir
.map(|state_dir| {
crate::paths::project_state_path(state_dir, crate::paths::ANALYTICS_DB_NAME)
})
.unwrap_or_default()
}
fn disabled_analytics_recorder(
project_state_dir: Option<&ProjectStateDir>,
) -> crate::analytics::AnalyticsRecorder {
crate::analytics::AnalyticsRecorder::disabled(default_analytics_db_path(project_state_dir))
}
impl SymForgeServer {
pub(crate) fn tool_router() -> ToolRouter<Self> {
Self::core_tool_router() + Self::edit_tool_router() + Self::secret_remediate_tool_router()
}
pub fn new(
index: SharedIndex,
project_name: String,
watcher_info: Arc<Mutex<WatcherInfo>>,
repo_root: Option<PathBuf>,
token_stats: Option<Arc<TokenStats>>,
) -> Self {
let (repo_root, state_placement) = match repo_root.as_deref() {
Some(root) => match crate::discovery::resolve_root_candidate(
root,
crate::domain::RootCandidateSource::LaunchCwd,
crate::domain::RootRequestMode::Automatic,
) {
crate::domain::RootResolution::Bound(binding) => {
let placement = crate::discovery::resolve_state_placement(&binding);
(Some(binding.canonical_root), Some(placement))
}
crate::domain::RootResolution::Unbound { .. } => (None, None),
},
None => (None, None),
};
Self::new_with_state_placement(
index,
project_name,
watcher_info,
repo_root,
state_placement,
token_stats,
)
}
pub fn new_with_state_placement(
index: SharedIndex,
project_name: String,
watcher_info: Arc<Mutex<WatcherInfo>>,
repo_root: Option<PathBuf>,
state_placement: Option<StatePlacement>,
token_stats: Option<Arc<TokenStats>>,
) -> Self {
crate::worktree::register_if_feature_enabled();
let analytics_recorder = disabled_analytics_recorder(
state_placement.as_ref().and_then(StatePlacement::directory),
);
let persistence_health = if matches!(
state_placement.as_ref(),
Some(StatePlacement::ProjectLocal { .. } | StatePlacement::UserLocal { .. })
) {
CapabilityStatus::Available
} else {
CapabilityStatus::Unavailable {
reason: CapabilityUnavailableReason::PersistentStateUnavailable,
}
};
let curation_coordinator =
Arc::new(knowledge_curation::KnowledgeCurationCoordinator::default());
let phase = std::time::Instant::now();
if let Some(root) = repo_root.as_deref()
&& let Err(error) = curation_coordinator.recover_on_project_load(
&index,
root,
state_placement.as_ref(),
persistence_health,
)
{
tracing::warn!("knowledge curation startup recovery remained fail-closed: {error}");
}
tracing::info!(
"serve: protocol/curation recover_on_project_load in {:?}",
phase.elapsed()
);
let phase = std::time::Instant::now();
let tool_router = Self::tool_router();
let prompt_router = Self::prompt_router();
tracing::info!("serve: protocol/routers in {:?}", phase.elapsed());
Self {
index: crate::live_index::index_lifecycle::activation::ProjectRuntimeHandle::bind(
index,
),
tool_router,
prompt_router,
project_name,
watcher_info,
watcher_handle: Arc::new(Mutex::new(None)),
repo_root: Arc::new(RwLock::new(repo_root)),
state_placement: Arc::new(RwLock::new(state_placement)),
control_state_dir: crate::paths::process_control_state_placement()
.directory()
.cloned(),
persistence_health: Arc::new(RwLock::new(persistence_health)),
curation_coordinator,
token_stats,
daemon_client: None,
daemon_degraded: Arc::new(Mutex::new(DaemonDegradation::default())),
descriptor_state_dir: Arc::new(RwLock::new(None)),
caller_declared_root: Arc::new(RwLock::new(None)),
session_context: Arc::new(session::SessionContext::new()),
ccr_store: Arc::new(Mutex::new(ccr::CcrStore::new())),
stel_ledger: Arc::new(Mutex::new(crate::stel::ledger::SessionLedger::new())),
repeat_tracker: Arc::new(Mutex::new(repeat::RepeatTracker::default())),
transport_lane: repeat::TransportLane::default(),
worktree_misuse: Arc::new(crate::worktree::WorktreeMisuseCounter::new()),
analytics_recorder: Arc::new(RwLock::new(analytics_recorder)),
#[cfg(feature = "server")]
stel_ledger_store: None,
#[cfg(feature = "server")]
ledger_writes: Arc::new(LedgerWriteTracker::default()),
}
}
pub fn new_daemon_proxy(daemon_client: crate::daemon::DaemonSessionClient) -> Self {
let repo_root = daemon_client.project_root().map(|p| p.to_path_buf());
let state_placement = repo_root.as_deref().and_then(|root| {
match crate::discovery::resolve_root_candidate(
root,
crate::domain::RootCandidateSource::LaunchCwd,
crate::domain::RootRequestMode::Automatic,
) {
crate::domain::RootResolution::Bound(binding) => {
Some(crate::discovery::resolve_state_placement(&binding))
}
crate::domain::RootResolution::Unbound { .. } => None,
}
});
Self::new_daemon_proxy_with_state_placement(daemon_client, state_placement)
}
pub fn new_daemon_proxy_with_state_placement(
daemon_client: crate::daemon::DaemonSessionClient,
state_placement: Option<StatePlacement>,
) -> Self {
use crate::watcher::WatcherInfo;
crate::worktree::register_if_feature_enabled();
let project_name = daemon_client.project_name().to_string();
let repo_root = daemon_client.project_root().map(|p| p.to_path_buf());
let analytics_recorder = disabled_analytics_recorder(
state_placement.as_ref().and_then(StatePlacement::directory),
);
let persistence_health = if matches!(
state_placement.as_ref(),
Some(StatePlacement::ProjectLocal { .. } | StatePlacement::UserLocal { .. })
) {
CapabilityStatus::Available
} else {
CapabilityStatus::Unavailable {
reason: CapabilityUnavailableReason::PersistentStateUnavailable,
}
};
Self {
index: crate::live_index::index_lifecycle::activation::ProjectRuntimeHandle::bind(
crate::live_index::LiveIndex::empty(),
),
tool_router: Self::tool_router(),
prompt_router: Self::prompt_router(),
project_name,
watcher_info: Arc::new(Mutex::new(WatcherInfo::default())),
watcher_handle: Arc::new(Mutex::new(None)),
repo_root: Arc::new(RwLock::new(repo_root)),
state_placement: Arc::new(RwLock::new(state_placement)),
control_state_dir: Some(daemon_client.control_state_dir().clone()),
persistence_health: Arc::new(RwLock::new(persistence_health)),
curation_coordinator: Arc::new(
knowledge_curation::KnowledgeCurationCoordinator::default(),
),
token_stats: None,
daemon_client: Some(Arc::new(tokio::sync::RwLock::new(daemon_client))),
daemon_degraded: Arc::new(Mutex::new(DaemonDegradation::default())),
descriptor_state_dir: Arc::new(RwLock::new(None)),
caller_declared_root: Arc::new(RwLock::new(None)),
session_context: Arc::new(session::SessionContext::new()),
ccr_store: Arc::new(Mutex::new(ccr::CcrStore::new())),
stel_ledger: Arc::new(Mutex::new(crate::stel::ledger::SessionLedger::new())),
repeat_tracker: Arc::new(Mutex::new(repeat::RepeatTracker::default())),
transport_lane: repeat::TransportLane::default(),
worktree_misuse: Arc::new(crate::worktree::WorktreeMisuseCounter::new()),
analytics_recorder: Arc::new(RwLock::new(analytics_recorder)),
#[cfg(feature = "server")]
stel_ledger_store: None,
#[cfg(feature = "server")]
ledger_writes: Arc::new(LedgerWriteTracker::default()),
}
}
#[cfg(feature = "server")]
pub fn with_stel_ledger_store(
mut self,
store: Arc<crate::stel::ledger_store::StelLedgerStore>,
) -> Self {
self.stel_ledger_store = Some(store);
self
}
pub fn with_stdio_transport_lane(mut self) -> Self {
self.transport_lane = repeat::TransportLane::Stdio;
self
}
#[cfg(feature = "server")]
fn persist_ledger_event_durably(&self, event: &crate::stel::types::StelLedgerEvent) {
let Some(store) = self.stel_ledger_store.as_ref() else {
return;
};
match tokio::runtime::Handle::try_current() {
Ok(handle) => {
let store = Arc::clone(store);
let event = event.clone();
let guard = self.ledger_writes.begin();
handle.spawn_blocking(move || {
let _guard = guard; store.record(&event);
Self::maybe_persist_tuning(&store);
});
}
Err(_) => {
crate::stel::runtime::record_durably_inline(store, event);
}
}
}
#[cfg(feature = "server")]
pub(crate) fn ledger_write_tracker(&self) -> &Arc<LedgerWriteTracker> {
&self.ledger_writes
}
#[cfg(feature = "server")]
fn maybe_persist_tuning(store: &crate::stel::ledger_store::StelLedgerStore) {
crate::stel::runtime::maybe_persist_tuning(store)
}
#[cfg(feature = "server")]
pub(crate) fn active_tuning_for_economics(
&self,
) -> Option<crate::stel::ledger_store::TunedEstimateConstants> {
crate::stel::runtime::active_tuning_for_economics(self.stel_ledger_store.as_deref())
}
#[cfg(feature = "server")]
pub(crate) fn durable_calibration_verdict(
&self,
) -> Option<crate::stel::calibration::CalibrationVerdict> {
crate::stel::runtime::durable_calibration_verdict(self.stel_ledger_store.as_deref())
}
#[cfg(feature = "server")]
pub(crate) fn reset_calibration(&self) -> Option<usize> {
crate::stel::runtime::reset_calibration(self.stel_ledger_store.as_deref())
}
#[cfg(not(feature = "server"))]
#[inline]
fn persist_ledger_event_durably(&self, _event: &crate::stel::types::StelLedgerEvent) {}
#[cfg(feature = "server")]
fn durable_ledger_summary_for_status(&self) -> crate::stel::status::DurableLedgerState {
crate::stel::runtime::durable_ledger_state(self.stel_ledger_store.as_deref())
}
#[cfg(not(feature = "server"))]
#[inline]
fn durable_ledger_summary_for_status(&self) -> crate::stel::status::DurableLedgerState {
crate::stel::status::DurableLedgerState::Unavailable
}
pub fn index(&self) -> &crate::live_index::index_lifecycle::activation::ProjectRuntimeHandle {
&self.index
}
#[doc(hidden)]
pub fn stel_ledger(&self) -> &Arc<Mutex<crate::stel::ledger::SessionLedger>> {
&self.stel_ledger
}
#[doc(hidden)]
pub fn drop_ccr_blob_for_tests(&self, handle: &str) -> bool {
self.ccr_store.lock().remove_blob(handle)
}
pub fn tool_definitions() -> Vec<Tool> {
Self::tool_router().list_all()
}
pub(crate) fn capture_repo_root(&self) -> Option<PathBuf> {
self.repo_root.read().clone()
}
pub(crate) fn capture_state_placement(&self) -> Option<StatePlacement> {
self.state_placement.read().clone()
}
pub(crate) fn capture_control_state_dir(&self) -> Option<ControlStateDir> {
self.control_state_dir.clone()
}
#[cfg(test)]
pub(crate) fn with_control_state_dir_for_test(
mut self,
control_state_dir: ControlStateDir,
) -> Self {
self.control_state_dir = Some(control_state_dir);
self
}
pub(crate) fn capture_project_state_dir(&self) -> Option<ProjectStateDir> {
self.state_placement
.read()
.as_ref()
.and_then(StatePlacement::directory)
.cloned()
}
pub(crate) fn bump_frecency(&self, paths: &[PathBuf]) {
if let Some(root) = self.capture_repo_root() {
let project_state = self.capture_project_state_dir();
crate::live_index::frecency::bump(&root, project_state.as_ref(), paths);
}
}
pub(crate) fn effective_repo_root_for_git_tools(&self) -> Option<PathBuf> {
self.capture_repo_root()
.or_else(crate::discovery::find_project_root)
}
pub(crate) fn set_repo_root(&self, repo_root: Option<PathBuf>) {
*self.repo_root.write() = repo_root.clone();
if self.analytics_recorder.read().status().disabled {
let state_dir = self.capture_project_state_dir();
*self.analytics_recorder.write() = disabled_analytics_recorder(state_dir.as_ref());
}
}
pub(crate) fn set_bound_project_state(
&self,
repo_root: Option<PathBuf>,
state_placement: Option<StatePlacement>,
) {
*self.persistence_health.write() = if matches!(
state_placement.as_ref(),
Some(StatePlacement::ProjectLocal { .. } | StatePlacement::UserLocal { .. })
) {
CapabilityStatus::Available
} else {
CapabilityStatus::Unavailable {
reason: CapabilityUnavailableReason::PersistentStateUnavailable,
}
};
*self.state_placement.write() = state_placement;
self.set_repo_root(repo_root);
}
pub(crate) fn note_worktree_misuse_if_active(&self, working_directory: Option<&str>) {
if working_directory.is_none()
&& crate::worktree::routing_policy_from_env()
== crate::capability::WorktreeRoutingPolicy::ExplicitCallTime
{
self.worktree_misuse.record_missing_working_directory();
}
}
pub(crate) fn record_read_savings(&self, saved_tokens: u64) {
if let Some(ref stats) = self.token_stats {
stats
.read_saved_tokens
.fetch_add(saved_tokens, std::sync::atomic::Ordering::Relaxed);
stats
.read_fires
.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
}
}
pub(crate) fn record_tool_savings_named(
&self,
tool_name: &str,
estimated_raw_tokens: u64,
output_tokens: u64,
) {
if let Some(ref stats) = self.token_stats {
let saved = estimated_raw_tokens.saturating_sub(output_tokens);
stats
.read_saved_tokens
.fetch_add(saved, std::sync::atomic::Ordering::Relaxed);
stats
.read_fires
.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
stats.record_tool_tokens(tool_name, output_tokens, saved);
}
}
pub(crate) fn ccr_publication_identity(&self) -> Option<ccr::CcrPublicationIdentity> {
let published = self.index.data_plane().published_generation();
let source = published.source.as_deref()?;
let bytes = serde_json::to_vec(source).ok()?;
Some(ccr::CcrPublicationIdentity {
source_digest: crate::hash::digest_hex(&bytes),
content_generation: published.content_generation,
})
}
pub(crate) fn apply_ccr_budget(
&self,
tool_name: &str,
result: String,
max_tokens: Option<u64>,
) -> String {
let budget = ccr::resolve_tool_max_tokens(tool_name, max_tokens);
if ccr::profile_for_tool(tool_name).is_some_and(|p| p.ccr_eligible) {
let publication = self.ccr_publication_identity();
let mut store = self.ccr_store.lock();
return ccr::enforce_token_budget_with_ccr(
&mut store,
tool_name,
result,
budget,
publication,
);
}
format::enforce_token_budget(result, budget)
}
pub(crate) fn apply_ccr_budget_with_truncation_status(
&self,
tool_name: &str,
result: String,
max_tokens: Option<u64>,
) -> (String, bool) {
let budget = ccr::resolve_tool_max_tokens(tool_name, max_tokens);
let truncated = budget
.is_some_and(|tokens| tokens > 0 && result.len() > (tokens as usize).saturating_mul(4));
(
self.apply_ccr_budget(tool_name, result, max_tokens),
truncated,
)
}
pub(crate) fn apply_ccr_budget_with_summary(
&self,
tool_name: &str,
result: String,
summary: String,
max_tokens: Option<u64>,
) -> String {
let budget = ccr::resolve_tool_max_tokens(tool_name, max_tokens);
let Some(tokens) = budget.filter(|tokens| *tokens > 0) else {
return result;
};
if ccr::profile_for_tool(tool_name).is_some_and(|profile| profile.ccr_eligible) {
let summary = format::enforce_token_budget(summary, Some(tokens));
let publication = self.ccr_publication_identity();
let mut store = self.ccr_store.lock();
return ccr::apply_ccr_overflow(
&mut store,
tool_name,
summary,
result,
tokens,
publication,
);
}
format::enforce_token_budget(result, Some(tokens))
}
pub(crate) fn format_read_cache_hit(
&self,
meta: &crate::protocol::session::SessionCacheHitMeta,
reason: &str,
) -> Option<String> {
self.ccr_store.lock().get(&meta.retrieve_handle)?;
self.session_context.record_cache_hit();
Some(format::format_session_cache_hit_body(meta, reason))
}
pub(crate) fn compression_economics(&self) -> crate::protocol::ccr::CcrEconomics {
self.ccr_store.lock().economics()
}
pub fn session_compression_heuristic(
&self,
) -> crate::protocol::ccr::SessionCompressionHeuristic {
let cache_hits = self.session_context.snapshot().cache_hit_count;
crate::protocol::ccr::SessionCompressionHeuristic::from_parts(
cache_hits,
self.compression_economics(),
)
}
pub(crate) fn record_tool_completion(
&self,
tool_name: &'static str,
response_text: &str,
duration: Duration,
outcome_class: OutcomeClass,
) {
self.record_tool_completion_with_success(
tool_name,
response_text,
duration,
outcome_class,
!outcome_class.is_error(),
);
}
pub(crate) fn record_tool_completion_with_success(
&self,
tool_name: &'static str,
response_text: &str,
duration: Duration,
outcome_class: OutcomeClass,
success: bool,
) {
let recorder = self.analytics_recorder.read().clone();
let response_bytes = response_text.len() as u64;
let observation = crate::analytics::AnalyticsObservation::new(
tool_name,
crate::analytics::AnalyticsSurface::Tool,
recorder.configured_scope(),
response_bytes,
Some(crate::stel::handler::estimate_tokens_from_bytes(
response_bytes,
)),
duration,
success,
outcome_class,
);
let _ = recorder.enqueue(observation);
}
#[cfg(test)]
pub(crate) fn set_analytics_recorder_for_tests(
&self,
recorder: crate::analytics::AnalyticsRecorder,
) {
*self.analytics_recorder.write() = recorder;
}
#[cfg(test)]
pub(crate) fn analytics_queue_status_for_tests(
&self,
) -> crate::analytics::AnalyticsQueueStatus {
self.analytics_recorder.read().status()
}
fn restore_local_project_evidence(&self) {
if let Some(evidence) = self.local_project_evidence() {
result_status::record_project_evidence(evidence);
} else {
result_status::clear_project_evidence();
}
}
fn validate_daemon_project_evidence(
&self,
params: &serde_json::Value,
expected_project_id: Option<&str>,
) {
if params
.get("projects")
.is_some_and(|projects| !projects.is_null())
{
result_status::clear_project_evidence();
return;
}
let selector = match params.get("project") {
None | Some(serde_json::Value::Null) => None,
Some(serde_json::Value::String(project)) => {
Some(project.as_str()).filter(|project| !project.trim().is_empty())
}
Some(_) => {
result_status::clear_project_evidence();
return;
}
};
let receipt_selector = expected_project_id.or(selector);
let valid = result_status::current_project_evidence().is_some_and(|evidence| {
result_status::project_evidence_matches_selector(&evidence, receipt_selector)
});
if !valid {
result_status::clear_project_evidence();
}
}
async fn initial_project_evidence_for_call(
&self,
arguments: Option<&serde_json::Map<String, serde_json::Value>>,
) -> Option<result_status::ProjectEvidence> {
fn object_matches_local(
object: &serde_json::Map<String, serde_json::Value>,
local: &result_status::ProjectEvidence,
) -> bool {
if object
.get("projects")
.is_some_and(|projects| !projects.is_null())
{
return false;
}
if let Some(project) = object.get("project")
&& !project.is_null()
{
let Some(project) = project.as_str() else {
return false;
};
if !project.trim().is_empty()
&& !result_status::project_evidence_matches_selector(local, Some(project))
{
return false;
}
}
if let Some(nested) = object
.get("_probe_legacy_args")
.and_then(serde_json::Value::as_object)
&& !object_matches_local(nested, local)
{
return false;
}
true
}
fn explicit_scalar_selector(
object: &serde_json::Map<String, serde_json::Value>,
) -> Option<&str> {
object
.get("project")
.and_then(serde_json::Value::as_str)
.filter(|project| !project.trim().is_empty())
.or_else(|| {
object
.get("_probe_legacy_args")
.and_then(serde_json::Value::as_object)
.and_then(explicit_scalar_selector)
})
}
let local = self.local_project_evidence()?;
if arguments.is_some_and(|arguments| !object_matches_local(arguments, &local)) {
return None;
}
if let Some(daemon_lock) = self.daemon_client.as_ref() {
let client = daemon_lock.read().await;
let targets_home = match arguments.and_then(explicit_scalar_selector) {
Some(selector) => client
.opened_project_for_selector(Some(selector))
.is_some_and(|(_, _, is_home)| is_home),
None => client.active_project_is_home(),
};
if !targets_home {
return None;
}
}
Some(local)
}
pub(crate) async fn proxy_tool_call<T>(&self, tool_name: &str, params: &T) -> Option<String>
where
T: serde::Serialize,
{
let daemon_lock = self.daemon_client.as_ref()?;
let was_degraded = self.daemon_degraded.lock().degraded;
let mut value = match serde_json::to_value(params) {
Ok(value) => value,
Err(error) => {
result_status::record_read_outcome(result_status::ReadOutcome::InvalidRequest);
return Some(format!("Daemon proxy serialization failed: {error}"));
}
};
let (local_fallback_refusal, expected_daemon_project_id) = {
let client = daemon_lock.read().await;
let has_project_topology =
client.project_root().is_some() || client.activated_root().is_some();
if value
.get("projects")
.is_some_and(|projects| !projects.is_null())
{
(
Some(format!(
"Error: project_routing: a set-valued daemon request cannot fall back to \
adapter HOME project '{}'. Restore daemon routing and retry.",
client.project_id()
)),
None,
)
} else {
match value.get("project") {
Some(serde_json::Value::String(selector)) if !selector.trim().is_empty() => {
match client.opened_project_for_selector(Some(selector)) {
Some((project_id, _, true)) => (None, Some(project_id)),
Some((project_id, _, false)) => (
Some(format!(
"Error: project_routing: daemon project '{project_id}' cannot \
fall back to adapter HOME project '{}'. Restore daemon routing \
and retry.",
client.project_id()
)),
Some(project_id),
),
None => (
Some(format!(
"Error: project_routing: project selector '{}' cannot be resolved \
for safe HOME fallback. Restore daemon routing and retry.",
selector
)),
Some(if has_project_topology {
"\0unresolved-project-selector".to_string()
} else {
selector.to_string()
}),
),
}
}
Some(serde_json::Value::Null) | None => {
let active_project_id = client.active_project_id();
(
(!client.active_project_is_home()).then(|| {
format!(
"Error: project_routing: ACTIVE daemon project '{}' cannot fall \
back to adapter HOME project '{}'. Restore daemon routing and \
retry.",
active_project_id,
client.project_id()
)
}),
has_project_topology.then_some(active_project_id),
)
}
Some(_) => (
Some(format!(
"Error: project_routing: a malformed project selector cannot inherit \
adapter HOME project '{}'. Correct the selector and retry.",
client.project_id()
)),
None,
),
}
}
};
if let Some(object) = value.as_object_mut() {
object.remove(crate::daemon::PRIVATE_PROJECT_ROUTE_PIN);
if let Some(project) = object.get_mut("project")
&& project.is_null()
&& let Some(expected_project_id) = expected_daemon_project_id.as_ref()
{
*project = serde_json::Value::String(expected_project_id.clone());
} else if !object.contains_key("project")
&& crate::daemon::private_project_routed_tool(tool_name)
&& let Some(expected_project_id) = expected_daemon_project_id.as_ref()
{
object.insert(
crate::daemon::PRIVATE_PROJECT_ROUTE_PIN.to_string(),
serde_json::Value::String(expected_project_id.clone()),
);
}
}
result_status::clear_project_evidence();
{
let client = daemon_lock.read().await;
match tokio::time::timeout(
std::time::Duration::from_secs(30),
client.call_tool_value(tool_name, value.clone()),
)
.await
{
Ok(Ok(result)) => {
self.validate_daemon_project_evidence(
&value,
expected_daemon_project_id.as_deref(),
);
self.note_daemon_recovered();
return Some(result);
}
Ok(Err(error)) => {
self.note_daemon_failure(client.base_url(), error.to_string());
tracing::warn!(
tool = tool_name,
"daemon proxy call failed, attempting reconnect: {error}"
);
}
Err(_elapsed) => {
self.note_daemon_failure(
client.base_url(),
"probe timed out after 30s".to_string(),
);
tracing::warn!(
tool = tool_name,
"daemon proxy call timed out after 30s, attempting reconnect"
);
}
}
}
if was_degraded {
let cooling = self
.daemon_degraded
.lock()
.last_reconnect_attempt
.map(|attempt| attempt.elapsed() < DAEMON_RECONNECT_COOLDOWN)
.unwrap_or(false);
if cooling {
tracing::warn!(
tool = tool_name,
"daemon proxy probe failed while degraded (reconnect cooldown active), falling back to local execution"
);
if let Some(refusal) = local_fallback_refusal.clone() {
result_status::clear_project_evidence();
result_status::record_read_outcome(result_status::ReadOutcome::InvalidRequest);
return Some(refusal);
}
self.ensure_local_index().await;
self.restore_local_project_evidence();
return None;
}
tracing::info!(
"daemon degraded past reconnect cooldown; attempting bounded rediscovery"
);
}
let _reconnect_activation_guard = if tool_name == "index_folder" {
None
} else {
let lane = daemon_lock.read().await.activation_lane();
Some(lane.lock_owned().await)
};
let reconnected = {
let mut client = daemon_lock.write().await;
self.daemon_degraded.lock().last_reconnect_attempt = Some(std::time::Instant::now());
match client.reconnect().await {
Ok(new_client) => {
tracing::info!("daemon reconnected successfully");
let old_client = std::mem::replace(&mut *client, new_client);
self.repeat_tracker.lock().clear();
self.republish_session_descriptor(&client);
if let Err(error) = old_client.close().await {
tracing::debug!(
"previous daemon session close after reconnect failed (usually dead endpoint): {error}"
);
}
self.note_daemon_recovered();
true
}
Err(reconnect_error) => {
tracing::warn!(
"daemon reconnect failed, falling back to local execution: {reconnect_error}"
);
self.note_daemon_failure(
client.base_url(),
format!("reconnect failed: {reconnect_error}"),
);
if local_fallback_refusal.is_none() {
self.ensure_local_index().await;
}
false
}
}
};
if !reconnected {
if let Some(refusal) = local_fallback_refusal.clone() {
result_status::clear_project_evidence();
result_status::record_read_outcome(result_status::ReadOutcome::InvalidRequest);
return Some(refusal);
}
self.restore_local_project_evidence();
return None;
}
{
let client = daemon_lock.read().await;
match tokio::time::timeout(
std::time::Duration::from_secs(30),
client.call_tool_value(tool_name, value.clone()),
)
.await
{
Ok(Ok(result)) => {
self.validate_daemon_project_evidence(
&value,
expected_daemon_project_id.as_deref(),
);
self.note_daemon_recovered();
Some(result)
}
Ok(Err(error)) => {
tracing::warn!(
tool = tool_name,
"daemon proxy call failed after reconnect, falling back to local: {error}"
);
self.note_daemon_failure(client.base_url(), error.to_string());
if let Some(refusal) = local_fallback_refusal.clone() {
result_status::clear_project_evidence();
result_status::record_read_outcome(
result_status::ReadOutcome::InvalidRequest,
);
return Some(refusal);
}
self.ensure_local_index().await;
self.restore_local_project_evidence();
None
}
Err(_elapsed) => {
tracing::warn!(
tool = tool_name,
"daemon proxy call timed out after reconnect, falling back to local"
);
self.note_daemon_failure(
client.base_url(),
"post-reconnect call timed out after 30s".to_string(),
);
if let Some(refusal) = local_fallback_refusal {
result_status::clear_project_evidence();
result_status::record_read_outcome(
result_status::ReadOutcome::InvalidRequest,
);
return Some(refusal);
}
self.ensure_local_index().await;
self.restore_local_project_evidence();
None
}
}
}
}
fn note_daemon_recovered(&self) {
let was_degraded = {
let mut state = self.daemon_degraded.lock();
let was_degraded = state.degraded;
if was_degraded {
tracing::info!("daemon proxy recovered; clearing degraded state");
}
*state = DaemonDegradation::default();
was_degraded
};
if was_degraded {
self.repeat_tracker.lock().clear();
}
}
fn note_daemon_failure(&self, endpoint: &str, failure: String) {
let was_healthy = {
let mut state = self.daemon_degraded.lock();
let was_healthy = !state.degraded;
state.degraded = true;
state.last_failure = Some(failure);
state.last_failure_at = Some(std::time::Instant::now());
state.last_endpoint = Some(endpoint.to_string());
was_healthy
};
if was_healthy {
self.repeat_tracker.lock().clear();
}
}
pub(crate) fn daemon_degradation_snapshot(&self) -> Option<DaemonDegradationSnapshot> {
let state = self.daemon_degraded.lock();
if !state.degraded {
return None;
}
Some(DaemonDegradationSnapshot {
endpoint: state
.last_endpoint
.clone()
.unwrap_or_else(|| "(unknown)".to_string()),
last_failure: state
.last_failure
.clone()
.unwrap_or_else(|| "(unrecorded)".to_string()),
retry_after_secs: state
.last_reconnect_attempt
.map(|attempt| {
DAEMON_RECONNECT_COOLDOWN
.as_secs()
.saturating_sub(attempt.elapsed().as_secs())
})
.unwrap_or(0),
})
}
fn republish_session_descriptor(&self, client: &crate::daemon::DaemonSessionClient) {
let state_dir = self.descriptor_state_dir.read().clone();
let (Some(state_dir), Some(port)) = (state_dir, client.port()) else {
return;
};
if let Err(error) = crate::sidecar::port_file::write_session_descriptor(
&state_dir,
port,
Some(client.session_id()),
client.project_root(),
client.daemon_started_at(),
) {
tracing::warn!("failed to republish session descriptor after reconnect: {error}");
}
}
pub fn daemon_client_slot(
&self,
) -> Option<Arc<tokio::sync::RwLock<crate::daemon::DaemonSessionClient>>> {
self.daemon_client.clone()
}
pub fn set_descriptor_state_dir(&self, state_dir: ControlStateDir) {
*self.descriptor_state_dir.write() = Some(state_dir);
}
pub(crate) async fn proxy_tool_call_without_params(&self, tool_name: &str) -> Option<String> {
self.proxy_tool_call(tool_name, &serde_json::json!({}))
.await
}
async fn ensure_local_index(&self) {
{
let mut watcher = self.watcher_info.lock();
*watcher = WatcherInfo::detached_local_fallback();
}
let repo_root = self.capture_repo_root();
let published = self.index.data_plane().published_state();
if published.file_count > 0 {
let target_root = repo_root
.as_deref()
.map(crate::live_index::store::normalize_root);
match (&published.indexed_root, &target_root) {
(Some(indexed), Some(target)) if indexed == target => return,
(_, None) => return,
_ => {}
}
}
if let Some(root) = repo_root {
tracing::info!(
root = %root.display(),
"daemon unreachable — loading local index as fallback"
);
match self.index.data_plane().reload(&root) {
Ok(()) => {
let published = self.index.data_plane().published_state();
tracing::info!(
files = published.file_count,
symbols = published.symbol_count,
"local fallback index loaded"
);
self.repeat_tracker.lock().clear();
let expected_gen = self.index.data_plane().current_project_generation();
crate::live_index::git_temporal::spawn_git_temporal_computation(
self.index.shared(),
root,
expected_gen,
);
}
Err(error) => {
tracing::error!("failed to load local fallback index: {error}");
}
}
} else {
tracing::warn!("daemon unreachable and no repo root available for local fallback");
}
}
#[allow(deprecated)]
pub(crate) async fn fetch_client_root_uris(
peer: &rmcp::Peer<RoleServer>,
) -> Option<Vec<String>> {
if crate::discovery::workspace_root_env_is_authoritative() {
tracing::debug!(
"workspace environment authority prevents client-roots retarget or fallback"
);
return None;
}
let declares_roots = peer
.peer_info()
.map(|info| info.capabilities.roots.is_some())
.unwrap_or(false);
if !declares_roots {
tracing::debug!("client did not declare the roots capability; workspace stays unbound");
return None;
}
let roots = match tokio::time::timeout(std::time::Duration::from_secs(5), peer.list_roots())
.await
{
Ok(Ok(result)) => result.roots,
Ok(Err(error)) => {
tracing::debug!(%error, "client roots/list failed; workspace stays unbound");
return None;
}
Err(_elapsed) => {
tracing::warn!(
"client roots/list did not respond within 5s; workspace stays unbound"
);
return None;
}
};
if roots.is_empty() {
tracing::debug!("client declared no roots; workspace stays unbound");
return None;
}
Some(roots.into_iter().map(|root| root.uri).collect())
}
pub(crate) async fn apply_prefetched_client_roots(&self, root_uris: Option<Vec<String>>) {
let Some(root_uris) = root_uris else {
return;
};
if crate::discovery::workspace_root_env_is_authoritative() {
return;
}
if self.capture_repo_root().is_some() {
let is_daemon_proxy = self.daemon_client.is_some();
if !is_daemon_proxy {
return;
}
tracing::debug!(
"daemon-proxy bound from CWD (no env override); allowing client roots to retarget"
);
}
let Some(resolved) = crate::discovery::resolve_workspace_root(None, &root_uris, None)
else {
tracing::info!(
roots = ?root_uris,
"no usable workspace among client roots (forbidden/unparseable); staying unbound"
);
return;
};
let _ = self.bind_declared_client_root(resolved).await;
}
async fn bind_workspace_from_client_roots(&self, peer: &rmcp::Peer<RoleServer>) {
if self.capture_repo_root().is_some() {
let is_daemon_proxy = self.daemon_client.is_some();
if !is_daemon_proxy {
return;
}
tracing::debug!(
"daemon-proxy bound from CWD (no env override); allowing client roots to retarget"
);
}
let uris = Self::fetch_client_root_uris(peer).await;
self.apply_prefetched_client_roots(uris).await;
}
pub(crate) async fn bind_declared_client_root(&self, resolved: PathBuf) -> Option<String> {
*self.caller_declared_root.write() = Some(resolved.clone());
if let Some(daemon_lock) = self.daemon_client.as_ref() {
let active = daemon_lock.read().await.active_project_id();
if crate::daemon::project_key(&resolved) == active {
tracing::info!(
root = %resolved.display(),
"client roots name the root this session is already bound to; skipped the rebind"
);
return None;
}
tracing::info!(
root = %resolved.display(),
"client roots name a different root than this session's; retargeting"
);
} else {
tracing::info!(
root = %resolved.display(),
"binding workspace from MCP client roots (no env/CWD root at startup)"
);
}
let input = crate::protocol::tools::IndexFolderInput {
path: resolved.display().to_string(),
idempotency_key: None,
add: None,
allow_protected_root: None,
};
let result = self
.index_folder(rmcp::handler::server::wrapper::Parameters(input))
.await;
tracing::info!(outcome = %result, "workspace bind from client roots complete");
Some(result)
}
#[doc(hidden)]
pub async fn dispatch_tool_for_tests(
&self,
tool_name: &str,
params: serde_json::Value,
) -> String {
use rmcp::handler::server::wrapper::Parameters;
fn decode<T: serde::de::DeserializeOwned>(params: serde_json::Value) -> Result<T, String> {
serde_json::from_value(params).map_err(|e| format!("invalid tool parameters: {e}"))
}
macro_rules! call {
($method:ident, $input:ty) => {{
match decode::<$input>(params) {
Ok(input) => self.$method(Parameters(input)).await,
Err(e) => e,
}
}};
}
match tool_name {
"replace_symbol_body" => call!(replace_symbol_body, edit::ReplaceSymbolBodyInput),
"insert_symbol" => call!(insert_symbol, edit::InsertSymbolInput),
"delete_symbol" => call!(delete_symbol, edit::DeleteSymbolInput),
"edit_within_symbol" => call!(edit_within_symbol, edit::EditWithinSymbolInput),
"batch_edit" => call!(batch_edit, edit::BatchEditInput),
"batch_rename" => call!(batch_rename, edit::BatchRenameInput),
"batch_insert" => call!(batch_insert, edit::BatchInsertInput),
"search_files" => call!(search_files, tools::SearchFilesInput),
"search_text" => call!(search_text, tools::SearchTextInput),
"search_knowledge" => call!(search_knowledge, tools::SearchKnowledgeInput),
"review_knowledge" => call!(review_knowledge, tools::ReviewKnowledgeInput),
"curate_knowledge" => call!(curate_knowledge, tools::CurateKnowledgeInput),
"search_symbols" => call!(search_symbols, tools::SearchSymbolsInput),
"get_file_context" => call!(get_file_context, tools::GetFileContextInput),
"get_file_content" => call!(get_file_content, tools::GetFileContentInput),
"get_symbol" => call!(get_symbol, tools::GetSymbolInput),
"get_symbol_context" => call!(get_symbol_context, tools::GetSymbolContextInput),
"find_references" => call!(find_references, tools::FindReferencesInput),
"find_dependents" => call!(find_dependents, tools::FindDependentsInput),
"inspect_match" => call!(inspect_match, tools::InspectMatchInput),
"analyze_file_impact" => call!(analyze_file_impact, tools::AnalyzeFileImpactInput),
"edit_plan" => call!(edit_plan, tools::EditPlanInput),
"index_folder" => call!(index_folder, tools::IndexFolderInput),
"detect_impact" => call!(detect_impact, tools::DetectImpactInput),
"what_changed" => call!(what_changed, tools::WhatChangedInput),
"diff_symbols" => call!(diff_symbols, tools::DiffSymbolsInput),
"explore" => call!(explore, tools::ExploreInput),
"ask" => call!(ask, tools::SmartQueryInput),
"get_repo_map" => call!(get_repo_map, tools::GetRepoMapInput),
"context_inventory" => self.context_inventory().await,
"symforge_retrieve" => call!(symforge_retrieve, read_tools::SymforgeRetrieveInput),
"health" => call!(health, tools::HealthInput),
"health_compact" => self.health_compact().await,
"conventions" => self.conventions().await,
other => format!("dispatch_tool_for_tests: unknown tool '{other}'"),
}
}
#[doc(hidden)]
pub async fn dispatch_tool_result_for_tests(
&self,
tool_name: &str,
params: serde_json::Value,
) -> Result<rmcp::model::CallToolResult, rmcp::ErrorData> {
withheld::with_withheld_scope(self.dispatch_tool_result_for_tests_inner(tool_name, params))
.await
}
async fn dispatch_tool_result_for_tests_inner(
&self,
tool_name: &str,
params: serde_json::Value,
) -> Result<rmcp::model::CallToolResult, rmcp::ErrorData> {
use rmcp::handler::server::wrapper::Parameters;
fn invalid_request_result(
tool_name: &str,
message: impl Into<String>,
) -> Result<rmcp::model::CallToolResult, rmcp::ErrorData> {
let text = format!(
"Invalid request for tool `{tool_name}`: {}\nRecovery: compare the request JSON with the advertised input schema from tool_definitions().",
message.into()
);
Ok(
result_status::ResultStatus::new(result_status::OutcomeClass::InvalidRequest)
.into_call_tool_result(text),
)
}
fn decode<T: serde::de::DeserializeOwned>(params: serde_json::Value) -> Result<T, String> {
serde_json::from_value(params).map_err(|e| format!("invalid tool parameters: {e}"))
}
macro_rules! call_statused {
($method:ident, $input:ty) => {{
match decode::<$input>(params) {
Ok(input) => self.$method(Parameters(input)).await,
Err(error) => invalid_request_result(tool_name, error),
}
}};
}
match tool_name {
"replace_symbol_body" => {
call_statused!(replace_symbol_body_tool, edit::ReplaceSymbolBodyInput)
}
"batch_edit" => call_statused!(batch_edit_tool, edit::BatchEditInput),
"insert_symbol" => call_statused!(insert_symbol_tool, edit::InsertSymbolInput),
"delete_symbol" => call_statused!(delete_symbol_tool, edit::DeleteSymbolInput),
"edit_within_symbol" => {
call_statused!(edit_within_symbol_tool, edit::EditWithinSymbolInput)
}
"batch_rename" => call_statused!(batch_rename_tool, edit::BatchRenameInput),
"batch_insert" => call_statused!(batch_insert_tool, edit::BatchInsertInput),
"search_files" => call_statused!(search_files_tool, tools::SearchFilesInput),
"search_text" => call_statused!(search_text_tool, tools::SearchTextInput),
"search_symbols" => call_statused!(search_symbols_tool, tools::SearchSymbolsInput),
"get_file_content" => {
call_statused!(get_file_content_tool, tools::GetFileContentInput)
}
"get_symbol" => call_statused!(get_symbol_tool, tools::GetSymbolInput),
"get_symbol_context" => {
call_statused!(get_symbol_context_tool, tools::GetSymbolContextInput)
}
"find_references" => call_statused!(find_references_tool, tools::FindReferencesInput),
"symforge" => call_statused!(symforge_facade_tool, crate::stel::SymforgeCallInput),
"symforge_edit" => {
call_statused!(symforge_edit_facade_tool, crate::stel::StelEditRequest)
}
"status" => call_statused!(status_stel_tool, crate::stel::StelStatusRequest),
"secret_remediate" => {
call_statused!(
secret_remediate_tool,
secret_remediate::SecretRemediateInput
)
}
other => {
let text = format!(
"Unsupported tool `{other}` in public conformance harness.\nRecovery: add a statused dispatcher branch before adding the case, or remove the case from the public corpus."
);
Ok(
result_status::ResultStatus::new(result_status::OutcomeClass::InvalidRequest)
.into_call_tool_result(text),
)
}
}
}
}
#[tool_handler(router = self.tool_router)]
impl ServerHandler for SymForgeServer {
fn get_info(&self) -> ServerConfig {
let config = ServerConfig::new(
ServerCapabilities::builder()
.enable_tools()
.enable_prompts()
.enable_resources()
.build(),
)
.with_server_info(rmcp::model::Implementation::new(
"symforge",
env!("CARGO_PKG_VERSION"),
));
match surface_probe::server_instructions(surface_probe::surface_profile_from_env()) {
Some(text) => config.with_instructions(text),
None => config,
}
}
fn supported_protocol_versions(
&self,
) -> std::borrow::Cow<'static, [rmcp::model::ProtocolVersion]> {
use rmcp::model::ProtocolVersion;
std::borrow::Cow::Borrowed(&[
ProtocolVersion::V_2024_11_05,
ProtocolVersion::V_2025_03_26,
ProtocolVersion::V_2025_06_18,
ProtocolVersion::V_2025_11_25,
ProtocolVersion::V_2026_07_28,
])
}
fn list_resources(
&self,
_request: Option<PaginatedRequestParams>,
_context: RequestContext<RoleServer>,
) -> impl std::future::Future<Output = Result<ListResourcesResult, rmcp::ErrorData>> + Send + '_
{
std::future::ready(Ok(ListResourcesResult::with_all_items(
self.resource_definitions(),
)
.with_ttl_ms(3_600_000)
.with_cache_scope(rmcp::model::CacheScope::Public)))
}
fn list_resource_templates(
&self,
_request: Option<PaginatedRequestParams>,
_context: RequestContext<RoleServer>,
) -> impl std::future::Future<Output = Result<ListResourceTemplatesResult, rmcp::ErrorData>>
+ Send
+ '_ {
std::future::ready(Ok(ListResourceTemplatesResult::with_all_items(
self.resource_template_definitions(),
)
.with_ttl_ms(3_600_000)
.with_cache_scope(rmcp::model::CacheScope::Public)))
}
fn read_resource(
&self,
request: ReadResourceRequestParams,
_context: RequestContext<RoleServer>,
) -> impl std::future::Future<
Output = Result<rmcp::model::ReadResourceResponse, rmcp::ErrorData>,
> + Send
+ '_ {
let uri = request.uri;
async move {
result_status::with_project_evidence_scope(self.local_project_evidence(), async {
self.read_resource_uri(&uri).await.map(|mut result| {
result_status::attach_project_evidence_meta(&mut result.meta);
rmcp::model::ReadResourceResponse::Complete(result)
})
})
.await
}
}
async fn call_tool(
&self,
mut request: rmcp::model::CallToolRequestParams,
context: RequestContext<RoleServer>,
) -> Result<rmcp::model::CallToolResponse, rmcp::ErrorData> {
surface_probe::enforce_compact_surface(request.name.as_ref())?;
let selected_modes =
match self.refuse_invalid_arguments(request.name.as_ref(), &mut request.arguments) {
Ok(selected) => selected,
Err(mut refusal) => {
let evidence = self
.initial_project_evidence_for_call(request.arguments.as_ref())
.await;
result_status::with_project_evidence_scope(evidence, async {
result_status::attach_project_evidence_meta(&mut refusal.meta);
})
.await;
return Ok(rmcp::model::CallToolResponse::Complete(refusal));
}
};
let admitted_raw_measurement_relay = request.name.as_ref() == "symforge"
&& request
.arguments
.as_ref()
.and_then(|arguments| {
serde_json::from_value::<crate::stel::SymforgeCallInput>(
serde_json::Value::Object(arguments.clone()),
)
.ok()
})
.and_then(|input| Some((input.probe_legacy_tool?, input.probe_legacy_args?)))
.is_some_and(|(tool, args)| Self::facade_probe_is_measurement_safe(&tool, &args));
let repeat_key = repeat::RepeatKey::observe(
repeat::SessionDiscriminator::observe(self.transport_lane, &context),
self.repeat_tracker.lock().epoch(),
request.name.as_ref(),
request.arguments.as_ref(),
);
let initial_project_evidence = self
.initial_project_evidence_for_call(request.arguments.as_ref())
.await;
let tool_name = request.name.clone();
let tcc = rmcp::handler::server::tool::ToolCallContext::new(self, request, context);
result_status::with_project_evidence_scope(initial_project_evidence, async {
withheld::with_withheld_scope(async {
let (response, recorded) =
result_status::with_read_outcome_scope(self.tool_router.call(tcc)).await;
response.map(|response| match response {
rmcp::model::CallToolResponse::Complete(mut result) => {
result_status::attach_project_evidence_meta(&mut result.meta);
if result.is_error == Some(true) {
append_required_fields_hint(
self.tool_router.get(&tool_name),
&mut result,
);
}
let typed_facade_step =
crate::stel::planner::FacadeStepTool::from_name(tool_name.as_ref())
.is_some();
if !admitted_raw_measurement_relay
&& (recorded.is_some() || typed_facade_step)
&& result_status::observed_outcome_class(result.meta.as_ref()).is_none()
{
let class = recorded
.map(|outcome| outcome.class())
.unwrap_or(OutcomeClass::InternalFailure);
if class.is_error() {
result.is_error = Some(true);
}
result.meta.get_or_insert_with(Default::default).0.insert(
result_status::RESULT_STATUS_META_KEY.to_string(),
serde_json::to_value(result_status::ResultStatus::new(class))
.expect("ResultStatus must serialize to JSON"),
);
}
let typed_result = typed_facade_step || recorded.is_some();
if !admitted_raw_measurement_relay
&& !typed_result
&& result.is_error != Some(true)
{
let body = result
.content
.iter()
.filter_map(|block| block.as_text().map(|text| text.text.as_str()))
.collect::<Vec<_>>()
.join("\n");
if !body.is_empty() && tools::is_error_output(&body) {
result.is_error = Some(true);
} else if tools::is_index_unavailable_output(&body) {
result.is_error = Some(true);
result
.meta
.get_or_insert_with(Default::default)
.0
.entry(result_status::RESULT_STATUS_META_KEY.to_string())
.or_insert_with(|| {
serde_json::to_value(result_status::ResultStatus::new(
OutcomeClass::InternalFailure,
))
.expect("ResultStatus must serialize to JSON")
});
}
}
tool_contract::append_selection_note(&mut result, &selected_modes);
if let Some(key) = repeat_key {
let observation = repeat::ServeObservation::from_result(&result);
let notice = self.repeat_tracker.lock().record_serve(key, observation);
if let Some(notice) = notice {
notice.attach(&mut result);
}
}
withheld::drain_pending_into_meta(&mut result.meta);
rmcp::model::CallToolResponse::Complete(result)
}
other => other,
})
})
.await
})
.await
}
async fn list_tools(
&self,
_request: Option<PaginatedRequestParams>,
_context: RequestContext<RoleServer>,
) -> Result<ListToolsResult, rmcp::ErrorData> {
let profile = surface_probe::surface_profile_from_env();
let tools = match profile {
surface_probe::SurfaceProfile::Compact => crate::stel::compact_surface_tools(),
_ => surface_probe::list_tools_for_profile(profile),
};
Ok(ListToolsResult::with_all_items(tools)
.with_ttl_ms(3_600_000)
.with_cache_scope(rmcp::model::CacheScope::Public))
}
async fn get_prompt(
&self,
request: rmcp::model::GetPromptRequestParams,
context: RequestContext<RoleServer>,
) -> Result<rmcp::model::GetPromptResponse, rmcp::ErrorData> {
let prompt_context = rmcp::handler::server::prompt::PromptContext::new(
self,
request.name,
request.arguments,
context,
);
self.prompt_router.get_prompt(prompt_context).await
}
async fn list_prompts(
&self,
_request: Option<PaginatedRequestParams>,
_context: RequestContext<RoleServer>,
) -> Result<rmcp::model::ListPromptsResult, rmcp::ErrorData> {
Ok(
rmcp::model::ListPromptsResult::with_all_items(self.prompt_router.list_all())
.with_ttl_ms(3_600_000)
.with_cache_scope(rmcp::model::CacheScope::Public),
)
}
async fn on_initialized(&self, context: rmcp::service::NotificationContext<RoleServer>) {
tracing::info!("client initialized");
self.bind_workspace_from_client_roots(&context.peer).await;
}
}
const PARAMETER_DECODE_ERROR_PREFIX: &str = "failed to deserialize parameters:";
fn required_field_names(tool: &Tool) -> Vec<&str> {
tool.input_schema
.get("required")
.and_then(serde_json::Value::as_array)
.map(|names| names.iter().filter_map(serde_json::Value::as_str).collect())
.unwrap_or_default()
}
fn append_required_fields_hint(tool: Option<&Tool>, result: &mut rmcp::model::CallToolResult) {
let Some(tool) = tool else { return };
let required = required_field_names(tool);
if required.is_empty() {
return;
}
for block in &mut result.content {
if let rmcp::model::ContentBlock::Text(text) = block
&& text.text.starts_with(PARAMETER_DECODE_ERROR_PREFIX)
{
text.text.push_str(&format!(
"\nRequired fields for `{}`: {}.",
tool.name,
required.join(", ")
));
return;
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use axum::extract::{Path as AxumPath, State};
use axum::http::{HeaderMap, HeaderValue, StatusCode};
use axum::routing::post;
use axum::{Json, Router};
use rmcp::handler::server::wrapper::Parameters;
use std::sync::atomic::{AtomicUsize, Ordering};
use tokio::net::TcpListener;
fn only_text(result: &rmcp::model::CallToolResult) -> &str {
match result.content.as_slice() {
[rmcp::model::ContentBlock::Text(text)] => &text.text,
other => panic!("expected exactly one text block, got {other:?}"),
}
}
#[test]
fn decode_error_gains_the_required_field_names_after_the_serde_text() {
let router = SymForgeServer::tool_router();
let serde_text = "failed to deserialize parameters: missing field `name`";
let mut result =
rmcp::model::CallToolResult::error(vec![rmcp::model::ContentBlock::text(serde_text)]);
append_required_fields_hint(router.get("find_references"), &mut result);
let text = only_text(&result);
assert!(
text.starts_with(serde_text),
"serde text must stay first: {text}"
);
assert!(
text.ends_with("\nRequired fields for `find_references`: name."),
"one line naming the required fields must follow: {text}"
);
}
#[test]
fn non_decode_errors_and_unknown_tools_are_left_untouched() {
let router = SymForgeServer::tool_router();
let mut other = rmcp::model::CallToolResult::error(vec![rmcp::model::ContentBlock::text(
"Error: symbol not found",
)]);
append_required_fields_hint(router.get("find_references"), &mut other);
assert_eq!(only_text(&other), "Error: symbol not found");
let mut unknown =
rmcp::model::CallToolResult::error(vec![rmcp::model::ContentBlock::text(
"failed to deserialize parameters: x",
)]);
append_required_fields_hint(router.get("no_such_tool"), &mut unknown);
assert_eq!(only_text(&unknown), "failed to deserialize parameters: x");
}
#[derive(Clone)]
struct FakeToolState {
calls: Arc<AtomicUsize>,
body: Arc<String>,
read_outcome_header: Option<String>,
}
async fn fake_tool_handler(
State(state): State<FakeToolState>,
_body: axum::body::Bytes,
) -> (HeaderMap, String) {
state.calls.fetch_add(1, Ordering::Relaxed);
let mut headers = HeaderMap::new();
if let Some(outcome) = state.read_outcome_header {
headers.insert(
result_status::READ_OUTCOME_HEADER,
HeaderValue::from_str(&outcome).expect("valid fake outcome header"),
);
}
(headers, state.body.as_ref().clone())
}
async fn spawn_fake_tool_server(
body: &str,
) -> (
String,
tokio::sync::oneshot::Sender<()>,
Arc<AtomicUsize>,
tokio::task::JoinHandle<()>,
) {
spawn_fake_tool_server_with_read_outcome_header(body, None).await
}
async fn spawn_fake_tool_server_with_read_outcome_header(
body: &str,
read_outcome_header: Option<&str>,
) -> (
String,
tokio::sync::oneshot::Sender<()>,
Arc<AtomicUsize>,
tokio::task::JoinHandle<()>,
) {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind fake daemon tool server");
let base_url = format!("http://{}", listener.local_addr().expect("listener addr"));
let calls = Arc::new(AtomicUsize::new(0));
let state = FakeToolState {
calls: Arc::clone(&calls),
body: Arc::new(body.to_string()),
read_outcome_header: read_outcome_header.map(str::to_string),
};
let app = Router::new()
.route(
"/v1/sessions/{session_id}/tools/{tool_name}",
post(fake_tool_handler),
)
.with_state(state);
let (shutdown_tx, shutdown_rx) = tokio::sync::oneshot::channel();
let server_task = tokio::spawn(async move {
let shutdown = async move {
let _ = shutdown_rx.await;
};
let _ = axum::serve(listener, app)
.with_graceful_shutdown(shutdown)
.await;
});
(base_url, shutdown_tx, calls, server_task)
}
#[derive(Clone)]
struct BlockingIndexFolderState {
calls: Arc<AtomicUsize>,
paths: Arc<Mutex<Vec<String>>>,
first_entered: Arc<tokio::sync::Notify>,
second_entered: Arc<tokio::sync::Notify>,
release_first: Arc<tokio::sync::Notify>,
}
async fn blocking_index_folder_handler(
State(state): State<BlockingIndexFolderState>,
Json(args): Json<serde_json::Value>,
) -> String {
let call = state.calls.fetch_add(1, Ordering::SeqCst);
state.paths.lock().push(
args.get("path")
.and_then(serde_json::Value::as_str)
.expect("index_folder path")
.to_string(),
);
if call == 0 {
state.first_entered.notify_one();
state.release_first.notified().await;
} else {
state.second_entered.notify_one();
}
"Indexed 0 files, 0 symbols.".to_string()
}
async fn spawn_blocking_index_folder_server() -> (
String,
tokio::sync::oneshot::Sender<()>,
BlockingIndexFolderState,
) {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind blocking index-folder server");
let base_url = format!("http://{}", listener.local_addr().expect("listener addr"));
let state = BlockingIndexFolderState {
calls: Arc::new(AtomicUsize::new(0)),
paths: Arc::new(Mutex::new(Vec::new())),
first_entered: Arc::new(tokio::sync::Notify::new()),
second_entered: Arc::new(tokio::sync::Notify::new()),
release_first: Arc::new(tokio::sync::Notify::new()),
};
let app = Router::new()
.route(
"/v1/sessions/{session_id}/tools/index_folder",
post(blocking_index_folder_handler),
)
.with_state(state.clone());
let (shutdown_tx, shutdown_rx) = tokio::sync::oneshot::channel();
tokio::spawn(async move {
let shutdown = async move {
let _ = shutdown_rx.await;
};
let _ = axum::serve(listener, app)
.with_graceful_shutdown(shutdown)
.await;
});
(base_url, shutdown_tx, state)
}
#[derive(Clone)]
struct ProjectEchoState {
requests: Arc<Mutex<Vec<(String, serde_json::Value)>>>,
evidence_project_override: Option<String>,
omit_evidence_for_tool: Option<String>,
different_generation_for_tool: Option<String>,
malformed_evidence_for_tool: Option<String>,
incoherent_evidence_for_tool: Option<String>,
}
async fn project_echo_handler(
AxumPath((_session_id, tool_name)): AxumPath<(String, String)>,
State(state): State<ProjectEchoState>,
Json(args): Json<serde_json::Value>,
) -> (HeaderMap, String) {
state
.requests
.lock()
.push((tool_name.clone(), args.clone()));
let project = args
.get("project")
.and_then(serde_json::Value::as_str)
.unwrap_or("<daemon-home>");
let evidence_project = state
.evidence_project_override
.as_deref()
.unwrap_or(project);
let canonical_root = format!("C:/FOREIGN_ROOT/{evidence_project}");
let evidence = crate::protocol::result_status::ProjectEvidence {
project_id: if state.incoherent_evidence_for_tool.as_deref() == Some(tool_name.as_str())
{
"project-v1-incoherent".to_string()
} else {
crate::daemon::project_key(std::path::Path::new(&canonical_root))
},
project_name: evidence_project.to_string(),
canonical_root: Some(canonical_root),
generation: if state.different_generation_for_tool.as_deref()
== Some(tool_name.as_str())
{
8
} else {
7
},
index_state: "Ready".to_string(),
trust: "Ready".to_string(),
load_source: "fake-daemon".to_string(),
index_files: 11,
index_symbols: 13,
};
let mut headers = HeaderMap::new();
if state.malformed_evidence_for_tool.as_deref() == Some(tool_name.as_str()) {
headers.insert(
crate::protocol::result_status::PROJECT_EVIDENCE_HEADER,
HeaderValue::from_static("{"),
);
} else if state.omit_evidence_for_tool.as_deref() != Some(tool_name.as_str()) {
headers.insert(
crate::protocol::result_status::PROJECT_EVIDENCE_HEADER,
HeaderValue::from_str(
&serde_json::to_string(&evidence).expect("serialize fake project evidence"),
)
.expect("fake project evidence is a valid header value"),
);
}
headers.insert(
crate::protocol::result_status::READ_OUTCOME_HEADER,
HeaderValue::from_str(
&serde_json::to_string(&crate::protocol::result_status::ReadOutcome::Found)
.expect("serialize read outcome"),
)
.expect("read outcome is a valid header value"),
);
let body = if tool_name == "index_folder" {
"Indexed 0 files, 0 symbols.".to_string()
} else {
format!("selected-project={project}; tool={tool_name}")
};
(headers, body)
}
async fn spawn_project_echo_tool_server() -> (
String,
tokio::sync::oneshot::Sender<()>,
Arc<Mutex<Vec<(String, serde_json::Value)>>>,
tokio::task::JoinHandle<()>,
) {
spawn_project_echo_tool_server_with_policy(None, None, None, None, None).await
}
async fn spawn_project_echo_tool_server_with_evidence_project(
evidence_project_override: Option<&str>,
) -> (
String,
tokio::sync::oneshot::Sender<()>,
Arc<Mutex<Vec<(String, serde_json::Value)>>>,
tokio::task::JoinHandle<()>,
) {
spawn_project_echo_tool_server_with_policy(
evidence_project_override,
None,
None,
None,
None,
)
.await
}
async fn spawn_project_echo_tool_server_with_policy(
evidence_project_override: Option<&str>,
omit_evidence_for_tool: Option<&str>,
different_generation_for_tool: Option<&str>,
malformed_evidence_for_tool: Option<&str>,
incoherent_evidence_for_tool: Option<&str>,
) -> (
String,
tokio::sync::oneshot::Sender<()>,
Arc<Mutex<Vec<(String, serde_json::Value)>>>,
tokio::task::JoinHandle<()>,
) {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind project echo daemon tool server");
let base_url = format!("http://{}", listener.local_addr().expect("listener addr"));
let requests = Arc::new(Mutex::new(Vec::new()));
let app = Router::new()
.route(
"/v1/sessions/{session_id}/tools/{tool_name}",
post(project_echo_handler),
)
.with_state(ProjectEchoState {
requests: Arc::clone(&requests),
evidence_project_override: evidence_project_override.map(str::to_string),
omit_evidence_for_tool: omit_evidence_for_tool.map(str::to_string),
different_generation_for_tool: different_generation_for_tool.map(str::to_string),
malformed_evidence_for_tool: malformed_evidence_for_tool.map(str::to_string),
incoherent_evidence_for_tool: incoherent_evidence_for_tool.map(str::to_string),
});
let (shutdown_tx, shutdown_rx) = tokio::sync::oneshot::channel();
let server_task = tokio::spawn(async move {
let shutdown = async move {
let _ = shutdown_rx.await;
};
let _ = axum::serve(listener, app)
.with_graceful_shutdown(shutdown)
.await;
});
(base_url, shutdown_tx, requests, server_task)
}
#[derive(Clone)]
struct FailingAskThenEchoState {
requests: Arc<Mutex<Vec<(String, serde_json::Value)>>>,
ask_entered: Arc<tokio::sync::Notify>,
release_ask: Arc<tokio::sync::Notify>,
}
async fn failing_ask_then_echo_handler(
AxumPath((_session_id, tool_name)): AxumPath<(String, String)>,
State(state): State<FailingAskThenEchoState>,
Json(args): Json<serde_json::Value>,
) -> Result<String, StatusCode> {
state
.requests
.lock()
.push((tool_name.clone(), args.clone()));
if tool_name == "ask" {
state.ask_entered.notify_one();
state.release_ask.notified().await;
return Err(StatusCode::SERVICE_UNAVAILABLE);
}
let project = args
.get("project")
.and_then(serde_json::Value::as_str)
.unwrap_or("<daemon-active>");
Ok(format!("selected-project={project}; tool={tool_name}"))
}
async fn spawn_failing_ask_then_echo_server() -> (
String,
tokio::sync::oneshot::Sender<()>,
tokio::task::JoinHandle<()>,
FailingAskThenEchoState,
) {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind failing ask daemon tool server");
let base_url = format!("http://{}", listener.local_addr().expect("listener addr"));
let state = FailingAskThenEchoState {
requests: Arc::new(Mutex::new(Vec::new())),
ask_entered: Arc::new(tokio::sync::Notify::new()),
release_ask: Arc::new(tokio::sync::Notify::new()),
};
let app = Router::new()
.route(
"/v1/sessions/{session_id}/tools/{tool_name}",
post(failing_ask_then_echo_handler),
)
.with_state(state.clone());
let (shutdown_tx, shutdown_rx) = tokio::sync::oneshot::channel();
let task = tokio::spawn(async move {
let shutdown = async move {
let _ = shutdown_rx.await;
};
let _ = axum::serve(listener, app)
.with_graceful_shutdown(shutdown)
.await;
});
(base_url, shutdown_tx, task, state)
}
#[tokio::test]
async fn daemon_proxy_resolves_index_folder_path_once_before_dispatch_and_mirroring() {
let cwd = std::env::current_dir().expect("test current directory");
let target = tempfile::Builder::new()
.prefix("symforge-index-folder-relative-")
.tempdir_in(&cwd)
.expect("relative index target under the adapter cwd");
let relative = target
.path()
.strip_prefix(&cwd)
.expect("temp target is beneath adapter cwd")
.to_string_lossy()
.into_owned();
assert!(
std::path::Path::new(&relative).is_relative(),
"fixture must exercise a relative caller spelling: {relative}"
);
let (base_url, shutdown, requests, server_task) = spawn_project_echo_tool_server().await;
let client = crate::daemon::DaemonSessionClient::new_for_test(
base_url,
"home-project-id".to_string(),
"session-id".to_string(),
"home-project".to_string(),
);
let client_state = client.clone();
let server = SymForgeServer::new_daemon_proxy(client);
let result = server
.index_folder(Parameters(crate::protocol::tools::IndexFolderInput {
path: relative,
idempotency_key: None,
add: None,
allow_protected_root: None,
}))
.await;
assert!(result.starts_with("Indexed 0 files"), "{result}");
let expected = target.path().canonicalize().expect("canonical test target");
{
let captured = requests.lock();
assert_eq!(captured.len(), 1);
assert_eq!(captured[0].0, "index_folder");
let forwarded = captured[0]
.1
.get("path")
.and_then(serde_json::Value::as_str)
.map(std::path::PathBuf::from)
.expect("index_folder forwards a path string");
assert!(
forwarded.is_absolute(),
"the daemon must never resolve the caller's relative spelling: {}",
forwarded.display()
);
assert_eq!(forwarded, expected);
assert_eq!(
client_state.activated_root().as_deref(),
Some(expected.as_path()),
"the adapter ACTIVE mirror must record the exact root sent to the daemon"
);
}
let missing = target.path().join("missing-project");
let missing_relative = missing
.strip_prefix(&cwd)
.expect("missing target is beneath adapter cwd")
.to_string_lossy()
.into_owned();
assert!(!missing.try_exists().expect("observe missing fixture"));
let refused = server
.index_folder(Parameters(crate::protocol::tools::IndexFolderInput {
path: missing_relative,
idempotency_key: None,
add: None,
allow_protected_root: None,
}))
.await;
assert!(refused.starts_with("Path does not exist:"), "{refused}");
assert_eq!(
requests.lock().len(),
1,
"an unresolved relative path must fail before any daemon request"
);
assert_eq!(
client_state.activated_root().as_deref(),
Some(expected.as_path()),
"a failed preflight must preserve the prior ACTIVE mirror"
);
let _ = shutdown.send(());
server_task.await.expect("fake daemon server task");
}
#[tokio::test]
async fn daemon_index_folder_serializes_response_and_active_mirror_order() {
let first_root = tempfile::TempDir::new().expect("first index root");
let second_root = tempfile::TempDir::new().expect("second index root");
let first_root = first_root
.path()
.canonicalize()
.expect("canonical first root");
let second_root = second_root
.path()
.canonicalize()
.expect("canonical second root");
let (base_url, shutdown, fake) = spawn_blocking_index_folder_server().await;
let client = crate::daemon::DaemonSessionClient::new_for_test(
base_url,
"home-project-id".to_string(),
"session-id".to_string(),
"home-project".to_string(),
);
let client_state = client.clone();
let server = SymForgeServer::new_daemon_proxy(client);
let first = tokio::spawn({
let server = server.clone();
let path = first_root.to_string_lossy().into_owned();
async move {
server
.index_folder(Parameters(crate::protocol::tools::IndexFolderInput {
path,
idempotency_key: None,
add: None,
allow_protected_root: None,
}))
.await
}
});
tokio::time::timeout(
std::time::Duration::from_secs(1),
fake.first_entered.notified(),
)
.await
.expect("first daemon request entered");
let writer_started = Arc::new(tokio::sync::Notify::new());
let writer_acquired = Arc::new(tokio::sync::Notify::new());
let release_writer = Arc::new(tokio::sync::Notify::new());
let writer = tokio::spawn({
let slot = server.daemon_client_slot().expect("daemon client slot");
let writer_started = Arc::clone(&writer_started);
let writer_acquired = Arc::clone(&writer_acquired);
let release_writer = Arc::clone(&release_writer);
async move {
writer_started.notify_one();
let _guard = slot.write().await;
writer_acquired.notify_one();
release_writer.notified().await;
}
});
writer_started.notified().await;
tokio::task::yield_now().await;
fake.release_first.notify_one();
tokio::time::timeout(
std::time::Duration::from_secs(1),
writer_acquired.notified(),
)
.await
.expect("queued writer acquired after the proxy response");
assert!(
client_state.activation_lane().try_lock().is_err(),
"the activation lane must remain held until the ACTIVE mirror write completes"
);
let second = tokio::spawn({
let server = server.clone();
let path = second_root.to_string_lossy().into_owned();
async move {
server
.index_folder(Parameters(crate::protocol::tools::IndexFolderInput {
path,
idempotency_key: None,
add: None,
allow_protected_root: None,
}))
.await
}
});
assert!(
tokio::time::timeout(
std::time::Duration::from_millis(100),
fake.second_entered.notified(),
)
.await
.is_err(),
"the second default open must not reach the daemon while the first mirror is pending"
);
release_writer.notify_one();
writer.await.expect("writer task");
let first_result = first.await.expect("first index task");
assert!(
first_result.starts_with("Indexed 0 files"),
"{first_result}"
);
tokio::time::timeout(
std::time::Duration::from_secs(1),
fake.second_entered.notified(),
)
.await
.expect("second daemon request entered after the first mirror");
let second_result = second.await.expect("second index task");
assert!(
second_result.starts_with("Indexed 0 files"),
"{second_result}"
);
assert_eq!(
fake.paths.lock().as_slice(),
&[
first_root.to_string_lossy().into_owned(),
second_root.to_string_lossy().into_owned(),
]
);
assert_eq!(
client_state.activated_root().as_deref(),
Some(second_root.as_path()),
"daemon and adapter ACTIVE order must match completed call order"
);
let _ = shutdown.send(());
}
#[tokio::test]
async fn daemon_proxy_ask_routes_the_whole_query_after_the_local_no_echo_guard() {
let (base_url, shutdown, requests, server_task) = spawn_project_echo_tool_server().await;
let client = crate::daemon::DaemonSessionClient::new_for_test(
base_url,
"home-project-id".to_string(),
"session-id".to_string(),
"home-project".to_string(),
);
let server = SymForgeServer::new_daemon_proxy(client);
let explicit = server
.ask(Parameters(crate::protocol::tools::SmartQueryInput {
project: Some("foreign-project".to_string()),
query: "which tool should I use for impact analysis?".to_string(),
max_tokens: None,
}))
.await;
assert_eq!(
explicit, "selected-project=foreign-project; tool=ask",
"the selected daemon project must own ask route classification"
);
let implicit = server
.ask(Parameters(crate::protocol::tools::SmartQueryInput {
project: None,
query: "which tool should I use for code search?".to_string(),
max_tokens: None,
}))
.await;
assert_eq!(
implicit, "selected-project=<daemon-home>; tool=ask",
"an omitted selector must still proxy the whole ask request"
);
let canary = ["runtime", "-", "ask", "-", "canary"].concat();
let rejected = server
.ask(Parameters(crate::protocol::tools::SmartQueryInput {
project: Some("foreign-project".to_string()),
query: format!("token={canary}"),
max_tokens: None,
}))
.await;
assert!(rejected.contains("sensitive query rejected"), "{rejected}");
assert!(!rejected.contains(&canary), "sensitive input must not echo");
{
let captured = requests.lock();
assert_eq!(
captured.len(),
2,
"the safety guard must reject before the daemon hop"
);
assert!(captured.iter().all(|(tool, _)| tool == "ask"));
assert_eq!(captured[0].1["project"], "foreign-project");
assert!(captured[1].1["project"].is_null());
}
let _ = shutdown.send(());
server_task.await.expect("fake daemon server task");
}
#[tokio::test]
async fn daemon_proxy_ask_fallback_keeps_explicit_home_for_nested_route() {
let home = tempfile::TempDir::new().expect("HOME project root");
let sibling = tempfile::TempDir::new().expect("sibling project root");
let home = home.path().canonicalize().expect("canonical HOME root");
let sibling = sibling
.path()
.canonicalize()
.expect("canonical sibling root");
let home_id = crate::daemon::project_key(&home);
let sibling_id = crate::daemon::project_key(&sibling);
let (base_url, shutdown, daemon_task, fake) = spawn_failing_ask_then_echo_server().await;
let client = crate::daemon::DaemonSessionClient::new_for_test(
base_url,
home_id.clone(),
"session-id".to_string(),
"home-project".to_string(),
);
client.record_opened_root(home.clone());
client.record_opened_root(sibling.clone());
client.record_active_root(sibling);
let server = SymForgeServer::new_daemon_proxy(client);
*server.repo_root.write() = Some(home);
{
let mut degraded = server.daemon_degraded.lock();
degraded.degraded = true;
degraded.last_reconnect_attempt = Some(std::time::Instant::now());
}
let ask = tokio::spawn({
let server = server.clone();
let home_id = home_id.clone();
async move {
server
.ask(Parameters(crate::protocol::tools::SmartQueryInput {
project: Some(home_id),
query: "find symbol ask_fallback_target".to_string(),
max_tokens: None,
}))
.await
}
});
tokio::time::timeout(
std::time::Duration::from_secs(1),
fake.ask_entered.notified(),
)
.await
.expect("outer ask reached daemon");
fake.release_ask.notify_one();
let result = ask.await.expect("ask task");
assert!(
result.contains(&format!("selected-project={home_id}; tool=search_symbols")),
"the nested route must stay pinned to the HOME used for fallback: {result}"
);
assert!(
!result.contains(&format!("selected-project={sibling_id}")),
"the nested route must not inherit daemon ACTIVE: {result}"
);
{
let requests = fake.requests.lock();
assert_eq!(requests.len(), 2, "outer ask plus one nested route");
assert_eq!(requests[0].0, "ask");
assert_eq!(requests[0].1["project"], home_id);
assert_eq!(requests[1].0, "search_symbols");
assert_eq!(requests[1].1["project"], home_id);
}
let _ = shutdown.send(());
tokio::time::timeout(std::time::Duration::from_secs(1), daemon_task)
.await
.expect("fake daemon shutdown")
.expect("fake daemon task");
}
#[tokio::test]
async fn daemon_proxy_ask_fallback_pins_omitted_home_across_active_retarget() {
let home = tempfile::TempDir::new().expect("HOME project root");
let sibling = tempfile::TempDir::new().expect("sibling project root");
let home = home.path().canonicalize().expect("canonical HOME root");
let sibling = sibling
.path()
.canonicalize()
.expect("canonical sibling root");
let home_id = crate::daemon::project_key(&home);
let sibling_id = crate::daemon::project_key(&sibling);
let (base_url, shutdown, daemon_task, fake) = spawn_failing_ask_then_echo_server().await;
let client = crate::daemon::DaemonSessionClient::new_for_test(
base_url,
home_id.clone(),
"session-id".to_string(),
"home-project".to_string(),
);
client.record_opened_root(home.clone());
client.record_opened_root(sibling.clone());
client.record_active_root(home.clone());
let client_state = client.clone();
let server = SymForgeServer::new_daemon_proxy(client);
*server.repo_root.write() = Some(home);
{
let mut degraded = server.daemon_degraded.lock();
degraded.degraded = true;
degraded.last_reconnect_attempt = Some(std::time::Instant::now());
}
let ask = tokio::spawn({
let server = server.clone();
async move {
server
.ask(Parameters(crate::protocol::tools::SmartQueryInput {
project: None,
query: "find symbol ask_fallback_target".to_string(),
max_tokens: None,
}))
.await
}
});
tokio::time::timeout(
std::time::Duration::from_secs(1),
fake.ask_entered.notified(),
)
.await
.expect("outer ask reached daemon after snapshotting HOME");
client_state.record_active_root(sibling);
fake.release_ask.notify_one();
let result = ask.await.expect("ask task");
assert!(
result.contains(&format!("selected-project={home_id}; tool=search_symbols")),
"the nested route must stay pinned to the snapshotted HOME: {result}"
);
assert!(
!result.contains(&format!("selected-project={sibling_id}")),
"the nested route must not inherit the concurrently activated sibling: {result}"
);
{
let requests = fake.requests.lock();
assert_eq!(requests.len(), 2, "outer ask plus one nested route");
assert_eq!(requests[0].0, "ask");
assert_eq!(requests[0].1["project"], home_id);
assert_eq!(requests[1].0, "search_symbols");
assert_eq!(requests[1].1["project"], home_id);
}
let _ = shutdown.send(());
tokio::time::timeout(std::time::Duration::from_secs(1), daemon_task)
.await
.expect("fake daemon shutdown")
.expect("fake daemon task");
}
async fn spawn_truncated_project_evidence_server(
evidence: crate::protocol::result_status::ProjectEvidence,
) -> (String, tokio::task::JoinHandle<()>) {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind truncated daemon tool server");
let base_url = format!("http://{}", listener.local_addr().expect("listener addr"));
let task = tokio::spawn(async move {
let (mut socket, _) = listener.accept().await.expect("accept daemon tool call");
let mut request_prefix = [0u8; 4096];
let _ = socket
.read(&mut request_prefix)
.await
.expect("read daemon request prefix");
let receipt = serde_json::to_string(&evidence).expect("serialize project evidence");
let response = format!(
"HTTP/1.1 200 OK\r\ncontent-type: text/plain\r\n{}: {}\r\n\
content-length: 256\r\nconnection: close\r\n\r\npartial-body",
crate::protocol::result_status::PROJECT_EVIDENCE_HEADER,
receipt
);
socket
.write_all(response.as_bytes())
.await
.expect("write deliberately truncated daemon response");
socket.shutdown().await.expect("close truncated response");
});
(base_url, task)
}
#[tokio::test]
async fn daemon_receipt_is_not_recorded_before_body_is_observed() {
let target_evidence = crate::protocol::result_status::ProjectEvidence {
project_id: "foreign-project-id".to_string(),
project_name: "foreign-project".to_string(),
canonical_root: Some("C:/FOREIGN_ROOT/foreign-project".to_string()),
generation: 7,
index_state: "Ready".to_string(),
trust: "Ready".to_string(),
load_source: "truncated-daemon".to_string(),
index_files: 11,
index_symbols: 13,
};
let (base_url, server_task) =
spawn_truncated_project_evidence_server(target_evidence).await;
let daemon_client = crate::daemon::DaemonSessionClient::new_for_test(
base_url,
"home-project-id".to_string(),
"session-id".to_string(),
"home-project".to_string(),
);
let home_evidence = crate::protocol::result_status::ProjectEvidence {
project_id: "home-project-id".to_string(),
project_name: "home-project".to_string(),
canonical_root: Some("C:/HOME_ROOT/home-project".to_string()),
generation: 3,
index_state: "Ready".to_string(),
trust: "Ready".to_string(),
load_source: "home-seed".to_string(),
index_files: 5,
index_symbols: 8,
};
crate::protocol::result_status::with_project_evidence_scope(Some(home_evidence), async {
crate::protocol::result_status::clear_project_evidence();
daemon_client
.call_tool_value("find_references", serde_json::json!({}))
.await
.expect_err("a truncated response body must fail observation");
assert!(
crate::protocol::result_status::current_project_evidence().is_none(),
"a receipt is not trustworthy until its response body is fully observed"
);
})
.await;
server_task.await.expect("truncated daemon server task");
}
#[tokio::test]
async fn daemon_proxy_success_without_receipt_does_not_reuse_home_evidence() {
let control_home = tempfile::TempDir::new().expect("isolated control-state home");
let control_state = crate::domain::ControlStateDir::new(control_home.path().to_path_buf());
let (base_url, shutdown, calls, server_task) =
spawn_fake_tool_server("daemon-read-without-receipt").await;
let daemon_client = crate::daemon::DaemonSessionClient::new_for_test_at(
base_url,
"home-project-id".to_string(),
"session-id".to_string(),
"home-project".to_string(),
control_state,
);
let server = SymForgeServer::new_daemon_proxy(daemon_client);
let home_root = tempfile::TempDir::new().expect("coherent home root");
let home_root_path = home_root.path().to_path_buf();
let home_id = crate::daemon::project_key(&home_root_path);
let home_canon = crate::daemon::normalized_path_string(&home_root_path);
let home_evidence = crate::protocol::result_status::ProjectEvidence {
project_id: home_id,
project_name: "home-project".to_string(),
canonical_root: Some(home_canon),
generation: 3,
index_state: "Ready".to_string(),
trust: "Ready".to_string(),
load_source: "home-seed".to_string(),
index_files: 5,
index_symbols: 8,
};
crate::protocol::result_status::with_project_evidence_scope(Some(home_evidence), async {
let body = server
.proxy_tool_call("find_references", &serde_json::json!({ "name": "cfg_if" }))
.await;
assert_eq!(body.as_deref(), Some("daemon-read-without-receipt"));
let leftover = crate::protocol::result_status::current_project_evidence();
assert!(
leftover.is_none(),
"a successful proxy response without a daemon receipt must not reuse HOME; leftover={leftover:?}"
);
})
.await;
assert_eq!(calls.load(Ordering::Relaxed), 1);
let _ = shutdown.send(());
server_task.await.expect("fake tool server task");
drop((control_home, home_root));
}
#[tokio::test]
async fn daemon_proxy_facade_calls_fail_closed_on_missing_or_malformed_outcome_header() {
for (header, body) in [
(
None,
"Error: this source file begins with an error-like line",
),
(
Some("{"),
"Index is loading... this is source text, not daemon status",
),
(None, "No matches found for query `Error: missing file`"),
] {
let control_home = tempfile::TempDir::new().expect("isolated control-state home");
let control_state =
crate::domain::ControlStateDir::new(control_home.path().to_path_buf());
let (base_url, shutdown, calls, server_task) =
spawn_fake_tool_server_with_read_outcome_header(body, header).await;
let daemon_client = crate::daemon::DaemonSessionClient::new_for_test_at(
base_url,
"home-project-id".to_string(),
"session-id".to_string(),
"home-project".to_string(),
control_state,
);
let server = SymForgeServer::new_daemon_proxy(daemon_client);
let result = server
.get_file_content_tool(Parameters(
serde_json::from_value(serde_json::json!({ "path": "notes/error.txt" }))
.expect("file content input"),
))
.await
.expect("get_file_content tool result");
assert_eq!(only_text(&result), body);
assert_eq!(result.is_error, Some(true));
assert_eq!(
result_status::observed_outcome_class(result.meta.as_ref()),
Some(result_status::OutcomeClass::InternalFailure)
);
let (facade_body, facade_class) = server
.facade_step(
"get_file_content",
serde_json::json!({ "path": "notes/error.txt" }),
)
.await;
assert_eq!(facade_body, body);
assert_eq!(facade_class, result_status::OutcomeClass::InternalFailure);
let uri = "symforge://file/content?path=notes%2Ferror.txt";
let resource_error = server
.read_resource_uri(uri)
.await
.expect_err("typed read without a valid outcome must fail closed");
assert_eq!(resource_error.code, rmcp::model::ErrorCode::INTERNAL_ERROR);
assert_eq!(resource_error.message, body);
assert_eq!(
resource_error.data,
Some(serde_json::json!({
"uri": uri,
"reason": "index_unavailable",
"retryable": false,
}))
);
for tool in crate::stel::planner::FacadeStepTool::ALL {
let tool = tool.as_str();
let (proxied_body, outcome) = result_status::with_read_outcome_scope(
server.proxy_tool_call(tool, &serde_json::json!({})),
)
.await;
assert_eq!(proxied_body.as_deref(), Some(body), "{tool}");
assert_eq!(
outcome.map(result_status::ReadOutcome::class),
Some(result_status::OutcomeClass::InternalFailure),
"{tool} must not classify source text when its typed header is absent or malformed"
);
}
assert_eq!(
calls.load(Ordering::Relaxed),
3 + crate::stel::planner::FacadeStepTool::ALL.len(),
);
let _ = shutdown.send(());
server_task.await.expect("fake daemon tool server task");
drop(control_home);
}
}
#[tokio::test]
async fn daemon_proxy_rejects_mismatched_or_set_valued_project_evidence() {
let (base_url, shutdown, requests, server_task) =
spawn_project_echo_tool_server_with_evidence_project(Some("home-project")).await;
let daemon_client = crate::daemon::DaemonSessionClient::new_for_test(
base_url,
"home-project-id".to_string(),
"session-id".to_string(),
"home-project".to_string(),
);
let server = SymForgeServer::new_daemon_proxy(daemon_client);
let home_evidence = crate::protocol::result_status::ProjectEvidence {
project_id: "home-project-id".to_string(),
project_name: "home-project".to_string(),
canonical_root: Some("C:/HOME".to_string()),
generation: 3,
index_state: "Ready".to_string(),
trust: "Ready".to_string(),
load_source: "home-seed".to_string(),
index_files: 5,
index_symbols: 8,
};
let cases = [
serde_json::json!({
"path": "src/lib.rs",
"project": "foreign-project",
}),
serde_json::json!({
"query": "thing",
"projects": ["foreign-project", "other-project"],
}),
serde_json::json!({
"query": "thing",
"project": 7,
}),
serde_json::json!({
"query": "thing",
"projects": [],
}),
serde_json::json!({
"query": "thing",
"projects": [""],
}),
serde_json::json!({
"query": "thing",
"projects": "foreign-project",
}),
];
for params in cases {
let (body, evidence, meta) =
crate::protocol::result_status::with_project_evidence_scope(
Some(home_evidence.clone()),
async {
let body = server
.proxy_tool_call("search_text", ¶ms)
.await
.expect("fake daemon response");
let evidence = crate::protocol::result_status::current_project_evidence();
let mut meta = None;
crate::protocol::result_status::attach_project_evidence_meta(&mut meta);
(body, evidence, meta)
},
)
.await;
assert!(body.contains("tool=search_text"), "fake body: {body}");
assert!(
evidence.is_none(),
"a scalar mismatch or set-valued result cannot carry one project receipt"
);
let meta = serde_json::to_value(meta).expect("serialize project evidence metadata");
assert_eq!(
meta["symforge/project_evidence"],
serde_json::json!({
"bound": false,
"reason": "project_evidence_unavailable",
}),
"the public seam must disclose unavailable evidence exactly: {meta}"
);
}
assert_eq!(requests.lock().len(), 6);
let _ = shutdown.send(());
server_task.await.expect("fake daemon server task");
}
#[tokio::test]
async fn daemon_proxy_binds_an_omitted_selector_to_the_active_project() {
let (base_url, shutdown, requests, server_task) =
spawn_project_echo_tool_server_with_evidence_project(Some("home-project")).await;
let active = tempfile::TempDir::new().expect("active sibling root");
let client = crate::daemon::DaemonSessionClient::new_for_test(
base_url,
"home-project-id".to_string(),
"session-id".to_string(),
"home-project".to_string(),
);
client.record_opened_root(active.path().to_path_buf());
client.record_active_root(active.path().to_path_buf());
let expected_active_id = client.active_project_id();
assert_ne!(expected_active_id, client.project_id());
let server = SymForgeServer::new_daemon_proxy(client);
let (body, evidence, meta) =
crate::protocol::result_status::with_project_evidence_scope(None, async {
let body = server
.proxy_tool_call(
"replace_symbol_body",
&serde_json::json!({
"path": "src/lib.rs",
"name": "thing",
"body": "fn thing() {}",
"project": null,
}),
)
.await
.expect("fake daemon response");
let evidence = crate::protocol::result_status::current_project_evidence();
let mut meta = None;
crate::protocol::result_status::attach_project_evidence_meta(&mut meta);
(body, evidence, meta)
})
.await;
assert!(
body.contains("tool=replace_symbol_body"),
"fake body: {body}"
);
assert!(
evidence.is_none(),
"an omitted selector must accept only the ACTIVE project's canonical receipt"
);
let meta = serde_json::to_value(meta).expect("serialize project evidence metadata");
assert_eq!(
meta["symforge/project_evidence"],
serde_json::json!({
"bound": false,
"reason": "project_evidence_unavailable",
})
);
{
let captured = requests.lock();
assert_eq!(captured.len(), 1);
assert_eq!(
captured[0].1["project"], expected_active_id,
"the omitted edit must be pinned to the ACTIVE snapshot before dispatch"
);
}
for tool_name in [
"inspect_match",
"checkpoint_now",
"detect_impact",
"conventions",
"health",
"health_compact",
"status",
"context_inventory",
"symforge_retrieve",
] {
let body = server
.proxy_tool_call(tool_name, &serde_json::json!({}))
.await
.expect("fake daemon response");
assert!(body.contains(&format!("tool={tool_name}")), "{body}");
}
{
let requests = requests.lock();
assert_eq!(requests.len(), 10);
for (tool_name, args) in requests.iter().skip(1) {
assert_eq!(
args[crate::daemon::PRIVATE_PROJECT_ROUTE_PIN],
expected_active_id,
"selector-less {tool_name} must carry the canonical ACTIVE snapshot"
);
assert!(
args.get("project").is_none(),
"the private route pin must not widen the public {tool_name} schema"
);
}
}
let _ = shutdown.send(());
server_task.await.expect("fake daemon server task");
}
#[tokio::test]
async fn call_scope_does_not_seed_home_evidence_for_omitted_active_sibling_requests() {
let active = tempfile::TempDir::new().expect("active sibling root");
let client = crate::daemon::DaemonSessionClient::new_for_test(
"http://127.0.0.1:1".to_string(),
"home-project-id".to_string(),
"session-id".to_string(),
"home-project".to_string(),
);
client.record_opened_root(active.path().to_path_buf());
client.record_active_root(active.path().to_path_buf());
let server = SymForgeServer::new_daemon_proxy(client);
let omitted = serde_json::json!({"query": "invalid early request"})
.as_object()
.expect("arguments object")
.clone();
assert!(
server
.initial_project_evidence_for_call(Some(&omitted))
.await
.is_none(),
"an omitted selector targets ACTIVE, so an active sibling cannot inherit HOME evidence"
);
}
#[tokio::test]
async fn daemon_proxy_rejects_a_coherent_receipt_for_an_unresolved_selector() {
let (base_url, shutdown, requests, server_task) = spawn_project_echo_tool_server().await;
let active = tempfile::TempDir::new().expect("active sibling root");
let client = crate::daemon::DaemonSessionClient::new_for_test(
base_url,
"home-project-id".to_string(),
"session-id".to_string(),
"home-project".to_string(),
);
client.record_opened_root(active.path().to_path_buf());
client.record_active_root(active.path().to_path_buf());
let server = SymForgeServer::new_daemon_proxy(client);
crate::protocol::result_status::with_project_evidence_scope(None, async {
let body = server
.proxy_tool_call(
"search_text",
&serde_json::json!({
"query": "thing",
"project": "not-an-open-project",
}),
)
.await
.expect("fake daemon response");
assert!(body.contains("selected-project=not-an-open-project"));
assert!(
crate::protocol::result_status::current_project_evidence().is_none(),
"a syntactically coherent receipt cannot authorize an unresolved selector"
);
})
.await;
assert_eq!(requests.lock().len(), 1);
let _ = shutdown.send(());
server_task.await.expect("fake daemon server task");
}
#[tokio::test]
async fn daemon_proxy_never_falls_back_to_home_for_an_active_sibling() {
let active = tempfile::TempDir::new().expect("active sibling root");
let client = crate::daemon::DaemonSessionClient::new_for_test(
"http://127.0.0.1:1".to_string(),
"home-project-id".to_string(),
"session-id".to_string(),
"home-project".to_string(),
);
client.record_opened_root(active.path().to_path_buf());
client.record_active_root(active.path().to_path_buf());
assert!(!client.active_project_is_home());
let server = SymForgeServer::new_daemon_proxy(client);
{
let mut degraded = server.daemon_degraded.lock();
degraded.degraded = true;
degraded.last_reconnect_attempt = Some(std::time::Instant::now());
}
let (result, evidence) = crate::protocol::result_status::with_project_evidence_scope(
server.local_project_evidence(),
async {
let result = server
.proxy_tool_call(
"search_text",
&serde_json::json!({"query": "active sibling marker"}),
)
.await;
let evidence = crate::protocol::result_status::current_project_evidence();
(result, evidence)
},
)
.await;
let refusal = result.expect(
"an unqualified ACTIVE-sibling call must refuse instead of falling back to HOME",
);
assert!(
refusal.starts_with("Error: project_routing:")
&& refusal.contains("ACTIVE daemon project"),
"unexpected active-project fallback refusal: {refusal}"
);
assert!(
evidence.is_none(),
"a failed ACTIVE-sibling route must never retain HOME evidence"
);
}
#[test]
fn constructed_servers_default_to_an_inert_transport_lane() {
let local = make_local_server(None);
assert_eq!(
local.transport_lane,
repeat::TransportLane::Shared,
"new_with_state_placement must leave the lane inert"
);
assert_eq!(
local.clone().transport_lane,
repeat::TransportLane::Shared,
"a clone (the HTTP factory clones per request) inherits the lane"
);
let proxy =
SymForgeServer::new_daemon_proxy(crate::daemon::DaemonSessionClient::new_for_test(
"http://127.0.0.1:1".to_string(),
"project-id".to_string(),
"session-id".to_string(),
"project-name".to_string(),
));
assert_eq!(
proxy.transport_lane,
repeat::TransportLane::Shared,
"new_daemon_proxy_with_state_placement must leave the lane inert"
);
let declared = local.with_stdio_transport_lane();
assert_eq!(declared.transport_lane, repeat::TransportLane::Stdio);
assert_eq!(
declared.clone().transport_lane,
repeat::TransportLane::Stdio
);
}
fn seed_repeat_run(server: &SymForgeServer) -> repeat::RepeatKey {
let args: rmcp::model::JsonObject =
serde_json::from_value(serde_json::json!({ "query": "anchor" })).expect("object");
let epoch = server.repeat_tracker.lock().epoch();
let key = repeat::RepeatKey::observe(
repeat::LaneWitness::assume(repeat::SessionDiscriminator::Stdio),
epoch,
"search_symbols",
Some(&args),
)
.expect("an eligible stdio call keys the tracker");
let evidence = result_status::ProjectEvidence {
project_id: "project-v1-seed".to_string(),
project_name: "seed".to_string(),
canonical_root: Some("C:/seed".to_string()),
generation: 1,
index_state: "Ready".to_string(),
trust: "Ready".to_string(),
load_source: "memory".to_string(),
index_files: 1,
index_symbols: 1,
};
let observed = || {
repeat::ServeObservation::observed_for_test(repeat::ObservedServe::for_test(
evidence.clone(),
&[rmcp::model::ContentBlock::text("body")],
))
};
let mut tracker = server.repeat_tracker.lock();
assert!(tracker.record_serve(key.clone(), observed()).is_none());
assert!(tracker.record_serve(key.clone(), observed()).is_none());
assert_eq!(tracker.len(), 1, "one run seeded at count 2");
key
}
#[tokio::test]
async fn daemon_degraded_clears_on_next_success() {
let (base_url, shutdown, calls, server_task) = spawn_fake_tool_server("daemon-ok").await;
let daemon_client = crate::daemon::DaemonSessionClient::new_for_test(
base_url,
"project-id".to_string(),
"session-id".to_string(),
"project-name".to_string(),
);
let server = SymForgeServer::new_daemon_proxy(daemon_client);
server.daemon_degraded.lock().degraded = true;
let _seeded = seed_repeat_run(&server);
let result = server
.proxy_tool_call("health", &serde_json::json!({}))
.await;
let _ = shutdown.send(());
server_task.await.expect("fake daemon server task");
assert_eq!(result.as_deref(), Some("daemon-ok"));
assert_eq!(
calls.load(Ordering::Relaxed),
1,
"degraded proxy should still probe the daemon once"
);
assert!(
!server.daemon_degraded.lock().degraded,
"successful proxy call should clear daemon_degraded"
);
assert!(
server.repeat_tracker.lock().is_empty(),
"the degraded -> daemon-served transition must clear every repeat run"
);
}
#[tokio::test]
async fn daemon_failure_transition_clears_repeat_runs() {
let daemon_client = crate::daemon::DaemonSessionClient::new_for_test(
"http://127.0.0.1:1".to_string(),
"project-id".to_string(),
"session-id".to_string(),
"project-name".to_string(),
);
let server = SymForgeServer::new_daemon_proxy(daemon_client);
assert!(!server.daemon_degraded.lock().degraded, "starts healthy");
let _seeded = seed_repeat_run(&server);
let result = server
.proxy_tool_call("health", &serde_json::json!({}))
.await;
assert!(result.is_none(), "the failed daemon falls back locally");
assert!(server.daemon_degraded.lock().degraded);
assert!(
server.repeat_tracker.lock().is_empty(),
"the daemon-served -> locally-served transition must clear every repeat run"
);
}
#[tokio::test]
async fn degraded_dead_endpoint_respects_reconnect_cooldown() {
let daemon_client = crate::daemon::DaemonSessionClient::new_for_test(
"http://127.0.0.1:1".to_string(),
"project-id".to_string(),
"session-id".to_string(),
"project-name".to_string(),
);
let server = SymForgeServer::new_daemon_proxy(daemon_client);
let attempt = std::time::Instant::now();
{
let mut state = server.daemon_degraded.lock();
state.degraded = true;
state.last_reconnect_attempt = Some(attempt);
}
let result = server
.proxy_tool_call("health", &serde_json::json!({}))
.await;
assert!(result.is_none(), "cooldown must serve the local fallback");
let state = server.daemon_degraded.lock();
assert!(state.degraded, "failed probe keeps the degraded state");
assert_eq!(
state.last_reconnect_attempt,
Some(attempt),
"cooldown must suppress the reconnect attempt (no storm)"
);
assert_eq!(
state.last_endpoint.as_deref(),
Some("http://127.0.0.1:1"),
"the failed endpoint must be recorded for health"
);
}
#[tokio::test]
async fn degraded_dead_endpoint_rediscovers_after_cooldown() {
let daemon_client = crate::daemon::DaemonSessionClient::new_for_test(
"http://127.0.0.1:1".to_string(),
"project-id".to_string(),
"session-id".to_string(),
"project-name".to_string(),
);
let server = SymForgeServer::new_daemon_proxy(daemon_client);
let past_attempt = std::time::Instant::now()
- DAEMON_RECONNECT_COOLDOWN
- std::time::Duration::from_secs(1);
{
let mut state = server.daemon_degraded.lock();
state.degraded = true;
state.last_reconnect_attempt = Some(past_attempt);
}
let result = server
.proxy_tool_call("health", &serde_json::json!({}))
.await;
assert!(
result.is_none(),
"failed rediscovery still falls back local"
);
let state = server.daemon_degraded.lock();
let bumped = state
.last_reconnect_attempt
.expect("past cooldown must attempt bounded rediscovery");
assert!(
bumped > past_attempt,
"the reconnect attempt marker must advance past the cooldown"
);
assert!(
state.degraded,
"failed rediscovery keeps the degraded state"
);
}
#[tokio::test]
async fn daemon_proxy_with_durable_store_records_symforge_event_through() {
let (base_url, shutdown, _calls, server_task) =
spawn_fake_tool_server("references to cfg_if:\n src/lib.rs:1").await;
let daemon_client = crate::daemon::DaemonSessionClient::new_for_test(
base_url,
"project-id".to_string(),
"session-id".to_string(),
"project-name".to_string(),
);
let store = Arc::new(
crate::stel::ledger_store::StelLedgerStore::open_in_memory("stdio-daemon-test")
.expect("in-memory durable store"),
);
let server = SymForgeServer::new_daemon_proxy(daemon_client)
.with_stel_ledger_store(Arc::clone(&store));
assert_eq!(store.summary().expect("summary").total_events, 0);
let request = crate::stel::StelRequest {
query: "who references cfg_if".to_string(),
..Default::default()
};
let _ = server
.symforge_stel_handler(&request)
.await
.expect("symforge_stel_handler dispatch");
let _ = shutdown.send(());
server_task.await.expect("fake daemon server task");
assert_eq!(
server.stel_ledger().lock().len(),
1,
"the proxy's in-memory ledger must record the event"
);
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
let total = loop {
let total = store.summary().map(|s| s.total_events).unwrap_or(0);
if total >= 1 || std::time::Instant::now() >= deadline {
break total;
}
tokio::time::sleep(std::time::Duration::from_millis(10)).await;
};
assert_eq!(
total, 1,
"the durable store attached on the daemon-proxy path must record the symforge event"
);
let recent = store.recent(10).expect("recent durable rows");
assert_eq!(recent.len(), 1);
assert_eq!(
recent[0].session_id, "stdio-daemon-test",
"the durable row carries the proxy store's session id"
);
}
#[tokio::test]
async fn daemon_facade_omission_routes_active_selectorless_steps_without_public_project() {
let (base_url, shutdown, requests, server_task) = spawn_project_echo_tool_server().await;
let active = tempfile::tempdir().expect("active project root");
let active_root = active.path().canonicalize().expect("canonical active root");
let active_id = crate::daemon::project_key(&active_root);
let daemon_client = crate::daemon::DaemonSessionClient::new_for_test(
base_url,
"home-project-id".to_string(),
"session-id".to_string(),
"home-project".to_string(),
);
daemon_client.record_opened_root(active_root.clone());
daemon_client.record_active_root(active_root);
let server = SymForgeServer::new_daemon_proxy(daemon_client);
for (query, intent) in [
(
"show the repository blast radius",
crate::stel::IntentBucket::Impact,
),
(
"show current context inventory",
crate::stel::IntentBucket::Meta,
),
] {
let request = crate::stel::StelRequest {
query: query.to_string(),
intent: Some(intent),
..Default::default()
};
let result = server
.symforge_stel_handler(&request)
.await
.expect("omitted-project facade dispatch");
let serialized = serde_json::to_value(&result).expect("serialize facade result");
let text = serialized["content"][0]["text"]
.as_str()
.expect("facade result text");
assert!(
!text.contains("cannot be routed through this plan"),
"an omitted selector must use session routing instead of the explicit-selector refusal: {text}"
);
}
let _ = shutdown.send(());
server_task.await.expect("fake daemon server task");
let captured = requests.lock();
assert_eq!(captured.len(), 2, "both selectorless plans must dispatch");
assert_eq!(captured[0].0, "detect_impact");
assert_eq!(
captured[0]
.1
.get(crate::daemon::PRIVATE_PROJECT_ROUTE_PIN)
.and_then(serde_json::Value::as_str),
Some(active_id.as_str()),
"selectorless project-bound tools use the private ACTIVE pin"
);
assert!(captured[0].1.get("project").is_none());
assert_eq!(captured[1].0, "context_inventory");
assert!(captured[1].1.get("project").is_none());
assert_eq!(
captured[1]
.1
.get(crate::daemon::PRIVATE_PROJECT_ROUTE_PIN)
.and_then(serde_json::Value::as_str),
Some(active_id.as_str()),
"selectorless session metadata is privately pinned to the snapshotted ACTIVE project"
);
}
#[tokio::test]
async fn daemon_facade_routes_foreign_project_into_served_primitive() {
let (base_url, shutdown, requests, server_task) = spawn_project_echo_tool_server().await;
let daemon_client = crate::daemon::DaemonSessionClient::new_for_test(
base_url,
"home-project-id".to_string(),
"session-id".to_string(),
"home-project".to_string(),
);
let server = SymForgeServer::new_daemon_proxy(daemon_client);
server.daemon_degraded.lock().degraded = true;
let home_root = tempfile::tempdir().expect("home-project root");
server.set_repo_root(Some(home_root.path().to_path_buf()));
let request = crate::stel::StelRequest {
query: "who references cfg_if".to_string(),
project: Some("foreign-project".to_string()),
..Default::default()
};
let result = crate::protocol::result_status::with_project_evidence_scope(
None,
server.symforge_stel_handler(&request),
)
.await
.expect("healthy daemon facade dispatch");
let serialized = serde_json::to_value(&result).expect("serialize facade result");
let text = serialized["content"][0]["text"]
.as_str()
.expect("facade result has text");
let home = home_root.path().display().to_string().replace('\\', "/");
assert!(
text.contains("project_root: C:/FOREIGN_ROOT/foreign-project"),
"the facade must render the selected daemon project's root receipt: {text}"
);
assert!(
!text.contains(&format!("project_root: {home}")),
"the facade must not label a foreign result with its home root: {text}"
);
let evidence = &serialized["_meta"]["symforge/project_evidence"];
assert_eq!(
evidence["project_name"], "foreign-project",
"typed evidence must name the selected daemon project: {serialized}"
);
assert_eq!(
evidence["canonical_root"], "C:/FOREIGN_ROOT/foreign-project",
"typed evidence must carry the selected daemon root: {serialized}"
);
let _ = shutdown.send(());
server_task.await.expect("fake daemon server task");
let requests = requests.lock();
assert_eq!(
requests.len(),
1,
"the healthy daemon facade must dispatch exactly one planned primitive"
);
let (tool, args) = &requests[0];
assert_eq!(tool, "find_references");
assert_eq!(
args.get("project").and_then(serde_json::Value::as_str),
Some("foreign-project"),
"the facade must inject the selected project before daemon dispatch"
);
assert!(
server.daemon_degradation_snapshot().is_none(),
"a successful routed probe must recover the compact facade"
);
}
#[tokio::test]
async fn daemon_facade_never_reuses_home_evidence_when_foreign_receipt_is_missing() {
let (base_url, shutdown, calls, server_task) =
spawn_fake_tool_server("references to cfg_if:\n foreign/src/lib.rs:1").await;
let daemon_client = crate::daemon::DaemonSessionClient::new_for_test(
base_url,
"home-project-id".to_string(),
"session-id".to_string(),
"home-project".to_string(),
);
let server = SymForgeServer::new_daemon_proxy(daemon_client);
let home_root = tempfile::tempdir().expect("home-project root");
server.set_repo_root(Some(home_root.path().to_path_buf()));
let home = home_root.path().display().to_string().replace('\\', "/");
let home_evidence = crate::protocol::result_status::ProjectEvidence {
project_id: "home-project-id".to_string(),
project_name: "home-project".to_string(),
canonical_root: Some(home.clone()),
generation: 3,
index_state: "Ready".to_string(),
trust: "Ready".to_string(),
load_source: "home-seed".to_string(),
index_files: 5,
index_symbols: 8,
};
let request = crate::stel::StelRequest {
query: "who references cfg_if".to_string(),
project: Some("foreign-project".to_string()),
..Default::default()
};
let result = crate::protocol::result_status::with_project_evidence_scope(
Some(home_evidence),
async {
let mut result = server.symforge_stel_handler(&request).await?;
crate::protocol::result_status::attach_project_evidence_meta(&mut result.meta);
Ok::<_, rmcp::ErrorData>(result)
},
)
.await
.expect("foreign facade dispatch without daemon evidence receipt");
let serialized = serde_json::to_value(&result).expect("serialize foreign facade result");
let text = serialized["content"][0]["text"]
.as_str()
.expect("foreign facade result has text");
assert!(
text.contains(
"project_root: (routed project foreign-project; daemon receipt unavailable)"
),
"missing target evidence must be disclosed without substituting HOME: {text}"
);
assert!(
!text.contains(&home),
"foreign response body must never inherit the adapter home root: {text}"
);
assert_eq!(
serialized["_meta"]["symforge/project_evidence"],
serde_json::json!({
"bound": false,
"reason": "project_evidence_unavailable",
}),
"foreign result without a target receipt must disclose unavailable evidence: {serialized}"
);
assert_eq!(calls.load(Ordering::Relaxed), 1);
let _ = shutdown.send(());
server_task.await.expect("fake daemon server task");
}
#[tokio::test]
async fn daemon_facade_rejects_a_mismatched_foreign_project_receipt() {
let (base_url, shutdown, requests, server_task) =
spawn_project_echo_tool_server_with_evidence_project(Some("home-project")).await;
let daemon_client = crate::daemon::DaemonSessionClient::new_for_test(
base_url,
"home-project-id".to_string(),
"session-id".to_string(),
"home-project".to_string(),
);
let server = SymForgeServer::new_daemon_proxy(daemon_client);
let request = crate::stel::StelRequest {
query: "who references cfg_if".to_string(),
project: Some("foreign-project".to_string()),
..Default::default()
};
let result = crate::protocol::result_status::with_project_evidence_scope(None, async {
let mut result = server.symforge_stel_handler(&request).await?;
crate::protocol::result_status::attach_project_evidence_meta(&mut result.meta);
Ok::<_, rmcp::ErrorData>(result)
})
.await
.expect("foreign facade dispatch with mismatched daemon receipt");
let serialized = serde_json::to_value(&result).expect("serialize foreign facade result");
let text = serialized["content"][0]["text"]
.as_str()
.expect("foreign facade result has text");
assert!(
text.contains(
"project_root: (routed project foreign-project; daemon receipt unavailable)"
),
"a mismatched receipt must be rejected rather than relabeled: {text}"
);
assert!(
!text.contains("C:/FOREIGN_ROOT/home-project"),
"a mismatched receipt must not leak into the response body: {text}"
);
assert_eq!(
serialized["_meta"]["symforge/project_evidence"],
serde_json::json!({
"bound": false,
"reason": "project_evidence_unavailable",
}),
"a mismatched receipt must disclose unavailable typed evidence: {serialized}"
);
assert_eq!(requests.lock().len(), 1);
let _ = shutdown.send(());
server_task.await.expect("fake daemon server task");
}
#[tokio::test]
async fn daemon_facade_requires_one_consistent_receipt_for_every_foreign_step() {
let (base_url, shutdown, requests, server_task) =
spawn_project_echo_tool_server_with_policy(
None,
Some("search_files"),
None,
None,
None,
)
.await;
let daemon_client = crate::daemon::DaemonSessionClient::new_for_test(
base_url,
"home-project-id".to_string(),
"session-id".to_string(),
"home-project".to_string(),
);
let server = SymForgeServer::new_daemon_proxy(daemon_client);
let request = crate::stel::StelRequest {
query: "widget routing".to_string(),
project: Some("foreign-project".to_string()),
..Default::default()
};
let result = crate::protocol::result_status::with_project_evidence_scope(None, async {
let mut result = server.symforge_stel_handler(&request).await?;
crate::protocol::result_status::attach_project_evidence_meta(&mut result.meta);
Ok::<_, rmcp::ErrorData>(result)
})
.await
.expect("foreign fused-find facade dispatch");
let serialized = serde_json::to_value(&result).expect("serialize foreign facade result");
let text = serialized["content"][0]["text"]
.as_str()
.expect("foreign facade result has text");
assert!(
text.contains("selected-project=foreign-project; tool=search_files")
&& text.contains("selected-project=foreign-project; tool=search_text"),
"both foreign steps must remain visible in the semantic body: {text}"
);
assert!(
text.contains(
"project_root: (routed project foreign-project; daemon receipt unavailable)"
),
"one unattested step makes the aggregate receipt unavailable: {text}"
);
assert_eq!(
serialized["_meta"]["symforge/project_evidence"],
serde_json::json!({
"bound": false,
"reason": "project_evidence_unavailable",
}),
"the public seam must disclose unavailable aggregate evidence exactly: {serialized}"
);
{
let captured = requests.lock();
assert_eq!(captured.len(), 2);
assert_eq!(captured[0].0, "search_files");
assert_eq!(captured[1].0, "search_text");
}
let _ = shutdown.send(());
server_task.await.expect("fake daemon server task");
}
#[tokio::test]
async fn daemon_facade_requires_one_consistent_receipt_for_every_home_step() {
let (base_url, shutdown, requests, server_task) =
spawn_project_echo_tool_server_with_policy(
None,
Some("search_files"),
None,
None,
None,
)
.await;
let daemon_client = crate::daemon::DaemonSessionClient::new_for_test(
base_url,
"home-project-id".to_string(),
"session-id".to_string(),
"home-project".to_string(),
);
let server = SymForgeServer::new_daemon_proxy(daemon_client);
let request = crate::stel::StelRequest {
query: "widget routing".to_string(),
..Default::default()
};
let result = crate::protocol::result_status::with_project_evidence_scope(None, async {
let mut result = server.symforge_stel_handler(&request).await?;
crate::protocol::result_status::attach_project_evidence_meta(&mut result.meta);
Ok::<_, rmcp::ErrorData>(result)
})
.await
.expect("home fused-find facade dispatch");
let serialized = serde_json::to_value(&result).expect("serialize home facade result");
assert_eq!(
serialized["_meta"]["symforge/project_evidence"],
serde_json::json!({
"bound": false,
"reason": "project_evidence_unavailable",
}),
"one unattested HOME step makes the aggregate receipt unavailable: {serialized}"
);
{
let captured = requests.lock();
assert_eq!(captured.len(), 2);
assert_eq!(captured[0].0, "search_files");
assert_eq!(captured[1].0, "search_text");
}
let _ = shutdown.send(());
server_task.await.expect("fake daemon server task");
}
#[tokio::test]
async fn daemon_facade_rejects_same_project_receipts_from_different_generations() {
let (base_url, shutdown, requests, server_task) =
spawn_project_echo_tool_server_with_policy(None, None, Some("search_text"), None, None)
.await;
let daemon_client = crate::daemon::DaemonSessionClient::new_for_test(
base_url,
"home-project-id".to_string(),
"session-id".to_string(),
"home-project".to_string(),
);
let server = SymForgeServer::new_daemon_proxy(daemon_client);
let request = crate::stel::StelRequest {
query: "widget routing".to_string(),
project: Some("foreign-project".to_string()),
..Default::default()
};
let result = crate::protocol::result_status::with_project_evidence_scope(None, async {
let mut result = server.symforge_stel_handler(&request).await?;
crate::protocol::result_status::attach_project_evidence_meta(&mut result.meta);
Ok::<_, rmcp::ErrorData>(result)
})
.await
.expect("foreign fused-find facade dispatch");
let serialized = serde_json::to_value(&result).expect("serialize foreign facade result");
let text = serialized["content"][0]["text"]
.as_str()
.expect("foreign facade result has text");
assert!(
text.contains(
"project_root: (routed project foreign-project; daemon receipt unavailable)"
),
"same-project receipts from different generations cannot attest one body: {text}"
);
assert_eq!(
serialized["_meta"]["symforge/project_evidence"],
serde_json::json!({
"bound": false,
"reason": "project_evidence_unavailable",
}),
"cross-generation aggregate evidence must be unavailable: {serialized}"
);
{
let captured = requests.lock();
assert_eq!(captured.len(), 2);
assert_eq!(captured[0].0, "search_files");
assert_eq!(captured[1].0, "search_text");
}
let _ = shutdown.send(());
server_task.await.expect("fake daemon server task");
}
#[tokio::test]
async fn daemon_facade_does_not_reuse_home_evidence_for_a_malformed_receipt() {
let (base_url, shutdown, requests, server_task) =
spawn_project_echo_tool_server_with_policy(
None,
None,
None,
Some("find_references"),
None,
)
.await;
let daemon_client = crate::daemon::DaemonSessionClient::new_for_test(
base_url,
"home-project-id".to_string(),
"session-id".to_string(),
"home-project".to_string(),
);
let server = SymForgeServer::new_daemon_proxy(daemon_client);
let home_evidence = crate::protocol::result_status::ProjectEvidence {
project_id: "home-project-id".to_string(),
project_name: "home-project".to_string(),
canonical_root: Some("C:/HOME".to_string()),
generation: 3,
index_state: "Ready".to_string(),
trust: "Ready".to_string(),
load_source: "home-seed".to_string(),
index_files: 5,
index_symbols: 8,
};
let request = crate::stel::StelRequest {
query: "who references cfg_if".to_string(),
project: Some("foreign-project".to_string()),
..Default::default()
};
let result = crate::protocol::result_status::with_project_evidence_scope(
Some(home_evidence),
async {
let mut result = server.symforge_stel_handler(&request).await?;
crate::protocol::result_status::attach_project_evidence_meta(&mut result.meta);
Ok::<_, rmcp::ErrorData>(result)
},
)
.await
.expect("foreign facade dispatch with malformed receipt");
let serialized = serde_json::to_value(&result).expect("serialize foreign facade result");
let text = serialized["content"][0]["text"]
.as_str()
.expect("foreign facade result has text");
assert!(
text.contains(
"project_root: (routed project foreign-project; daemon receipt unavailable)"
) && !text.contains("C:/HOME"),
"malformed target evidence must never retain HOME: {text}"
);
assert_eq!(
serialized["_meta"]["symforge/project_evidence"],
serde_json::json!({
"bound": false,
"reason": "project_evidence_unavailable",
}),
"malformed target evidence must be unavailable at the public seam: {serialized}"
);
assert_eq!(requests.lock().len(), 1);
let _ = shutdown.send(());
server_task.await.expect("fake daemon server task");
}
#[tokio::test]
async fn daemon_facade_rejects_a_selector_matching_receipt_with_an_incoherent_root() {
let (base_url, shutdown, requests, server_task) =
spawn_project_echo_tool_server_with_policy(
None,
None,
None,
None,
Some("find_references"),
)
.await;
let daemon_client = crate::daemon::DaemonSessionClient::new_for_test(
base_url,
"home-project-id".to_string(),
"session-id".to_string(),
"home-project".to_string(),
);
let server = SymForgeServer::new_daemon_proxy(daemon_client);
let request = crate::stel::StelRequest {
query: "who references cfg_if".to_string(),
project: Some("foreign-project".to_string()),
..Default::default()
};
let result = crate::protocol::result_status::with_project_evidence_scope(None, async {
let mut result = server.symforge_stel_handler(&request).await?;
crate::protocol::result_status::attach_project_evidence_meta(&mut result.meta);
Ok::<_, rmcp::ErrorData>(result)
})
.await
.expect("foreign facade dispatch with incoherent receipt");
let serialized = serde_json::to_value(&result).expect("serialize foreign facade result");
let text = serialized["content"][0]["text"]
.as_str()
.expect("foreign facade result has text");
assert!(
text.contains(
"project_root: (routed project foreign-project; daemon receipt unavailable)"
),
"a selector name cannot bless an incoherent ID/root pair: {text}"
);
assert_eq!(
serialized["_meta"]["symforge/project_evidence"],
serde_json::json!({
"bound": false,
"reason": "project_evidence_unavailable",
}),
"an incoherent receipt must be unavailable: {serialized}"
);
assert_eq!(requests.lock().len(), 1);
let _ = shutdown.send(());
server_task.await.expect("fake daemon server task");
}
#[tokio::test]
async fn daemon_facade_never_augments_foreign_impact_with_home_cochanges() {
use crate::live_index::git_temporal::{
CoChangeEntry, CommitSummary, GitFileHistory, GitTemporalIndex, GitTemporalState,
GitTemporalStats,
};
let (base_url, shutdown, requests, server_task) = spawn_project_echo_tool_server().await;
let daemon_client = crate::daemon::DaemonSessionClient::new_for_test(
base_url,
"home-project-id".to_string(),
"session-id".to_string(),
"home-project".to_string(),
);
let server = SymForgeServer::new_daemon_proxy(daemon_client);
let home_root = tempfile::tempdir().expect("home-project root");
server.set_repo_root(Some(home_root.path().to_path_buf()));
let home_history = GitFileHistory {
commit_count: 7,
churn_score: 0.9,
last_commit: CommitSummary {
hash: "abc1234".to_string(),
timestamp: "2026-06-01T12:00:00Z".to_string(),
author: "Tester".to_string(),
message_head: "touch widget".to_string(),
days_ago: 2.0,
},
contributors: vec![],
co_changes: vec![CoChangeEntry {
path: "src/HOME_ONLY_PARTNER.rs".to_string(),
coupling_score: 0.71,
shared_commits: 5,
}],
weak_co_changes: vec![],
};
server
.index
.data_plane()
.update_git_temporal(GitTemporalIndex {
files: std::collections::HashMap::from([(
"src/widget.rs".to_string(),
home_history,
)]),
stats: GitTemporalStats {
total_commits_analyzed: 14,
analysis_window_days: 90,
hotspots: vec![],
most_coupled: vec![],
computed_at: std::time::SystemTime::now(),
compute_duration: std::time::Duration::ZERO,
},
state: GitTemporalState::Ready,
});
let foreign = crate::stel::StelRequest {
query: "impact cfg_if".to_string(),
intent: Some(crate::stel::IntentBucket::Impact),
symbol: Some("cfg_if".to_string()),
path: Some("src/widget.rs".to_string()),
project: Some("foreign-project".to_string()),
..Default::default()
};
let result = crate::protocol::result_status::with_project_evidence_scope(
None,
server.symforge_stel_handler(&foreign),
)
.await
.expect("foreign impact facade dispatch");
let serialized = serde_json::to_value(&result).expect("serialize foreign impact result");
let text = serialized["content"][0]["text"]
.as_str()
.expect("foreign impact result has text");
assert!(
text.contains("selected-project=foreign-project; tool=find_dependents"),
"the foreign impact result must come from the selected daemon project: {text}"
);
assert!(
!text.contains("HOME_ONLY_PARTNER") && !text.contains("Co-changing files"),
"foreign impact must not be augmented from the facade's home index: {text}"
);
let home = crate::stel::StelRequest {
project: None,
path: Some("src/widget.rs".to_string()),
..foreign
};
let result = crate::protocol::result_status::with_project_evidence_scope(
None,
server.symforge_stel_handler(&home),
)
.await
.expect("home impact facade dispatch");
let serialized = serde_json::to_value(&result).expect("serialize home impact result");
let text = serialized["content"][0]["text"]
.as_str()
.expect("home impact result has text");
assert!(
text.contains("HOME_ONLY_PARTNER") && text.contains("Co-changing files"),
"home impact must retain the existing local co-change augmentation: {text}"
);
let _ = shutdown.send(());
server_task.await.expect("fake daemon server task");
let requests = requests.lock();
assert_eq!(requests.len(), 2);
assert_eq!(requests[0].0, "find_dependents");
assert_eq!(requests[1].0, "find_dependents");
assert_eq!(
requests[0]
.1
.get("project")
.and_then(serde_json::Value::as_str),
Some("foreign-project")
);
}
#[tokio::test]
async fn daemon_facade_never_rewrites_foreign_find_with_a_home_anchor() {
let home_root = tempfile::tempdir().expect("home project root");
std::fs::create_dir_all(home_root.path().join("src")).expect("home src directory");
std::fs::write(
home_root.path().join("src/homeanchor.rs"),
"pub fn homeanchor() {}\n",
)
.expect("home anchor source");
let (base_url, shutdown, requests, server_task) = spawn_project_echo_tool_server().await;
let daemon_client = crate::daemon::DaemonSessionClient::new_for_test(
base_url,
"home-project-id".to_string(),
"session-id".to_string(),
"home-project".to_string(),
);
let mut server = SymForgeServer::new_daemon_proxy(daemon_client);
server.index = crate::live_index::index_lifecycle::activation::ProjectRuntimeHandle::bind(
crate::live_index::LiveIndex::load(home_root.path()).expect("load home project index"),
);
let foreign = crate::stel::StelRequest {
query: "homeanchor routing".to_string(),
project: Some("foreign-project".to_string()),
..Default::default()
};
let result = crate::protocol::result_status::with_project_evidence_scope(
None,
server.symforge_stel_handler(&foreign),
)
.await
.expect("foreign fused-find facade dispatch");
let serialized = serde_json::to_value(&result).expect("serialize fused-find result");
let text = serialized["content"][0]["text"]
.as_str()
.expect("fused-find result has text");
assert!(
text.contains("project_root: C:/FOREIGN_ROOT/foreign-project"),
"equal receipts from every foreign step may attest the aggregate: {text}"
);
assert_eq!(
serialized["_meta"]["symforge/project_evidence"]["project_name"],
"foreign-project"
);
let foreign_requests = requests.lock().clone();
assert_eq!(foreign_requests.len(), 2);
let (tool, args) = &foreign_requests[0];
assert_eq!(tool, "search_files");
assert_eq!(
args.get("project").and_then(serde_json::Value::as_str),
Some("foreign-project")
);
assert_eq!(
args.get("query").and_then(serde_json::Value::as_str),
Some("homeanchor routing"),
"a foreign find must retain the caller's query"
);
assert!(
args.get("anchor_path")
.is_none_or(serde_json::Value::is_null)
&& args.get("rank_by").is_none_or(serde_json::Value::is_null),
"a foreign find must not carry a home-derived co-change anchor: {args}"
);
assert_eq!(foreign_requests[1].0, "search_text");
assert_eq!(
foreign_requests[1]
.1
.get("project")
.and_then(serde_json::Value::as_str),
Some("foreign-project")
);
requests.lock().clear();
let home = crate::stel::StelRequest {
project: None,
..foreign
};
crate::protocol::result_status::with_project_evidence_scope(
None,
server.symforge_stel_handler(&home),
)
.await
.expect("home fused-find facade dispatch");
let home_requests = requests.lock().clone();
assert_eq!(home_requests.len(), 2);
let (tool, args) = &home_requests[0];
assert_eq!(tool, "search_files");
assert_eq!(
args.get("query").and_then(serde_json::Value::as_str),
Some("homeanchor")
);
assert_eq!(
args.get("anchor_path").and_then(serde_json::Value::as_str),
Some("src/homeanchor.rs")
);
assert_eq!(
args.get("rank_by").and_then(serde_json::Value::as_str),
Some("path+cochange")
);
let _ = shutdown.send(());
server_task.await.expect("fake daemon server task");
}
#[tokio::test]
async fn daemon_facade_never_grounds_foreign_economics_from_home_bytes() {
let home_root = tempfile::tempdir().expect("home project root");
std::fs::create_dir_all(home_root.path().join("src")).expect("home src directory");
let mut source = "// home-only economics bytes\n".repeat(4_096);
source.push_str("pub fn shared() {}\n");
std::fs::write(home_root.path().join("src/shared.rs"), source).expect("large home source");
let (base_url, shutdown, _requests, server_task) = spawn_project_echo_tool_server().await;
let make_server = || {
let daemon_client = crate::daemon::DaemonSessionClient::new_for_test(
base_url.clone(),
"home-project-id".to_string(),
"session-id".to_string(),
"home-project".to_string(),
);
let mut server = SymForgeServer::new_daemon_proxy(daemon_client);
server.index =
crate::live_index::index_lifecycle::activation::ProjectRuntimeHandle::bind(
crate::live_index::LiveIndex::load(home_root.path())
.expect("load home project index"),
);
server
};
let foreign = crate::stel::StelRequest {
query: "read shared file".to_string(),
intent: Some(crate::stel::IntentBucket::Read),
path: Some("src/shared.rs".to_string()),
project: Some("foreign-project".to_string()),
..Default::default()
};
let floor_plan = crate::stel::planner::build_plan(&foreign);
assert!(floor_plan.steps[0].index_refs.is_empty());
let floor = crate::stel::controller::estimate_economics(&floor_plan);
let foreign_server = make_server();
crate::protocol::result_status::with_project_evidence_scope(
None,
foreign_server.symforge_stel_handler(&foreign),
)
.await
.expect("foreign read facade dispatch");
let foreign_event = foreign_server
.stel_ledger()
.lock()
.last()
.expect("foreign facade ledger event");
assert_eq!(
foreign_event.manual_baseline_tokens, floor.predicted_manual_tokens,
"foreign economics must retain the ungrounded target-plan floor"
);
assert_eq!(
foreign_event.predicted_response_tokens, floor.predicted_response_tokens,
"foreign response economics must not use home file bytes"
);
let home_server = make_server();
let home = crate::stel::StelRequest {
project: None,
..foreign
};
crate::protocol::result_status::with_project_evidence_scope(
None,
home_server.symforge_stel_handler(&home),
)
.await
.expect("home read facade dispatch");
let home_event = home_server
.stel_ledger()
.lock()
.last()
.expect("home facade ledger event");
assert_ne!(
home_event.manual_baseline_tokens, floor.predicted_manual_tokens,
"home reads must retain real-byte economics grounding"
);
let _ = shutdown.send(());
server_task.await.expect("fake daemon server task");
}
fn make_local_server(repo_root: Option<std::path::PathBuf>) -> SymForgeServer {
let index = crate::live_index::LiveIndex::empty();
let watcher_info = Arc::new(Mutex::new(WatcherInfo::default()));
SymForgeServer::new(
index,
"test_project".to_string(),
watcher_info,
repo_root,
None,
)
}
fn seed_project(dir: &std::path::Path, file_name: &str, body: &str) {
std::fs::write(dir.join(file_name), body).expect("seed project source file");
}
#[tokio::test]
async fn ensure_local_index_reloads_on_root_mismatch_without_reset() {
let dir_a = tempfile::TempDir::new().expect("temp dir A");
let dir_b = tempfile::TempDir::new().expect("temp dir B");
seed_project(dir_a.path(), "alpha.rs", "fn alpha_only() {}\n");
seed_project(dir_b.path(), "beta.rs", "fn beta_only() {}\n");
let server = make_local_server(Some(dir_a.path().to_path_buf()));
server.ensure_local_index().await;
let published_a = server.index.data_plane().published_state();
assert!(
published_a.file_count > 0,
"project A should have loaded a non-empty index"
);
assert_eq!(
published_a.indexed_root.as_deref(),
Some(crate::live_index::store::normalize_root(dir_a.path()).as_path()),
"loaded index must record project A's normalized root"
);
assert!(
server
.index
.data_plane()
.read()
.get_file("alpha.rs")
.is_some(),
"project A's file should be present after the first load"
);
let _seeded = seed_repeat_run(&server);
server.set_repo_root(Some(dir_b.path().to_path_buf()));
server.ensure_local_index().await;
assert!(
server.repeat_tracker.lock().is_empty(),
"a local index reload is a new incarnation: every repeat run must be cleared"
);
let published_b = server.index.data_plane().published_state();
assert_eq!(
published_b.indexed_root.as_deref(),
Some(crate::live_index::store::normalize_root(dir_b.path()).as_path()),
"after a root switch, ensure_local_index must serve project B's root"
);
assert!(
server
.index
.data_plane()
.read()
.get_file("beta.rs")
.is_some(),
"project B's file must be present after the root-mismatch reload"
);
assert!(
server
.index
.data_plane()
.read()
.get_file("alpha.rs")
.is_none(),
"project A's stale file must be gone after switching to project B"
);
}
#[tokio::test]
async fn ensure_local_index_does_not_reload_on_repeated_same_root_calls() {
let dir_a = tempfile::TempDir::new().expect("temp dir A");
seed_project(dir_a.path(), "alpha.rs", "fn alpha_only() {}\n");
let server = make_local_server(Some(dir_a.path().to_path_buf()));
server.ensure_local_index().await;
let gen_after_first = server.index.data_plane().current_project_generation();
let root_after_first = server
.index
.data_plane()
.published_state()
.indexed_root
.clone();
assert!(
server.index.data_plane().published_state().file_count > 0,
"first ensure_local_index call should have loaded project A"
);
let _seeded = seed_repeat_run(&server);
for _ in 0..3 {
server.ensure_local_index().await;
}
assert_eq!(
server.repeat_tracker.lock().len(),
1,
"a same-root no-op must leave repeat runs untouched"
);
assert_eq!(
server.index.data_plane().current_project_generation(),
gen_after_first,
"repeated same-root ensure_local_index calls must not reload (project generation must not change)"
);
assert_eq!(
server.index.data_plane().published_state().indexed_root,
root_after_first,
"repeated same-root calls must leave the recorded root unchanged"
);
}
#[test]
fn get_info_reports_symforge_name_and_crate_version() {
let server = make_local_server(None);
let info = ServerHandler::get_info(&server);
assert_eq!(
info.server_info.name, "symforge",
"serverInfo.name must identify symforge, not the rmcp framework"
);
assert_eq!(
info.server_info.version,
env!("CARGO_PKG_VERSION"),
"serverInfo.version must track the symforge crate version"
);
}
}