use parking_lot::{Mutex, RwLock};
use std::collections::{HashMap, HashSet};
use std::io;
use std::net::IpAddr;
use std::path::{Path, PathBuf};
use std::process::Stdio;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::time::{Duration, SystemTime};
use anyhow::Context;
use axum::extract::{Path as AxumPath, Query, State};
use axum::http::{HeaderMap, StatusCode, header};
use axum::routing::{delete, get, post};
use axum::{Json, Router};
use rmcp::handler::server::wrapper::Parameters;
use serde::{Deserialize, Serialize};
use tokio::net::TcpListener;
use crate::domain::{
CapabilityStatus, ControlStateDir, FreshnessStatus, ProjectCapabilities, RootBinding,
RootCandidateSource, RootRequestMode, RootResolution, SourceAccessMode, StatePlacement,
UnboundReason,
};
use crate::live_index::store::LiveIndex;
use crate::live_index::view::{BaseKey, CommitId, IndexBase, Targets, WorkingSet};
use crate::live_index::{self, SharedIndex};
use crate::paths;
use crate::protocol::SymForgeServer;
use crate::protocol::edit::{
BatchEditInput, BatchInsertInput, BatchRenameInput, DeleteSymbolInput, EditWithinSymbolInput,
InsertSymbolInput, ReplaceSymbolBodyInput,
};
use crate::protocol::read_tools::SymforgeRetrieveInput;
use crate::protocol::tools::{
AnalyzeFileImpactInput, CheckpointNowInput, CurateKnowledgeInput, DetectImpactInput,
DiffSymbolsInput, EditPlanInput, ExploreInput, FindDependentsInput, FindReferencesInput,
GetFileContentInput, GetFileContextInput, GetRepoMapInput, GetSymbolContextInput,
GetSymbolInput, HealthInput, IndexFolderInput, InspectMatchInput, InvestigationInput,
ReviewKnowledgeInput, SearchFilesInput, SearchKnowledgeInput, SearchSymbolsInput,
SearchTextInput, SmartQueryInput, TraceSymbolInput, ValidateFileSyntaxInput, WhatChangedInput,
search_symbols_options_from_input, search_text_options_from_input,
};
use crate::sidecar::{SidecarState, SymbolSnapshot, TokenStats};
use crate::watcher::{self, WatcherInfo};
const LEGACY_DAEMON_PORT_FILE: &str = "daemon.port";
const LEGACY_DAEMON_PID_FILE: &str = "daemon.pid";
#[cfg(test)]
const LEGACY_DAEMON_START_LOCK_FILE: &str = "daemon.starting";
fn daemon_port_file_name() -> String {
crate::paths::os_tagged_runtime_file_name("daemon", "port")
}
fn daemon_pid_file_name() -> String {
crate::paths::os_tagged_runtime_file_name("daemon", "pid")
}
fn daemon_start_lock_file_name() -> String {
crate::paths::os_tagged_runtime_file_name("daemon", "starting")
}
fn daemon_token_file_name() -> String {
crate::paths::os_tagged_runtime_file_name("daemon", "token")
}
fn read_daemon_runtime(dir: &std::path::Path, tagged: &str, legacy: &str) -> io::Result<String> {
match std::fs::read_to_string(dir.join(tagged)) {
Ok(c) => Ok(c),
Err(e) if e.kind() == io::ErrorKind::NotFound => std::fs::read_to_string(dir.join(legacy)),
Err(e) => Err(e),
}
}
const DAEMON_BIND_ENV: &str = "SYMFORGE_DAEMON_BIND";
const DAEMON_ALLOW_NON_LOOPBACK_ENV: &str = "SYMFORGE_DAEMON_ALLOW_NON_LOOPBACK";
const SESSION_TTL_ENV: &str = "SYMFORGE_SESSION_TTL_SECS";
const DEFAULT_SESSION_TTL_SECS: u64 = 86_400;
fn session_ttl_from_env() -> std::time::Duration {
let secs = std::env::var(SESSION_TTL_ENV)
.ok()
.and_then(|value| value.trim().parse::<u64>().ok())
.unwrap_or(DEFAULT_SESSION_TTL_SECS)
.max(60);
std::time::Duration::from_secs(secs)
}
const DAEMON_IDLE_SHUTDOWN_ENV: &str = "SYMFORGE_DAEMON_IDLE_SHUTDOWN_SECS";
const DEFAULT_DAEMON_IDLE_SHUTDOWN_SECS: u64 = 600;
fn daemon_idle_shutdown_from_env() -> Option<std::time::Duration> {
let value = std::env::var(DAEMON_IDLE_SHUTDOWN_ENV).ok()?;
let secs = value
.trim()
.parse::<u64>()
.unwrap_or(DEFAULT_DAEMON_IDLE_SHUTDOWN_SECS);
(secs > 0).then(|| std::time::Duration::from_secs(secs.max(60)))
}
const LOCAL_REF_LANES_ENV: &str = "SYMFORGE_LOCAL_REF_LANES";
fn local_ref_lanes_enabled() -> bool {
std::env::var(LOCAL_REF_LANES_ENV)
.ok()
.is_some_and(|value| {
matches!(
value.trim().to_ascii_lowercase().as_str(),
"1" | "true" | "on"
)
})
}
const DAEMON_AUTH_TOKEN_ENV: &str = "SYMFORGE_DAEMON_AUTH_TOKEN";
const TRACE_SYMBOL_ALIAS_DEPRECATION: &str = concat!(
"Deprecation warning: `trace_symbol` is retired; ",
"use `get_symbol_context` with `sections=[...]` or `find_references` instead. ",
"Compatibility policy: keep daemon alias through v7.x; planned removal in v8.0."
);
const DETECT_CHANGES_ALIAS_DEPRECATION: &str = concat!(
"Deprecation warning: `detect_changes` is a CBM-compatibility alias; ",
"use `detect_impact` instead. Compatibility policy: kept for CBM migrator ",
"ergonomics (decision-log D-015-012); no removal date set."
);
pub type SharedDaemonState = Arc<DaemonState>;
pub struct DaemonHandle {
pub port: u16,
pub shutdown_tx: tokio::sync::oneshot::Sender<()>,
pub state: SharedDaemonState,
server_task: tokio::task::JoinHandle<()>,
reaper_task: tokio::task::JoinHandle<()>,
}
#[derive(Clone)]
pub struct DaemonSessionClient {
http_client: reqwest::Client,
base_url: String,
project_id: String,
session_id: String,
project_name: String,
opened_roots: std::sync::Arc<parking_lot::Mutex<Vec<PathBuf>>>,
auth_token: Option<String>,
control_state_dir: ControlStateDir,
project_root: Option<PathBuf>,
}
pub struct DaemonState {
next_session_id: AtomicU64,
bases: RwLock<HashMap<BaseKey, Arc<IndexBase>>>,
base_generation_seq: AtomicU64,
projects: RwLock<HashMap<String, Arc<ProjectSlot>>>,
sessions: RwLock<HashMap<String, SessionRecord>>,
identity: DaemonIdentity,
auth_token: String,
control_state_dir: Option<ControlStateDir>,
governor: crate::sidecar::governor::RequestGovernor,
last_activity_at: AtomicU64,
active_authenticated_requests: AtomicU64,
idle_shutdown: tokio::sync::Notify,
}
struct AuthenticatedActivityGuard {
state: SharedDaemonState,
}
impl Drop for AuthenticatedActivityGuard {
fn drop(&mut self) {
self.state
.last_activity_at
.store(now_epoch_millis(), Ordering::Relaxed);
self.state
.active_authenticated_requests
.fetch_sub(1, Ordering::Relaxed);
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum ActivationState {
Inactive,
Activating,
Active,
}
struct ProjectInstance {
project_id: String,
canonical_root: PathBuf,
project_name: String,
source_access_mode: SourceAccessMode,
state_placement: StatePlacement,
persistence_health: Arc<RwLock<CapabilityStatus>>,
curation_coordinator: Arc<crate::protocol::knowledge_curation::KnowledgeCurationCoordinator>,
index: SharedIndex,
watcher_info: Arc<Mutex<WatcherInfo>>,
watcher_task: Option<tokio::task::JoinHandle<()>>,
stop_token: Arc<AtomicBool>,
token_stats: Arc<TokenStats>,
symbol_cache: Arc<RwLock<HashMap<String, Vec<SymbolSnapshot>>>>,
session_ids: HashSet<String>,
opened_at: SystemTime,
activation_state: ActivationState,
}
struct ProjectSlot {
metadata: RwLock<ProjectInstance>,
mutation: Mutex<()>,
}
struct SessionRecord {
session_id: String,
active_project_id: String,
working_set: Arc<RwLock<WorkingSet>>,
servers: HashMap<String, SymForgeServer>,
client_name: String,
pid: Option<u32>,
opened_at: SystemTime,
last_seen_at: AtomicU64,
}
impl Clone for SessionRecord {
fn clone(&self) -> Self {
Self {
session_id: self.session_id.clone(),
active_project_id: self.active_project_id.clone(),
working_set: Arc::clone(&self.working_set),
servers: self.servers.clone(),
client_name: self.client_name.clone(),
pid: self.pid,
opened_at: self.opened_at,
last_seen_at: AtomicU64::new(self.last_seen_at.load(Ordering::Relaxed)),
}
}
}
impl SessionRecord {
fn last_seen_at_time(&self) -> SystemTime {
let millis = self.last_seen_at.load(Ordering::Relaxed);
SystemTime::UNIX_EPOCH + Duration::from_millis(millis)
}
}
fn now_epoch_millis() -> u64 {
SystemTime::now()
.duration_since(SystemTime::UNIX_EPOCH)
.unwrap_or_default()
.as_millis() as u64
}
fn daemon_auth_token_from_env() -> Option<String> {
std::env::var(DAEMON_AUTH_TOKEN_ENV)
.ok()
.map(|value| value.trim().to_string())
.filter(|value| !value.is_empty())
}
fn daemon_auth_token_from_file() -> Option<String> {
let control_state_dir = process_control_state_dir().ok()?;
daemon_auth_token_from_file_at(control_state_dir)
}
fn daemon_auth_token_from_file_at(control_state_dir: &ControlStateDir) -> Option<String> {
let dir = daemon_dir_for(control_state_dir).ok()?;
let contents = std::fs::read_to_string(dir.join(daemon_token_file_name())).ok()?;
let trimmed = contents.trim().to_string();
if trimmed.is_empty() {
None
} else {
Some(trimmed)
}
}
pub(crate) fn resolve_daemon_auth_token() -> Option<String> {
daemon_auth_token_from_env().or_else(daemon_auth_token_from_file)
}
fn resolve_daemon_auth_token_at(control_state_dir: &ControlStateDir) -> Option<String> {
daemon_auth_token_from_env().or_else(|| daemon_auth_token_from_file_at(control_state_dir))
}
fn generate_daemon_auth_token() -> String {
#[cfg(unix)]
{
use std::io::Read;
if let Ok(mut f) = std::fs::File::open("/dev/urandom") {
let mut buf = [0u8; 32];
if f.read_exact(&mut buf).is_ok() {
return crate::hash::digest_hex(&buf);
}
}
}
use std::sync::atomic::{AtomicU64, Ordering};
static COUNTER: AtomicU64 = AtomicU64::new(0);
let mut seed: Vec<u8> = Vec::with_capacity(64);
let now_nanos = SystemTime::now()
.duration_since(SystemTime::UNIX_EPOCH)
.unwrap_or_default()
.as_nanos();
seed.extend_from_slice(&now_nanos.to_le_bytes());
let mono = std::time::Instant::now();
seed.extend_from_slice(&format!("{mono:?}").into_bytes());
seed.extend_from_slice(&std::process::id().to_le_bytes());
seed.extend_from_slice(&COUNTER.fetch_add(1, Ordering::Relaxed).to_le_bytes());
let boxed = Box::new(0u8);
let addr = (&*boxed as *const u8) as usize;
seed.extend_from_slice(&addr.to_le_bytes());
seed.extend_from_slice(format!("{:?}", std::thread::current().id()).as_bytes());
crate::hash::digest_hex(&seed)
}
fn establish_daemon_auth_token() -> String {
daemon_auth_token_from_env().unwrap_or_else(generate_daemon_auth_token)
}
fn write_daemon_token_file_at(control_state_dir: &ControlStateDir, token: &str) -> io::Result<()> {
let path = daemon_dir_for(control_state_dir)?.join(daemon_token_file_name());
#[cfg(unix)]
{
use std::io::Write;
use std::os::unix::fs::OpenOptionsExt;
use std::os::unix::fs::PermissionsExt;
let mut file = std::fs::OpenOptions::new()
.write(true)
.create(true)
.truncate(true)
.mode(0o600)
.open(&path)
.map_err(|e| {
io::Error::new(
e.kind(),
format!("writing daemon token file at {}: {}", path.display(), e),
)
})?;
file.write_all(token.as_bytes()).map_err(|e| {
io::Error::new(
e.kind(),
format!("writing daemon token file at {}: {}", path.display(), e),
)
})?;
let _ = std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600));
Ok(())
}
#[cfg(not(unix))]
{
std::fs::write(&path, token.as_bytes()).map_err(|e| {
io::Error::new(
e.kind(),
format!("writing daemon token file at {}: {}", path.display(), e),
)
})
}
}
fn env_var_truthy(name: &str) -> bool {
std::env::var(name)
.ok()
.map(|value| {
matches!(
value.trim().to_ascii_lowercase().as_str(),
"1" | "true" | "yes" | "on"
)
})
.unwrap_or(false)
}
fn is_loopback_bind_host(host: &str) -> bool {
let trimmed = host.trim().trim_start_matches('[').trim_end_matches(']');
trimmed.eq_ignore_ascii_case("localhost")
|| trimmed
.parse::<IpAddr>()
.map(|ip| ip.is_loopback())
.unwrap_or(false)
}
fn resolve_daemon_bind_host(default_host: &str) -> anyhow::Result<String> {
let configured = std::env::var(DAEMON_BIND_ENV).unwrap_or_else(|_| default_host.to_string());
let host = configured.trim();
if host.is_empty() {
anyhow::bail!("{DAEMON_BIND_ENV} must not be empty");
}
if is_loopback_bind_host(host) {
return Ok(host.to_string());
}
if env_var_truthy(DAEMON_ALLOW_NON_LOOPBACK_ENV) {
tracing::warn!(
bind_host = %host,
allow_env = DAEMON_ALLOW_NON_LOOPBACK_ENV,
"daemon binding to a non-loopback interface after explicit operator opt-in"
);
Ok(host.to_string())
} else {
anyhow::bail!(
"refusing non-loopback daemon bind '{host}'; set {DAEMON_ALLOW_NON_LOOPBACK_ENV}=1 to allow it explicitly"
);
}
}
fn daemon_socket_bind_address(host: &str) -> String {
let host = host.trim();
if host.contains(':') && !host.starts_with('[') {
format!("[{host}]:0")
} else {
format!("{host}:0")
}
}
fn apply_daemon_auth_header(
request: reqwest::RequestBuilder,
auth_token: Option<&str>,
) -> reqwest::RequestBuilder {
if let Some(token) = auth_token {
request.bearer_auth(token)
} else {
request
}
}
fn constant_time_eq(a: &[u8], b: &[u8]) -> bool {
if a.len() != b.len() {
return false;
}
let mut acc: u8 = 0;
for (lhs, rhs) in a.iter().zip(b.iter()) {
acc |= lhs ^ rhs;
}
acc == 0
}
fn authorize_daemon_request(
state: &SharedDaemonState,
headers: &HeaderMap,
) -> Result<AuthenticatedActivityGuard, StatusCode> {
let expected_token = state.auth_token.as_str();
let Some(header_value) = headers
.get(header::AUTHORIZATION)
.and_then(|value| value.to_str().ok())
else {
return Err(StatusCode::UNAUTHORIZED);
};
let Some((scheme, provided_token)) = header_value.split_once(' ') else {
return Err(StatusCode::UNAUTHORIZED);
};
if !scheme.eq_ignore_ascii_case("bearer") {
return Err(StatusCode::UNAUTHORIZED);
}
let expected_digest = crate::hash::digest(expected_token.as_bytes());
let provided_digest = crate::hash::digest(provided_token.as_bytes());
if constant_time_eq(&expected_digest, &provided_digest) {
state
.last_activity_at
.store(now_epoch_millis(), Ordering::Relaxed);
state
.active_authenticated_requests
.fetch_add(1, Ordering::Relaxed);
Ok(AuthenticatedActivityGuard {
state: Arc::clone(state),
})
} else {
Err(StatusCode::UNAUTHORIZED)
}
}
fn daemon_auth_error(status: StatusCode) -> (StatusCode, String) {
(status, "daemon authentication required".to_string())
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct OpenProjectRequest {
pub project_root: String,
pub client_name: String,
pub pid: Option<u32>,
}
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
pub struct OpenProjectResponse {
pub project_id: String,
pub session_id: String,
pub project_name: String,
pub canonical_root: String,
pub session_count: usize,
}
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
pub struct CloseSessionResponse {
pub session_id: String,
pub project_id: String,
pub remaining_sessions: usize,
pub project_removed: bool,
}
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
pub struct HeartbeatResponse {
pub session_id: String,
pub known_session: bool,
}
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
pub struct ProjectSummary {
pub project_id: String,
pub project_name: String,
pub canonical_root: String,
pub session_count: usize,
pub opened_at_unix_secs: u64,
}
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
pub struct SessionSummary {
pub session_id: String,
pub project_id: String,
pub client_name: String,
pub pid: Option<u32>,
pub opened_at_unix_secs: u64,
pub last_seen_at_unix_secs: u64,
}
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
pub struct ProjectHealth {
pub project_id: String,
pub project_name: String,
pub canonical_root: String,
pub session_count: usize,
pub file_count: usize,
pub symbol_count: usize,
pub index_state: String,
#[serde(default = "default_project_freshness")]
pub freshness: FreshnessStatus,
pub durability: CapabilityStatus,
pub capabilities: ProjectCapabilities,
pub opened_at_unix_secs: u64,
}
fn default_project_freshness() -> FreshnessStatus {
FreshnessStatus::Current
}
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
pub struct DaemonHealth {
pub project_count: usize,
pub session_count: usize,
pub daemon_version: String,
pub executable_path: String,
#[serde(default)]
pub auth_required: bool,
#[serde(default)]
pub pid: Option<u32>,
}
#[derive(Clone)]
struct SessionRuntime {
canonical_root: PathBuf,
project_id: String,
session_id: String,
index: SharedIndex,
token_stats: Arc<TokenStats>,
symbol_cache: Arc<RwLock<HashMap<String, Vec<SymbolSnapshot>>>>,
server: SymForgeServer,
working_set: Arc<RwLock<WorkingSet>>,
project_indexes: HashMap<String, SharedIndex>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct DaemonIdentity {
version: String,
executable_path: String,
}
impl DaemonState {
pub fn new() -> Self {
Self::with_token(establish_daemon_auth_token())
}
fn auth_token_for_cleanup(&self) -> String {
self.auth_token.clone()
}
fn with_token(auth_token: String) -> Self {
let control_state_dir = paths::process_control_state_placement()
.directory()
.cloned();
Self::with_token_and_control_state(auth_token, control_state_dir)
}
fn with_token_at(auth_token: String, control_state_dir: ControlStateDir) -> Self {
Self::with_token_and_control_state(auth_token, Some(control_state_dir))
}
fn with_token_and_control_state(
auth_token: String,
control_state_dir: Option<ControlStateDir>,
) -> Self {
Self {
next_session_id: AtomicU64::new(1),
bases: RwLock::new(HashMap::new()),
base_generation_seq: AtomicU64::new(1),
projects: RwLock::new(HashMap::new()),
sessions: RwLock::new(HashMap::new()),
identity: current_daemon_identity(),
auth_token,
control_state_dir,
governor: crate::sidecar::governor::RequestGovernor::new(),
last_activity_at: AtomicU64::new(now_epoch_millis()),
active_authenticated_requests: AtomicU64::new(0),
idle_shutdown: tokio::sync::Notify::new(),
}
}
fn intern_base(&self, candidate: Arc<IndexBase>) -> Arc<IndexBase> {
let mut bases = self.bases.write();
if let Some(existing) = bases.get(&candidate.key) {
return Arc::clone(existing);
}
let generation = self.base_generation_seq.fetch_add(1, Ordering::Relaxed);
let mut published = (*candidate).clone();
published.base_generation = generation;
let published = Arc::new(published);
bases.insert(published.key.clone(), Arc::clone(&published));
published
}
fn intern_base_refresh(&self, candidate: Arc<IndexBase>) -> Arc<IndexBase> {
let mut bases = self.bases.write();
let generation = self.base_generation_seq.fetch_add(1, Ordering::Relaxed);
let mut published = (*candidate).clone();
published.base_generation = generation;
let published = Arc::new(published);
bases.insert(published.key.clone(), Arc::clone(&published));
published
}
fn intern_base_for_project(&self, project_id: &str) -> Option<Arc<IndexBase>> {
let slot = self.projects.read().get(project_id).cloned()?;
Some(self.intern_base(slot.base()))
}
fn refresh_working_set_bases(&self, working_set: &Arc<RwLock<WorkingSet>>, targets: &Targets) {
let targeted: Vec<(String, Arc<LiveIndex>)> = {
let ws = working_set.read();
ws.iter()
.filter(|entry| targets_selects(targets, &entry.project_id))
.map(|entry| (entry.project_id.clone(), Arc::clone(&entry.base.index)))
.collect()
};
if targeted.is_empty() {
return;
}
let slots: HashMap<String, Arc<ProjectSlot>> = {
let projects = self.projects.read();
targeted
.iter()
.filter_map(|(project_id, _)| {
projects
.get(project_id)
.cloned()
.map(|slot| (project_id.clone(), slot))
})
.collect()
};
let stale: Vec<(String, Arc<IndexBase>)> = targeted
.iter()
.filter_map(|(project_id, entry_index)| {
let slot = slots.get(project_id)?;
let index = Arc::clone(&slot.metadata.read().index);
let current = index.read();
if Arc::ptr_eq(¤t, entry_index) {
None } else {
Some((project_id.clone(), slot.base()))
}
})
.collect();
if stale.is_empty() {
return; }
let fresh: Vec<(String, Arc<IndexBase>)> = stale
.into_iter()
.map(|(project_id, candidate)| (project_id, self.intern_base_refresh(candidate)))
.collect();
let mut ws = working_set.write();
for (project_id, base) in fresh {
ws.add(project_id, base);
}
drop(ws);
self.gc_orphaned_bases();
}
fn gc_orphaned_bases(&self) {
self.bases
.write()
.retain(|_key, base| Arc::strong_count(base) > 1);
}
fn ensure_project_slot_for_session(
&self,
session_id: &str,
project_id: &str,
canonical_root: &Path,
) -> anyhow::Result<Arc<ProjectSlot>> {
self.ensure_project_slot_for_session_with(session_id, project_id, || {
ProjectInstance::load(canonical_root)
})
}
fn ensure_project_slot_for_binding(
&self,
session_id: &str,
binding: &RootBinding,
) -> anyhow::Result<Arc<ProjectSlot>> {
self.ensure_project_slot_for_session_with(session_id, &binding.root_id.0, || {
let state_placement = crate::discovery::resolve_state_placement(binding);
ProjectInstance::load_bound(binding, state_placement)
})
}
fn ensure_project_slot_for_session_with<F>(
&self,
session_id: &str,
project_id: &str,
load_project: F,
) -> anyhow::Result<Arc<ProjectSlot>>
where
F: FnOnce() -> anyhow::Result<ProjectInstance>,
{
let mut load_project = Some(load_project);
loop {
let existing = self.projects.read().get(project_id).cloned();
if let Some(slot) = existing {
let projects = self.projects.write();
if projects
.get(project_id)
.is_some_and(|current| Arc::ptr_eq(current, &slot))
{
slot.metadata
.write()
.session_ids
.insert(session_id.to_string());
return Ok(slot);
}
continue;
}
let candidate = Arc::new(ProjectSlot::new(load_project
.take()
.expect("cold project loader is consumed only on the returning branch")(
)?));
let mut projects = self.projects.write();
let slot = Arc::clone(projects.entry(project_id.to_string()).or_insert(candidate));
slot.metadata
.write()
.session_ids
.insert(session_id.to_string());
return Ok(slot);
}
}
fn register_session_for_existing_project(
&self,
project_id: &str,
request: &OpenProjectRequest,
canonical_root: &Path,
) -> anyhow::Result<OpenProjectResponse> {
let session_id = format!(
"session-{}",
self.next_session_id.fetch_add(1, Ordering::Relaxed)
);
let now = SystemTime::now();
let slot = self.ensure_project_slot_for_session(&session_id, project_id, canonical_root)?;
slot.activate();
let (project_name, canonical_root_text, session_count) = {
let project = slot.metadata.read();
(
project.project_name.clone(),
normalized_path_string(&project.canonical_root),
project.session_ids.len(),
)
};
let server = slot.server_for_session();
let base = self.intern_base(slot.base());
let mut working_set = WorkingSet::new();
working_set.add(project_id.to_string(), base);
let session = SessionRecord {
session_id: session_id.clone(),
active_project_id: project_id.to_string(),
working_set: Arc::new(RwLock::new(working_set)),
servers: HashMap::from([(project_id.to_string(), server)]),
client_name: request.client_name.clone(),
pid: request.pid,
opened_at: now,
last_seen_at: AtomicU64::new(now_epoch_millis()),
};
self.sessions.write().insert(session_id.clone(), session);
Ok(OpenProjectResponse {
project_id: project_id.to_string(),
session_id,
project_name,
canonical_root: canonical_root_text,
session_count,
})
}
pub fn open_project_session(
&self,
request: OpenProjectRequest,
) -> anyhow::Result<OpenProjectResponse> {
let binding = match crate::discovery::resolve_root_candidate(
Path::new(&request.project_root),
RootCandidateSource::McpClientRoot,
RootRequestMode::Automatic,
) {
RootResolution::Bound(binding) => binding,
RootResolution::Unbound {
reason: UnboundReason::Refused(reason),
..
} => {
anyhow::bail!(
"Refused to open session for sensitive system path: {}. Use a project directory instead. ({})",
request.project_root,
reason.code()
);
}
RootResolution::Unbound { .. } => {
anyhow::bail!(
"Refused to open session for project root: {}. Use a project directory instead.",
request.project_root
);
}
};
self.register_session_for_existing_project(
&binding.root_id.0,
&request,
&binding.canonical_root,
)
}
pub fn heartbeat(&self, session_id: &str) -> HeartbeatResponse {
let known_session = self
.sessions
.read()
.get(session_id)
.map(|session| {
session
.last_seen_at
.store(now_epoch_millis(), Ordering::Relaxed);
true
})
.unwrap_or(false);
HeartbeatResponse {
session_id: session_id.to_string(),
known_session,
}
}
pub fn close_session(&self, session_id: &str) -> Option<CloseSessionResponse> {
let session = self.sessions.write().remove(session_id)?;
Some(self.finish_removed_session(session))
}
fn finish_removed_session(&self, session: SessionRecord) -> CloseSessionResponse {
let session_id = session.session_id.clone();
let active_project_id = Some(session.active_project_id.clone());
let closed_session_id = session.session_id.clone();
drop(session);
let mut active_remaining = 0usize;
let mut active_removed = false;
let mut active_pid_seen = false;
let mut removed_slots = Vec::new();
{
let mut projects = self.projects.write();
let owning: Vec<String> = projects
.iter()
.filter(|(_, slot)| slot.metadata.read().session_ids.contains(&session_id))
.map(|(id, _)| id.clone())
.collect();
for pid in owning {
let is_active = active_project_id.as_deref() == Some(pid.as_str());
let remaining = {
let Some(slot) = projects.get(&pid) else {
continue;
};
let mut project = slot.metadata.write();
project.session_ids.remove(&session_id);
project.session_ids.len()
};
let removed = if remaining == 0 {
if let Some(removed) = projects.remove(&pid) {
removed_slots.push(removed);
}
true
} else {
false
};
if is_active {
active_pid_seen = true;
active_remaining = remaining;
active_removed = removed;
}
}
}
for slot in removed_slots {
slot.stop();
}
self.gc_orphaned_bases();
let project_id = match (active_project_id, active_pid_seen) {
(Some(pid), true) => pid,
_ => "orphan".to_string(),
};
CloseSessionResponse {
session_id: closed_session_id,
project_id,
remaining_sessions: active_remaining,
project_removed: active_removed,
}
}
fn close_session_if_expired(
&self,
session_id: &str,
observed_last_seen: u64,
cutoff: u64,
) -> bool {
let session = {
let mut sessions = self.sessions.write();
let Some(record) = sessions.get(session_id) else {
return false;
};
let current = record.last_seen_at.load(Ordering::Relaxed);
if current != observed_last_seen || current >= cutoff {
return false;
}
sessions.remove(session_id)
};
let Some(session) = session else {
return false;
};
let response = self.finish_removed_session(session);
tracing::info!(
session_id = %response.session_id,
project_id = %response.project_id,
"reaper closed expired session"
);
true
}
pub fn reap_expired_sessions(&self, ttl: std::time::Duration) -> usize {
let cutoff = now_epoch_millis().saturating_sub(ttl.as_millis() as u64);
let candidates: Vec<(String, u64)> = self
.sessions
.read()
.iter()
.filter_map(|(id, session)| {
let seen = session.last_seen_at.load(Ordering::Relaxed);
(seen < cutoff).then(|| (id.clone(), seen))
})
.collect();
let mut reaped = 0usize;
for (session_id, observed) in candidates {
if self.close_session_if_expired(&session_id, observed, cutoff) {
reaped += 1;
}
}
reaped
}
pub fn list_projects(&self) -> Vec<ProjectSummary> {
let slots: Vec<Arc<ProjectSlot>> = self.projects.read().values().cloned().collect();
let mut summaries: Vec<ProjectSummary> = slots
.iter()
.map(|slot| {
let project = slot.metadata.read();
ProjectSummary {
project_id: project.project_id.clone(),
project_name: project.project_name.clone(),
canonical_root: normalized_path_string(&project.canonical_root),
session_count: project.session_ids.len(),
opened_at_unix_secs: unix_seconds(project.opened_at),
}
})
.collect();
summaries.sort_by(|a, b| a.canonical_root.cmp(&b.canonical_root));
summaries
}
pub fn project_health(&self, project_id: &str) -> Option<ProjectHealth> {
let slot = self.projects.read().get(project_id).cloned()?;
let project = slot.metadata.read();
let published = project.index.published_state();
let durability = *project.persistence_health.read();
let durable_mutation = match durability {
CapabilityStatus::Available => CapabilityStatus::Available,
CapabilityStatus::Unavailable { .. } => CapabilityStatus::Unavailable {
reason:
crate::domain::CapabilityUnavailableReason::DurableMutationReplayUnavailable,
},
};
let protected = project.source_access_mode == SourceAccessMode::ExplicitProtected;
let source_mutation = if protected {
CapabilityStatus::Unavailable {
reason: crate::domain::CapabilityUnavailableReason::ExplicitProtectedSource,
}
} else {
durable_mutation
};
let repository_init = if protected {
CapabilityStatus::Unavailable {
reason: crate::domain::CapabilityUnavailableReason::ExplicitProtectedSource,
}
} else {
CapabilityStatus::Available
};
let team_artifact_export = if protected {
CapabilityStatus::Unavailable {
reason: crate::domain::CapabilityUnavailableReason::ExplicitProtectedSource,
}
} else if matches!(
&project.state_placement,
StatePlacement::ProjectLocal { .. }
) {
CapabilityStatus::Available
} else {
CapabilityStatus::Unavailable {
reason: crate::domain::CapabilityUnavailableReason::NonProjectLocalPlacement,
}
};
let repository_curation = project.curation_coordinator.capability_status(
&project.index,
Some(&project.canonical_root),
Some(&project.state_placement),
durability,
);
Some(ProjectHealth {
project_id: project.project_id.clone(),
project_name: project.project_name.clone(),
canonical_root: normalized_path_string(&project.canonical_root),
session_count: project.session_ids.len(),
file_count: published.file_count,
symbol_count: published.symbol_count,
index_state: published.status_label().to_string(),
freshness: project.index.freshness_status().as_ref().clone(),
durability,
capabilities: ProjectCapabilities {
persistent_snapshots: durability,
checkpoint: durability,
structural_edits: source_mutation,
repository_init,
repository_curation,
team_artifact_export,
},
opened_at_unix_secs: unix_seconds(project.opened_at),
})
}
pub fn list_sessions(&self, project_id: &str) -> Option<Vec<SessionSummary>> {
let session_ids: Vec<String> = {
let slot = self.projects.read().get(project_id).cloned()?;
let project = slot.metadata.read();
project.session_ids.iter().cloned().collect()
};
let sessions = self.sessions.read();
let mut summaries: Vec<SessionSummary> = session_ids
.iter()
.filter_map(|session_id| sessions.get(session_id))
.map(|session| SessionSummary {
session_id: session.session_id.clone(),
project_id: session.active_project_id.clone(),
client_name: session.client_name.clone(),
pid: session.pid,
opened_at_unix_secs: unix_seconds(session.opened_at),
last_seen_at_unix_secs: unix_seconds(session.last_seen_at_time()),
})
.collect();
summaries.sort_by(|a, b| a.session_id.cmp(&b.session_id));
Some(summaries)
}
fn index_folder_for_session(
&self,
session_id: &str,
input: IndexFolderInput,
) -> anyhow::Result<String> {
let allow_protected_root = input.allow_protected_root == Some(true);
let binding = match crate::discovery::resolve_root_candidate(
Path::new(&input.path),
RootCandidateSource::ExplicitIndexFolder,
RootRequestMode::ExplicitIndexFolder {
allow_protected_root,
},
) {
RootResolution::Bound(binding) => binding,
RootResolution::Unbound {
reason: UnboundReason::Refused(reason),
..
} => {
return Ok(format!(
"{}: Refused to index sensitive system path: {}. Use a project directory instead.",
reason.code(),
input.path
));
}
RootResolution::Unbound { .. } => {
return Ok(format!(
"root_unbound: Refused to index project root: {}.",
input.path
));
}
};
let target_root = &binding.canonical_root;
let reset_requested = crate::protocol::tools::index_folder_reset_requested();
let (idempotency, replay_response) = match input.idempotency_key.as_deref() {
Some(raw_key) => {
let Some(control_state) = self.control_state_dir.as_ref() else {
return Ok(
"Idempotency unavailable: durable process control state is unavailable."
.to_string(),
);
};
match crate::idempotency::begin_index_folder_replay(
control_state,
target_root,
raw_key,
reset_requested,
allow_protected_root,
) {
Ok(crate::idempotency::ReplayStart::FirstExecution(active)) => {
(Some(active), None)
}
Ok(crate::idempotency::ReplayStart::Replay(response)) => (None, Some(response)),
Err(error) => return Ok(crate::idempotency::format_tool_error(&error)),
}
}
None => (None, None),
};
match self.open_project_for_session(session_id, &binding) {
Ok(mut output) => {
if let Some(response) = replay_response {
return Ok(response);
}
if let Some(idempotency) = &idempotency
&& let Err(error) = idempotency.complete(output.clone())
{
output.push_str(&format!(
"\nIdempotency warning: failed to store replay result: {error}"
));
}
Ok(output)
}
Err(error) => {
if let Some(response) = replay_response {
return Ok(crate::idempotency::format_live_postcondition_unavailable(
&response, &error,
));
}
if let Some(idempotency) = &idempotency {
let _ = idempotency.fail(format!("Index failed: {error}"));
}
Err(error)
}
}
}
fn open_project_for_session(
&self,
session_id: &str,
binding: &RootBinding,
) -> anyhow::Result<String> {
let target_project_id = &binding.root_id.0;
let target_root = &binding.canonical_root;
let target_slot = self.ensure_project_slot_for_binding(session_id, binding)?;
target_slot.activate();
let (file_count, symbol_count) = target_slot.reload_for_binding(binding)?;
let (index, source_access_mode, state_placement, persistence_health) = {
let project = target_slot.metadata.read();
(
Arc::clone(&project.index),
project.source_access_mode,
project.state_placement.clone(),
Arc::clone(&project.persistence_health),
)
};
let gitignore_hygiene = crate::gitignore_hygiene::reconcile_project_gitignore(
target_root,
if source_access_mode == SourceAccessMode::ExplicitProtected {
crate::gitignore_hygiene::GitignoreHygieneAuthority::ExplicitProtected
} else {
crate::gitignore_hygiene::GitignoreHygieneAuthority::ExplicitNormalBinding
},
);
let (checkpoint, state_location) = match &state_placement {
StatePlacement::ProjectLocal { .. } | StatePlacement::UserLocal { .. } => (
match crate::live_index::persist::checkpoint_shared_index(
&index,
target_root,
&state_placement,
) {
Ok(_) => {
*persistence_health.write() = CapabilityStatus::Available;
"checkpoint=written".to_string()
}
Err(error) => {
*persistence_health.write() = CapabilityStatus::Unavailable {
reason: crate::domain::CapabilityUnavailableReason::PersistentStateUnavailable,
};
format!("checkpoint=degraded: {error}")
}
},
if matches!(&state_placement, StatePlacement::ProjectLocal { .. }) {
"project-local"
} else {
"user-local"
},
),
StatePlacement::MemoryOnly { .. } => {
("checkpoint=skipped(memory-only)".to_string(), "memory-only")
}
};
if !self.add_project_to_session(session_id, target_project_id) {
return Err(anyhow::anyhow!(
"session '{session_id}' closed before the opened project could be attached"
));
}
let (project_name, root_text) = {
let project = target_slot.metadata.read();
(
project.project_name.clone(),
normalized_path_string(&project.canonical_root),
)
};
Ok(format!(
"Indexed {file_count} files, {symbol_count} symbols (added to working set).\nproject_id={target_project_id} project_name={project_name} root={root_text} source_access={source_access_mode:?} state={state_location} {checkpoint}\n{}",
gitignore_hygiene.receipt()
))
}
fn add_project_to_session(&self, session_id: &str, project_id: &str) -> bool {
let Some(base) = self.intern_base_for_project(project_id) else {
return false;
};
let slot = {
let projects = self.projects.read();
let Some(slot) = projects.get(project_id) else {
return false;
};
Arc::clone(slot)
};
let server = slot.server_for_session();
let slot_index = Arc::clone(&slot.metadata.read().index);
slot.metadata
.write()
.session_ids
.insert(session_id.to_string());
let attached = match self.sessions.write().get_mut(session_id) {
Some(session) => {
let replace_server = session
.servers
.get(project_id)
.map(|existing| !Arc::ptr_eq(&existing.index, &slot_index))
.unwrap_or(true);
if replace_server {
session.servers.insert(project_id.to_string(), server);
}
session
.working_set
.write()
.add(project_id.to_string(), base);
true
}
None => false,
};
if !attached {
self.detach_project_membership(session_id, project_id);
}
attached
}
fn detach_project_membership(&self, session_id: &str, project_id: &str) {
let removed = {
let mut projects = self.projects.write();
let Some(slot) = projects.get(project_id).cloned() else {
return;
};
let mut project = slot.metadata.write();
project.session_ids.remove(session_id);
let empty = project.session_ids.is_empty();
drop(project);
if empty {
projects.remove(project_id)
} else {
None
}
};
if let Some(slot) = removed {
slot.stop();
}
}
#[allow(dead_code)]
fn set_active_project(&self, session_id: &str, project_id: &str) -> bool {
match self.sessions.write().get_mut(session_id) {
Some(session) => {
let is_open = session.working_set.read().get(project_id).is_some();
if !is_open {
return false;
}
session.active_project_id = project_id.to_string();
session
.last_seen_at
.store(now_epoch_millis(), Ordering::Relaxed);
true
}
None => false,
}
}
#[allow(dead_code)]
fn remove_project_from_session(&self, session_id: &str, project_id: &str) -> bool {
let removed = match self.sessions.write().get_mut(session_id) {
Some(session) => {
if session.active_project_id == project_id {
return false;
}
let mut working_set = session.working_set.write();
let removed = working_set.remove(project_id).is_some();
drop(working_set);
if removed {
session.servers.remove(project_id);
}
removed
}
None => false,
};
if !removed {
return false;
}
let evicted = {
let mut projects = self.projects.write();
let Some(slot) = projects.get(project_id).cloned() else {
return true;
};
let mut project = slot.metadata.write();
project.session_ids.remove(session_id);
let empty = project.session_ids.is_empty();
drop(project);
if empty {
projects.remove(project_id)
} else {
None
}
};
if let Some(slot) = evicted {
slot.stop();
}
true
}
fn session_runtime(&self, session_id: &str) -> Option<SessionRuntime> {
self.runtime_for_target(session_id, None).ok()
}
fn runtime_for_target(
&self,
session_id: &str,
project: Option<&str>,
) -> Result<SessionRuntime, String> {
let session = self
.sessions
.read()
.get(session_id)
.cloned()
.ok_or_else(|| format!("unknown session '{session_id}'"))?;
let target_id = match project.map(str::trim).filter(|p| !p.is_empty()) {
None => session.active_project_id.clone(),
Some(selector) => {
let open_ids: Vec<String> = session
.working_set
.read()
.iter()
.map(|entry| entry.project_id.clone())
.collect();
if open_ids.iter().any(|id| id == selector) {
selector.to_string()
} else {
let mut matches: Vec<String> = Vec::new();
let mut candidates: Vec<String> = Vec::new();
{
let projects = self.projects.read();
for id in &open_ids {
if let Some(slot) = projects.get(id) {
let meta = slot.metadata.read();
candidates.push(format!("{} ({id})", meta.project_name));
if meta.project_name == selector {
matches.push(id.clone());
}
}
}
}
candidates.sort();
match matches.len() {
1 => matches.remove(0),
0 => {
return Err(format!(
"project '{selector}' is not open in this session. Open \
projects: [{}]. Open it first with index_folder(path=...).",
candidates.join(", ")
));
}
_ => {
return Err(format!(
"project selector '{selector}' is ambiguous among open \
projects: [{}]. Use the project id.",
candidates.join(", ")
));
}
}
}
}
};
let slot = self
.projects
.read()
.get(&target_id)
.cloned()
.ok_or_else(|| format!("project '{target_id}' is not loaded in the daemon"))?;
let server = session.servers.get(&target_id).cloned().ok_or_else(|| {
format!(
"project '{target_id}' has no session server; reopen it with \
index_folder(path=...)"
)
})?;
let project_meta = slot.metadata.read();
let project_indexes = session
.servers
.iter()
.map(|(id, server)| (id.clone(), Arc::clone(&server.index)))
.collect();
Ok(SessionRuntime {
canonical_root: project_meta.canonical_root.clone(),
project_id: target_id.clone(),
session_id: session.session_id.clone(),
index: Arc::clone(&project_meta.index),
token_stats: Arc::clone(&project_meta.token_stats),
symbol_cache: Arc::clone(&project_meta.symbol_cache),
server,
working_set: Arc::clone(&session.working_set),
project_indexes,
})
}
fn render_session_project_inventory(&self, session_id: &str) -> Option<String> {
let session = self.sessions.read().get(session_id).cloned()?;
let open_ids: Vec<String> = session
.working_set
.read()
.iter()
.map(|entry| entry.project_id.clone())
.collect();
let mut lines = vec!["── projects ──".to_string()];
{
let projects = self.projects.read();
for id in &open_ids {
let Some(slot) = projects.get(id) else {
lines.push(format!(
"{id} state=missing (open in working set but not loaded)"
));
continue;
};
let meta = slot.metadata.read();
let published = meta.index.published_state();
let home = if *id == session.active_project_id {
" home=yes"
} else {
""
};
let snapshot = if meta
.canonical_root
.join(".symforge")
.join("index.bin")
.is_file()
{
"present"
} else {
"absent"
};
lines.push(format!(
"{id}{home} name={} root={} files={} symbols={} index={} generation={} opened={} snapshot={}",
meta.project_name,
normalized_path_string(&meta.canonical_root),
published.file_count,
published.symbol_count,
published.status_label(),
meta.index.current_project_generation(),
unix_seconds(meta.opened_at),
snapshot,
));
}
}
lines.push(format!(
"session={} last_seen={} ttl_secs={}",
session.session_id,
unix_seconds(session.last_seen_at_time()),
session_ttl_from_env().as_secs()
));
Some(lines.join("\n"))
}
fn render_session_project_inventory_if_multi(&self, session_id: &str) -> Option<String> {
let multi = {
let sessions = self.sessions.read();
let session = sessions.get(session_id)?;
session.working_set.read().len() > 1
};
if multi {
self.render_session_project_inventory(session_id)
} else {
None
}
}
pub fn health(&self) -> DaemonHealth {
DaemonHealth {
project_count: self.projects.read().len(),
session_count: self.sessions.read().len(),
daemon_version: self.identity.version.clone(),
executable_path: self.identity.executable_path.clone(),
auth_required: true,
pid: Some(std::process::id()),
}
}
}
impl Default for DaemonState {
fn default() -> Self {
Self::new()
}
}
impl DaemonSessionClient {
fn new_with_auth_token(
base_url: String,
project_id: String,
session_id: String,
project_name: String,
auth_token: Option<String>,
control_state_dir: ControlStateDir,
) -> Self {
let http_client = reqwest::Client::builder()
.connect_timeout(std::time::Duration::from_secs(5))
.timeout(std::time::Duration::from_secs(60))
.build()
.expect("failed to build reqwest client with timeout — this is a critical invariant");
Self {
http_client,
base_url,
project_id,
session_id,
project_name,
auth_token,
control_state_dir,
project_root: None,
opened_roots: std::sync::Arc::new(parking_lot::Mutex::new(Vec::new())),
}
}
fn with_project_root(mut self, root: PathBuf) -> Self {
self.project_root = Some(root);
self
}
pub(crate) fn record_opened_root(&self, root: PathBuf) {
if self.project_root.as_deref() == Some(root.as_path()) {
return;
}
let mut roots = self.opened_roots.lock();
if !roots.iter().any(|existing| existing == &root) {
roots.push(root);
}
}
#[cfg(test)]
pub(crate) fn new_for_test(
base_url: String,
project_id: String,
session_id: String,
project_name: String,
) -> Self {
let control_state_dir = process_control_state_dir()
.expect("test daemon control state must be resolvable")
.clone();
Self::new_for_test_at(
base_url,
project_id,
session_id,
project_name,
control_state_dir,
)
}
#[cfg(test)]
pub(crate) fn new_for_test_at(
base_url: String,
project_id: String,
session_id: String,
project_name: String,
control_state_dir: ControlStateDir,
) -> Self {
let auth_token = resolve_daemon_auth_token_at(&control_state_dir);
Self::new_with_auth_token(
base_url,
project_id,
session_id,
project_name,
auth_token,
control_state_dir,
)
}
pub fn project_name(&self) -> &str {
&self.project_name
}
pub fn project_id(&self) -> &str {
&self.project_id
}
pub fn session_id(&self) -> &str {
&self.session_id
}
pub fn base_url(&self) -> &str {
&self.base_url
}
pub fn project_root(&self) -> Option<&Path> {
self.project_root.as_deref()
}
pub(crate) fn control_state_dir(&self) -> &ControlStateDir {
&self.control_state_dir
}
pub fn port(&self) -> Option<u16> {
self.base_url
.rsplit(':')
.next()
.and_then(|value| value.parse::<u16>().ok())
}
pub async fn reconnect(&self) -> anyhow::Result<DaemonSessionClient> {
let project_root = self
.project_root
.as_deref()
.context("cannot reconnect: no project root stored")?;
tracing::info!(
"attempting daemon reconnection for project {}",
self.project_name
);
let new_client = connect_or_spawn_session_at(
project_root,
"mcp-stdio",
Some(std::process::id()),
&self.control_state_dir,
)
.await?;
let new_client = new_client.with_project_root(project_root.to_path_buf());
if let Ok(canonical_home) = canonical_project_root(project_root) {
let expected_home = project_key(&canonical_home);
anyhow::ensure!(
new_client.project_id == expected_home,
"reconnect produced a different home project id (expected {expected_home}, got {}); refusing to serve",
new_client.project_id
);
}
let siblings: Vec<PathBuf> = self.opened_roots.lock().clone();
for root in &siblings {
let response = new_client
.call_tool_value(
"index_folder",
serde_json::json!({ "path": root.display().to_string() }),
)
.await
.with_context(|| {
format!("reconnect failed to reopen sibling {}", root.display())
})?;
let expected = canonical_project_root(root).map(|c| project_key(&c));
if let Ok(expected) = expected {
anyhow::ensure!(
response.contains(&format!("project_id={expected}")),
"reconnect reopened sibling {} with an unexpected identity; refusing to serve (receipt: {response})",
root.display()
);
}
new_client.record_opened_root(root.clone());
}
Ok(new_client)
}
pub async fn call_tool_value(
&self,
tool_name: &str,
params: serde_json::Value,
) -> anyhow::Result<String> {
let request = self
.http_client
.post(format!(
"{}/v1/sessions/{}/tools/{}",
self.base_url, self.session_id, tool_name
))
.json(¶ms);
let request = apply_daemon_auth_header(request, self.auth_token.as_deref()).header(
crate::protocol::surface_probe::CONNECTION_SURFACE_HEADER,
crate::protocol::surface_probe::surface_profile_label(
crate::protocol::surface_probe::surface_profile_from_env(),
),
);
let response = request
.send()
.await
.with_context(|| format!("calling daemon tool '{tool_name}'"))?
.error_for_status()
.with_context(|| format!("daemon rejected tool '{tool_name}'"))?;
if let Some(header) = response
.headers()
.get(crate::protocol::result_status::PROJECT_EVIDENCE_HEADER)
&& let Ok(text) = header.to_str()
&& let Ok(evidence) =
serde_json::from_str::<crate::protocol::result_status::ProjectEvidence>(text)
{
crate::protocol::result_status::record_project_evidence(evidence);
}
response
.text()
.await
.with_context(|| format!("reading daemon tool response for '{tool_name}'"))
}
pub async fn heartbeat(&self) -> anyhow::Result<HeartbeatResponse> {
let request = self.http_client.post(format!(
"{}/v1/sessions/{}/heartbeat",
self.base_url, self.session_id
));
apply_daemon_auth_header(request, self.auth_token.as_deref())
.send()
.await
.context("sending daemon heartbeat")?
.error_for_status()
.context("daemon heartbeat status")?
.json::<HeartbeatResponse>()
.await
.context("daemon heartbeat body")
}
pub async fn close(&self) -> anyhow::Result<CloseSessionResponse> {
let request = self
.http_client
.delete(format!("{}/v1/sessions/{}", self.base_url, self.session_id));
apply_daemon_auth_header(request, self.auth_token.as_deref())
.send()
.await
.context("closing daemon session")?
.error_for_status()
.context("daemon close status")?
.json::<CloseSessionResponse>()
.await
.context("daemon close body")
}
}
struct DaemonStartLock {
path: PathBuf,
}
impl Drop for DaemonStartLock {
fn drop(&mut self) {
let _ = std::fs::remove_file(&self.path);
}
}
pub async fn connect_or_spawn_session(
project_root: &Path,
client_name: &str,
pid: Option<u32>,
) -> anyhow::Result<DaemonSessionClient> {
let control_state_dir = process_control_state_dir()?;
connect_or_spawn_session_at(project_root, client_name, pid, control_state_dir).await
}
async fn connect_or_spawn_session_at(
project_root: &Path,
client_name: &str,
pid: Option<u32>,
control_state_dir: &ControlStateDir,
) -> anyhow::Result<DaemonSessionClient> {
let port = ensure_daemon_running_at(control_state_dir).await?;
let base_url = format!("http://127.0.0.1:{port}");
let http_client = reqwest::Client::builder()
.connect_timeout(Duration::from_secs(5))
.timeout(Duration::from_secs(60))
.build()
.context("building reqwest client for connect_or_spawn_session")?;
let auth_token = resolve_daemon_auth_token_at(control_state_dir);
let open_request = http_client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project_root.display().to_string(),
client_name: client_name.to_string(),
pid,
});
let opened = apply_daemon_auth_header(open_request, auth_token.as_deref())
.send()
.await
.context("opening daemon session")?
.error_for_status()
.context("daemon session open status")?
.json::<OpenProjectResponse>()
.await
.context("daemon session open body")?;
Ok(DaemonSessionClient::new_with_auth_token(
base_url,
opened.project_id,
opened.session_id,
opened.project_name,
auth_token,
control_state_dir.clone(),
)
.with_project_root(project_root.to_path_buf()))
}
async fn ensure_daemon_running_at(control_state_dir: &ControlStateDir) -> anyhow::Result<u16> {
let identity = current_daemon_identity();
if let Some(port) = daemon_port_if_compatible_at(control_state_dir, &identity).await? {
tracing::debug!("daemon already running on port {port}");
return Ok(port);
}
if cfg!(test) || daemon_autospawn_disabled() {
anyhow::bail!(
"no running compatible daemon found and auto-spawn is disabled (test build or {DAEMON_AUTOSPAWN_ENV}); start `symforge daemon` explicitly"
);
}
if let Some(lock) = try_acquire_start_lock_at(control_state_dir)? {
if let Some(port) = daemon_port_if_compatible_at(control_state_dir, &identity).await? {
tracing::debug!("daemon became ready while acquiring lock, port {port}");
return Ok(port);
}
tracing::info!("acquired start lock, spawning new daemon");
stop_incompatible_recorded_daemon_at(control_state_dir, &identity).await?;
spawn_daemon_process()?;
drop(lock);
wait_for_daemon_ready_at(control_state_dir, &identity).await
} else {
tracing::info!("start lock held by another process, waiting for daemon");
wait_for_daemon_ready_at(control_state_dir, &identity).await
}
}
pub enum GuardedStart {
Started(DaemonHandle),
AlreadyRunning { port: u16 },
}
pub async fn guarded_daemon_start(bind_host: &str) -> anyhow::Result<GuardedStart> {
let control_state_dir = process_control_state_dir()?;
guarded_daemon_start_at(bind_host, control_state_dir).await
}
#[doc(hidden)]
pub async fn guarded_daemon_start_at(
bind_host: &str,
control_state_dir: &ControlStateDir,
) -> anyhow::Result<GuardedStart> {
let identity = current_daemon_identity();
let deadline = tokio::time::Instant::now() + tokio::time::Duration::from_secs(10);
let _lock = loop {
if let Some(port) = daemon_port_if_compatible_at(control_state_dir, &identity).await? {
return Ok(GuardedStart::AlreadyRunning { port });
}
if let Some(lock) = try_acquire_start_lock_at(control_state_dir)? {
break lock;
}
if tokio::time::Instant::now() >= deadline {
anyhow::bail!(
"timed out waiting for the symforge daemon start lock; another start is in progress"
);
}
tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
};
if let Some(port) = daemon_port_if_compatible_at(control_state_dir, &identity).await? {
return Ok(GuardedStart::AlreadyRunning { port });
}
stop_incompatible_recorded_daemon_at(control_state_dir, &identity).await?;
let handle = spawn_daemon_at(bind_host, control_state_dir).await?;
Ok(GuardedStart::Started(handle))
}
async fn daemon_port_if_compatible_at(
control_state_dir: &ControlStateDir,
identity: &DaemonIdentity,
) -> anyhow::Result<Option<u16>> {
let port = match read_daemon_port_file_at(control_state_dir) {
Ok(port) => port,
Err(error) if error.kind() == io::ErrorKind::NotFound => return Ok(None),
Err(error) if error.kind() == io::ErrorKind::InvalidData => {
tracing::warn!("ignoring corrupt symforge daemon port file: {error}");
return Ok(None);
}
Err(error) => return Err(error).context("reading daemon port file"),
};
match daemon_health(port).await {
Some(health) if daemon_health_matches(&health, identity) => Ok(Some(port)),
Some(health) => {
tracing::warn!(
recorded_port = port,
recorded_version = %health.daemon_version,
expected_version = %identity.version,
recorded_executable = %health.executable_path,
expected_executable = %identity.executable_path,
"recorded symforge daemon is incompatible with the current executable"
);
Ok(None)
}
None => Ok(None),
}
}
async fn wait_for_daemon_ready_at(
control_state_dir: &ControlStateDir,
identity: &DaemonIdentity,
) -> anyhow::Result<u16> {
let deadline = tokio::time::Instant::now() + tokio::time::Duration::from_secs(5);
loop {
if let Some(port) = daemon_port_if_compatible_at(control_state_dir, identity).await? {
return Ok(port);
}
if tokio::time::Instant::now() >= deadline {
anyhow::bail!("timed out waiting for symforge daemon to become ready");
}
tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
}
}
async fn daemon_health(port: u16) -> Option<DaemonHealth> {
let client = reqwest::Client::builder()
.connect_timeout(Duration::from_secs(5))
.timeout(Duration::from_secs(10))
.build()
.ok()?;
client
.get(format!("http://127.0.0.1:{port}/health"))
.send()
.await
.ok()?
.error_for_status()
.ok()?
.json::<DaemonHealth>()
.await
.ok()
}
async fn daemon_health_ok(port: u16) -> bool {
daemon_health(port).await.is_some()
}
async fn stop_incompatible_recorded_daemon_at(
control_state_dir: &ControlStateDir,
identity: &DaemonIdentity,
) -> anyhow::Result<()> {
let port = match read_daemon_port_file_at(control_state_dir) {
Ok(port) => port,
Err(error) if error.kind() == io::ErrorKind::NotFound => return Ok(()),
Err(error) if error.kind() == io::ErrorKind::InvalidData => {
tracing::warn!("removing corrupt symforge daemon port file: {error}");
cleanup_daemon_runtime_files_at(control_state_dir);
return Ok(());
}
Err(error) => return Err(error).context("reading daemon port file"),
};
let Some(health) = daemon_health(port).await else {
cleanup_daemon_runtime_files_at(control_state_dir);
return Ok(());
};
if daemon_health_matches(&health, identity) {
return Ok(());
}
if let Ok(pid) = read_daemon_pid_file_at(control_state_dir) {
if should_terminate_recorded_daemon(&health, identity, pid) {
if let Err(error) = terminate_process(pid) {
tracing::warn!(
pid,
"failed to terminate incompatible symforge daemon automatically: {error}"
);
}
wait_for_daemon_unhealthy(port).await;
} else if !daemon_health_matches_recorded_pid(&health, pid) {
match health.pid {
Some(health_pid) => {
tracing::warn!(
recorded_pid = pid,
daemon_pid = health_pid,
"not terminating incompatible symforge daemon because the pid file does not match health"
);
}
None => {
tracing::warn!(
recorded_pid = pid,
"not terminating incompatible symforge daemon because health did not report a pid"
);
}
}
} else {
tracing::warn!(
recorded_pid = pid,
daemon_pid = ?health.pid,
recorded_executable = %health.executable_path,
expected_executable = %identity.executable_path,
"not terminating incompatible symforge daemon because pid ownership/executable safety checks failed"
);
}
}
cleanup_daemon_runtime_files_at(control_state_dir);
Ok(())
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) enum DaemonStopOutcome {
NotRunning,
Stopped { pid: u32 },
StopTimedOut { pid: u32 },
SkippedSafety,
}
#[allow(unsafe_code)] pub(crate) async fn stop_running_daemon_for_update() -> anyhow::Result<DaemonStopOutcome> {
let control_state_dir = process_control_state_dir()?;
stop_running_daemon_for_update_at(control_state_dir).await
}
async fn stop_running_daemon_for_update_at(
control_state_dir: &ControlStateDir,
) -> anyhow::Result<DaemonStopOutcome> {
let port = match read_daemon_port_file_at(control_state_dir) {
Ok(port) => port,
Err(error) if error.kind() == io::ErrorKind::NotFound => {
return Ok(DaemonStopOutcome::NotRunning);
}
Err(error) if error.kind() == io::ErrorKind::InvalidData => {
tracing::warn!("removing corrupt symforge daemon port file during update: {error}");
cleanup_daemon_runtime_files_at(control_state_dir);
return Ok(DaemonStopOutcome::NotRunning);
}
Err(error) => return Err(error).context("reading daemon port file"),
};
let Some(health) = daemon_health(port).await else {
cleanup_daemon_runtime_files_at(control_state_dir);
return Ok(DaemonStopOutcome::NotRunning);
};
let identity = current_daemon_identity();
match read_daemon_pid_file_at(control_state_dir) {
Ok(pid) if should_terminate_recorded_daemon(&health, &identity, pid) => {
if let Err(error) = terminate_process(pid) {
tracing::warn!(
pid,
"failed to terminate symforge daemon during update: {error}"
);
}
wait_for_daemon_unhealthy(port).await;
if process_is_alive(pid) {
#[cfg(unix)]
#[allow(unsafe_code)]
unsafe {
libc::kill(pid as i32, libc::SIGKILL);
}
for _ in 0..20 {
if !process_is_alive(pid) {
break;
}
tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
}
}
if process_is_alive(pid) {
tracing::warn!(
pid,
"symforge daemon still alive after terminate during update"
);
Ok(DaemonStopOutcome::StopTimedOut { pid })
} else {
cleanup_daemon_runtime_files_at(control_state_dir);
Ok(DaemonStopOutcome::Stopped { pid })
}
}
Ok(_) => Ok(DaemonStopOutcome::SkippedSafety),
Err(_) => {
cleanup_daemon_runtime_files_at(control_state_dir);
Ok(DaemonStopOutcome::NotRunning)
}
}
}
#[allow(unsafe_code)] fn process_is_alive(pid: u32) -> bool {
#[cfg(windows)]
{
crate::process_util::hidden_command("tasklist")
.args(["/FI", &format!("PID eq {pid}"), "/NH", "/FO", "CSV"])
.stdin(Stdio::null())
.stderr(Stdio::null())
.output()
.map(|output| String::from_utf8_lossy(&output.stdout).contains(&pid.to_string()))
.unwrap_or(false)
}
#[cfg(not(windows))]
{
unsafe { libc::kill(pid as i32, 0) == 0 }
}
}
async fn wait_for_daemon_unhealthy(port: u16) {
let deadline = tokio::time::Instant::now() + tokio::time::Duration::from_secs(3);
while tokio::time::Instant::now() < deadline {
if !daemon_health_ok(port).await {
break;
}
tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
}
}
fn try_acquire_start_lock_at(
control_state_dir: &ControlStateDir,
) -> anyhow::Result<Option<DaemonStartLock>> {
let path = daemon_dir_for(control_state_dir)?.join(daemon_start_lock_file_name());
match std::fs::OpenOptions::new()
.write(true)
.create_new(true)
.open(&path)
{
Ok(_) => Ok(Some(DaemonStartLock { path })),
Err(error) if error.kind() == io::ErrorKind::AlreadyExists => {
if let Ok(metadata) = std::fs::metadata(&path)
&& let Ok(modified) = metadata.modified()
&& modified.elapsed().unwrap_or_default() > std::time::Duration::from_secs(30)
{
tracing::warn!("removing stale daemon start lock (age > 30s)");
let _ = std::fs::remove_file(&path);
if std::fs::OpenOptions::new()
.write(true)
.create_new(true)
.open(&path)
.is_ok()
{
return Ok(Some(DaemonStartLock { path }));
}
}
Ok(None)
}
Err(error) => Err(error).context("creating daemon start lock"),
}
}
pub const DAEMON_AUTOSPAWN_ENV: &str = "SYMFORGE_DAEMON_AUTOSPAWN";
fn daemon_autospawn_disabled() -> bool {
std::env::var(DAEMON_AUTOSPAWN_ENV)
.map(|value| {
matches!(
value.trim().to_ascii_lowercase().as_str(),
"off" | "0" | "false" | "no"
)
})
.unwrap_or(false)
}
fn spawn_daemon_process() -> anyhow::Result<()> {
let current_exe = std::env::current_exe().context("locating current symforge executable")?;
if cfg!(test) {
anyhow::bail!(
"refusing to auto-spawn a daemon from a test build; start `symforge daemon` explicitly"
);
}
if current_exe
.parent()
.and_then(|dir| dir.file_name())
.is_some_and(|name| name == "deps")
{
anyhow::bail!(
"refusing to auto-spawn a daemon from a Cargo deps/ test artifact: {}",
current_exe.display()
);
}
if daemon_autospawn_disabled() {
anyhow::bail!(
"daemon auto-spawn disabled by {DAEMON_AUTOSPAWN_ENV}; start `symforge daemon` explicitly"
);
}
let mut command = std::process::Command::new(current_exe);
if std::env::var_os(DAEMON_IDLE_SHUTDOWN_ENV).is_none() {
command.env(
DAEMON_IDLE_SHUTDOWN_ENV,
DEFAULT_DAEMON_IDLE_SHUTDOWN_SECS.to_string(),
);
}
command
.arg("daemon")
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null());
#[cfg(windows)]
{
use std::os::windows::process::CommandExt;
const DETACHED_PROCESS: u32 = 0x0000_0008;
const CREATE_NO_WINDOW: u32 = 0x0800_0000;
command.creation_flags(DETACHED_PROCESS | CREATE_NO_WINDOW);
}
command
.spawn()
.context("spawning detached symforge daemon")?;
Ok(())
}
fn current_daemon_identity() -> DaemonIdentity {
let executable_path = std::env::current_exe()
.ok()
.map(|path| normalized_path_string(&path))
.unwrap_or_else(|| "unknown".to_string());
DaemonIdentity {
version: env!("CARGO_PKG_VERSION").to_string(),
executable_path,
}
}
fn daemon_health_matches(health: &DaemonHealth, identity: &DaemonIdentity) -> bool {
if health.daemon_version != identity.version {
return false;
}
if health.executable_path == "unknown" || identity.executable_path == "unknown" {
return true;
}
stable_path_identity(&health.executable_path) == stable_path_identity(&identity.executable_path)
}
fn daemon_health_matches_recorded_pid(health: &DaemonHealth, recorded_pid: u32) -> bool {
health.pid == Some(recorded_pid)
}
fn should_terminate_recorded_daemon(
health: &DaemonHealth,
identity: &DaemonIdentity,
recorded_pid: u32,
) -> bool {
if !daemon_health_matches_recorded_pid(health, recorded_pid) {
return false;
}
if !daemon_executable_name_matches_current(health, identity) {
return false;
}
#[cfg(target_os = "linux")]
{
if !recorded_pid_owner_matches_current_user(recorded_pid).unwrap_or(false) {
return false;
}
if !recorded_pid_executable_matches_health(recorded_pid, health).unwrap_or(false) {
return false;
}
}
true
}
fn daemon_executable_name_matches_current(
health: &DaemonHealth,
identity: &DaemonIdentity,
) -> bool {
let Some(health_name) = daemon_executable_file_name(&health.executable_path) else {
return false;
};
let Some(identity_name) = daemon_executable_file_name(&identity.executable_path) else {
return false;
};
health_name == identity_name
}
fn daemon_executable_file_name(path: &str) -> Option<String> {
if path == "unknown" {
return None;
}
let normalized = path.replace('\\', "/");
let name = normalized.rsplit('/').find(|part| !part.is_empty())?;
if cfg!(windows) {
Some(name.to_lowercase())
} else {
Some(name.to_string())
}
}
#[cfg(target_os = "linux")]
#[allow(unsafe_code)] fn recorded_pid_owner_matches_current_user(pid: u32) -> Option<bool> {
let status = std::fs::read_to_string(format!("/proc/{pid}/status")).ok()?;
let uid_line = status.lines().find(|line| line.starts_with("Uid:"))?;
let effective_uid = uid_line.split_whitespace().nth(2)?.parse::<u32>().ok()?;
let current_uid = unsafe { libc::geteuid() as u32 };
Some(effective_uid == current_uid)
}
#[cfg(target_os = "linux")]
fn recorded_pid_executable_matches_health(pid: u32, health: &DaemonHealth) -> Option<bool> {
if health.executable_path == "unknown" {
return None;
}
let actual = std::fs::read_link(format!("/proc/{pid}/exe")).ok()?;
Some(
stable_path_identity(&normalized_path_string(&actual))
== stable_path_identity(&health.executable_path),
)
}
fn stable_path_identity(path: &str) -> String {
let normalized = path.replace('\\', "/");
if cfg!(windows) {
normalized.to_lowercase()
} else {
normalized
}
}
impl ProjectInstance {
fn load(canonical_root: &Path) -> anyhow::Result<Self> {
let binding = RootBinding {
source: RootCandidateSource::InitCwd,
canonical_root: canonical_root.to_path_buf(),
root_id: crate::discovery::project_id_for_canonical_root(canonical_root),
access_mode: SourceAccessMode::NormalProject,
};
let state_placement = crate::discovery::resolve_state_placement(&binding);
Self::load_bound(&binding, state_placement)
}
fn load_bound(binding: &RootBinding, state_placement: StatePlacement) -> anyhow::Result<Self> {
let canonical_root = &binding.canonical_root;
let project_name = canonical_root
.file_name()
.and_then(|name| name.to_str())
.unwrap_or("project")
.to_string();
let index = bootstrap_project_index(canonical_root, &state_placement)?;
let watcher_info = Arc::new(Mutex::new(WatcherInfo::default()));
let token_stats = TokenStats::new();
let persistence_status = if matches!(
&state_placement,
StatePlacement::ProjectLocal { .. } | StatePlacement::UserLocal { .. }
) {
CapabilityStatus::Available
} else {
CapabilityStatus::Unavailable {
reason: crate::domain::CapabilityUnavailableReason::PersistentStateUnavailable,
}
};
let persistence_health = Arc::new(RwLock::new(persistence_status));
let curation_coordinator =
Arc::new(crate::protocol::knowledge_curation::KnowledgeCurationCoordinator::default());
if let Err(error) = curation_coordinator.recover_on_project_load(
&index,
canonical_root,
Some(&state_placement),
persistence_status,
) {
tracing::warn!("knowledge curation startup recovery remained fail-closed: {error}");
}
Ok(Self {
project_id: binding.root_id.0.clone(),
canonical_root: canonical_root.to_path_buf(),
project_name,
source_access_mode: binding.access_mode,
state_placement,
persistence_health,
curation_coordinator,
index,
watcher_info,
watcher_task: None,
stop_token: Arc::new(AtomicBool::new(false)),
token_stats,
symbol_cache: Arc::new(RwLock::new(HashMap::new())),
session_ids: HashSet::new(),
opened_at: SystemTime::now(),
activation_state: ActivationState::Inactive,
})
}
fn activate(&mut self) {
if self.activation_state != ActivationState::Inactive {
tracing::error!(
project_id = %self.project_id,
state = ?self.activation_state,
"activate() called on a project that is not Inactive — skipping"
);
return;
}
self.activation_state = ActivationState::Activating;
self.stop_token = Arc::new(AtomicBool::new(false));
self.watcher_task = start_project_watcher(
self.canonical_root.clone(),
Arc::clone(&self.index),
Arc::clone(&self.watcher_info),
Arc::clone(&self.stop_token),
);
let expected_gen = self.index.current_project_generation();
live_index::git_temporal::spawn_git_temporal_computation(
Arc::clone(&self.index),
self.canonical_root.clone(),
expected_gen,
);
self.activation_state = ActivationState::Active;
}
}
impl ProjectSlot {
fn new(project: ProjectInstance) -> Self {
Self {
metadata: RwLock::new(project),
mutation: Mutex::new(()),
}
}
fn activate(&self) {
let _mutation = self.mutation.lock();
let mut project = self.metadata.write();
if project.activation_state == ActivationState::Inactive {
project.activate();
}
}
fn stop(&self) {
let _mutation = self.mutation.lock();
let (mut watcher_task, stop_token) = {
let mut project = self.metadata.write();
(project.watcher_task.take(), Arc::clone(&project.stop_token))
};
abort_watcher_task(&mut watcher_task, &stop_token);
}
fn base(&self) -> Arc<IndexBase> {
let (canonical_root, index) = {
let project = self.metadata.read();
(
project.canonical_root.clone(),
Arc::clone(&project.index.read()),
)
};
let commit = match crate::git::head_sha(&canonical_root) {
Ok(sha) => CommitId::Sha(sha),
Err(_) => CommitId::Dirtyless,
};
Arc::new(IndexBase::new(
BaseKey::new(canonical_root, commit),
index,
1,
))
}
fn server_for_session(&self) -> SymForgeServer {
let (
index,
project_name,
watcher_info,
canonical_root,
state_placement,
persistence_health,
curation_coordinator,
token_stats,
) = {
let project = self.metadata.read();
(
Arc::clone(&project.index),
project.project_name.clone(),
Arc::clone(&project.watcher_info),
project.canonical_root.clone(),
project.state_placement.clone(),
Arc::clone(&project.persistence_health),
Arc::clone(&project.curation_coordinator),
Arc::clone(&project.token_stats),
)
};
let mut server = SymForgeServer::new_with_state_placement(
index,
project_name,
watcher_info,
Some(canonical_root),
Some(state_placement),
Some(token_stats),
);
server.persistence_health = persistence_health;
server.curation_coordinator = curation_coordinator;
server
}
fn reload_for_binding(&self, binding: &RootBinding) -> anyhow::Result<(usize, usize)> {
let (project_state_dir, source_exclusions) = {
let project = self.metadata.read();
(
project.state_placement.directory().cloned(),
crate::discovery::SourceExclusions::for_state_placement(
&binding.canonical_root,
&project.state_placement,
),
)
};
self.reload_with(&binding.canonical_root, move |index, root| {
index.reload_for_binding_with_exclusions(root, project_state_dir, source_exclusions)
})
}
fn reload_with<F>(
&self,
canonical_root: &Path,
reload_index: F,
) -> anyhow::Result<(usize, usize)>
where
F: FnOnce(&SharedIndex, &Path) -> anyhow::Result<()>,
{
let _mutation = self.mutation.lock();
let (index, watcher_info, mut watcher_task, old_stop_token) = {
let mut project = self.metadata.write();
(
Arc::clone(&project.index),
Arc::clone(&project.watcher_info),
project.watcher_task.take(),
Arc::clone(&project.stop_token),
)
};
abort_watcher_task(&mut watcher_task, &old_stop_token);
reload_index(&index, canonical_root)?;
let published = index.published_state();
let counts = (published.file_count, published.symbol_count);
let stop_token = Arc::new(AtomicBool::new(false));
let watcher_task = start_project_watcher(
canonical_root.to_path_buf(),
Arc::clone(&index),
watcher_info,
Arc::clone(&stop_token),
);
{
let mut project = self.metadata.write();
project.stop_token = stop_token;
project.watcher_task = watcher_task;
project.canonical_root = canonical_root.to_path_buf();
project.project_name = canonical_root
.file_name()
.and_then(|name| name.to_str())
.unwrap_or("project")
.to_string();
project.project_id = project_key(canonical_root);
}
let expected_gen = index.current_project_generation();
spawn_local_ref_reconcile(Arc::clone(&index), canonical_root.to_path_buf());
live_index::git_temporal::spawn_git_temporal_computation(
index,
canonical_root.to_path_buf(),
expected_gen,
);
Ok(counts)
}
}
fn spawn_local_ref_reconcile(
index: SharedIndex,
canonical_root: PathBuf,
) -> Option<tokio::task::JoinHandle<()>> {
if !local_ref_lanes_enabled() {
return None;
}
if tokio::runtime::Handle::try_current().is_err() {
return None;
}
Some(tokio::task::spawn_blocking(move || {
let Ok(canonical) = dunce::canonicalize(&canonical_root) else {
return;
};
let Ok(repository) = git2::Repository::open(&canonical) else {
return;
};
let project_id = crate::discovery::project_id_for_canonical_root(&canonical);
let repository_id =
match crate::live_index::persist::capture_repository_source(&canonical, &project_id) {
Ok(captured) => captured.source.repository_id,
Err(error) => {
tracing::debug!(%error, "local ref reconcile: repository identity unavailable");
return;
}
};
match live_index::local_ref_scout::reconcile_local_ref_topology(
&index,
&repository,
repository_id,
&live_index::local_ref_scout::LocalRefScoutBudget::default(),
) {
Ok(outcome) => tracing::info!(
published = outcome.published.len(),
removed = outcome.removed.len(),
checked_out = outcome.checked_out.len(),
"local ref lanes reconciled",
),
Err(error) => tracing::debug!(%error, "local ref reconcile skipped"),
}
}))
}
fn bootstrap_project_index(
canonical_root: &Path,
state_placement: &StatePlacement,
) -> anyhow::Result<SharedIndex> {
let source_exclusions =
crate::discovery::SourceExclusions::for_state_placement(canonical_root, state_placement);
if let Some(snapshot) = live_index::persist::load_snapshot(canonical_root, state_placement) {
let file_count = snapshot.files.len();
let snapshot_mtimes: HashMap<String, u64> = snapshot
.files
.iter()
.map(|(path, file)| (path.clone(), file.mtime_secs))
.collect();
let (live, code_signals) =
live_index::persist::snapshot_to_live_index_with_code_signals(snapshot, canonical_root);
tracing::info!(
files = file_count,
load_source = ?live.load_source(),
root = %canonical_root.display(),
"daemon bootstrap restored index from .symforge snapshot/team artifact"
);
let shared: SharedIndex =
live_index::SharedIndexHandle::shared_with_source_exclusions_and_code_signals(
live,
source_exclusions.clone(),
code_signals,
);
if let Ok(handle) = tokio::runtime::Handle::try_current() {
let bg_index = shared.clone();
let bg_root = canonical_root.to_path_buf();
handle.spawn(async move {
live_index::persist::background_verify(bg_index, bg_root, snapshot_mtimes).await;
});
}
return Ok(shared);
}
let cold_result = if matches!(state_placement, StatePlacement::ProjectLocal { .. }) {
live_index::LiveIndex::load_for_state_placement(canonical_root, state_placement)
.with_context(|| {
format!(
"failed to load project index for {}",
canonical_root.display()
)
})
} else {
let index = LiveIndex::empty();
match index.reload_for_binding_with_exclusions(
canonical_root,
state_placement.directory().cloned(),
source_exclusions,
) {
Ok(()) => Ok(index),
Err(error) => Err(error),
}
};
match cold_result {
Ok(index) => Ok(index),
Err(error) => {
let Some(capacity) = error.downcast_ref::<crate::discovery::ScoutCapacityError>()
else {
return Err(error);
};
let index = LiveIndex::empty();
index.set_freshness_status(crate::domain::FreshnessStatus::Degraded {
last_valid_content_generation: 0,
reason_codes: vec![capacity.reason()],
});
tracing::warn!(
root = %canonical_root.display(),
reason = ?capacity.reason(),
"cold project observation refused by catalog capacity; keeping project non-ready"
);
Ok(index)
}
}
}
fn start_project_watcher(
repo_root: PathBuf,
index: SharedIndex,
watcher_info: Arc<Mutex<WatcherInfo>>,
stop_token: Arc<AtomicBool>,
) -> Option<tokio::task::JoinHandle<()>> {
tokio::runtime::Handle::try_current().ok().map(|handle| {
handle.spawn(watcher::run_watcher_with_stop(
repo_root,
index,
watcher_info,
stop_token,
))
})
}
fn abort_watcher_task(
task: &mut Option<tokio::task::JoinHandle<()>>,
stop_token: &Arc<AtomicBool>,
) {
stop_token.store(true, Ordering::Release);
if let Some(task) = task.take() {
task.abort();
}
}
pub fn build_router(state: SharedDaemonState) -> Router {
Router::new()
.route("/health", get(daemon_health_handler))
.route("/v1/projects", get(list_projects_handler))
.route(
"/v1/projects/{project_id}/health",
get(project_health_handler),
)
.route(
"/v1/projects/{project_id}/sessions",
get(list_sessions_handler),
)
.route("/v1/sessions/open", post(open_project_session_handler))
.route(
"/v1/sessions/{session_id}/tools/{tool_name}",
post(call_tool_handler),
)
.route(
"/v1/sessions/{session_id}/sidecar/health",
get(sidecar_health_handler),
)
.route(
"/v1/sessions/{session_id}/sidecar/outline",
get(sidecar_outline_handler),
)
.route(
"/v1/sessions/{session_id}/sidecar/workflows/source-read",
get(sidecar_outline_handler),
)
.route(
"/v1/sessions/{session_id}/sidecar/impact",
get(sidecar_impact_handler),
)
.route(
"/v1/sessions/{session_id}/sidecar/workflows/post-edit-impact",
get(sidecar_impact_handler),
)
.route(
"/v1/sessions/{session_id}/sidecar/symbol-context",
get(sidecar_symbol_context_handler),
)
.route(
"/v1/sessions/{session_id}/sidecar/workflows/search-hit-expansion",
get(sidecar_symbol_context_handler),
)
.route(
"/v1/sessions/{session_id}/sidecar/repo-map",
get(sidecar_repo_map_handler),
)
.route(
"/v1/sessions/{session_id}/sidecar/workflows/repo-start",
get(sidecar_repo_map_handler),
)
.route(
"/v1/sessions/{session_id}/sidecar/prompt-context",
get(sidecar_prompt_context_handler),
)
.route(
"/v1/sessions/{session_id}/sidecar/workflows/prompt-context",
get(sidecar_prompt_context_handler),
)
.route(
"/v1/sessions/{session_id}/sidecar/stats",
get(sidecar_stats_handler),
)
.route(
"/v1/sessions/{session_id}/heartbeat",
post(heartbeat_handler),
)
.route("/v1/sessions/{session_id}", delete(close_session_handler))
.with_state(state)
}
pub async fn spawn_daemon(bind_host: &str) -> anyhow::Result<DaemonHandle> {
let control_state_dir = process_control_state_dir()?;
spawn_daemon_at(bind_host, control_state_dir).await
}
#[doc(hidden)]
pub async fn spawn_daemon_at(
bind_host: &str,
control_state_dir: &ControlStateDir,
) -> anyhow::Result<DaemonHandle> {
let resolved_host = resolve_daemon_bind_host(bind_host)?;
cleanup_daemon_runtime_files_at(control_state_dir);
let listener = TcpListener::bind(daemon_socket_bind_address(&resolved_host)).await?;
let port = listener.local_addr()?.port();
let auth_token = establish_daemon_auth_token();
write_daemon_token_file_at(control_state_dir, &auth_token)?;
write_daemon_port_file_at(control_state_dir, port)?;
write_daemon_pid_file_at(control_state_dir, std::process::id())?;
let state = Arc::new(DaemonState::with_token_at(
auth_token,
control_state_dir.clone(),
));
let app = build_router(Arc::clone(&state));
let (shutdown_tx, shutdown_rx) = tokio::sync::oneshot::channel::<()>();
let owned_token = state.auth_token_for_cleanup();
let cleanup_control_state_dir = control_state_dir.clone();
let server_task = tokio::spawn(async move {
let shutdown_signal = async move {
let _ = shutdown_rx.await;
};
if let Err(error) = axum::serve(listener, app)
.with_graceful_shutdown(shutdown_signal)
.await
{
tracing::error!("daemon server error: {error}");
}
cleanup_daemon_runtime_files_if_owner_at(
&cleanup_control_state_dir,
port,
std::process::id(),
&owned_token,
);
});
let ttl = session_ttl_from_env();
let idle_shutdown_after = daemon_idle_shutdown_from_env();
let reaper_state = Arc::downgrade(&state);
let reaper_task = tokio::spawn(async move {
let mut period_secs = (ttl.as_secs() / 4).clamp(10, 600);
if let Some(idle) = idle_shutdown_after {
period_secs = period_secs.min((idle.as_secs() / 4).max(10));
}
let mut interval = tokio::time::interval(tokio::time::Duration::from_secs(period_secs));
interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
let mut idle_fired = false;
loop {
interval.tick().await;
let Some(state) = reaper_state.upgrade() else {
break;
};
let reaped = state.reap_expired_sessions(ttl);
if reaped > 0 {
tracing::info!(reaped, ttl_secs = ttl.as_secs(), "session reaper sweep");
}
if let Some(idle) = idle_shutdown_after {
if state.active_authenticated_requests.load(Ordering::Relaxed) > 0 {
idle_fired = false;
continue;
}
let idle_ms = now_epoch_millis()
.saturating_sub(state.last_activity_at.load(Ordering::Relaxed));
if idle_ms >= idle.as_millis() as u64 {
if !idle_fired {
idle_fired = true;
tracing::info!(
idle_secs = idle_ms / 1000,
"no authenticated activity within the idle window; requesting daemon shutdown"
);
state.idle_shutdown.notify_one();
}
} else {
idle_fired = false;
}
}
}
});
Ok(DaemonHandle {
port,
shutdown_tx,
state,
server_task,
reaper_task,
})
}
pub async fn run_daemon_until_shutdown(bind_host: &str) -> anyhow::Result<()> {
let handle = match guarded_daemon_start(bind_host).await? {
GuardedStart::Started(handle) => handle,
GuardedStart::AlreadyRunning { port } => {
anyhow::bail!(
"a compatible symforge daemon is already running on port {port}; not starting a second one"
);
}
};
tracing::info!(port = handle.port, "shared daemon started");
let idle_state = Arc::clone(&handle.state);
#[cfg(unix)]
{
use tokio::signal::unix::{SignalKind, signal};
let mut sigterm = signal(SignalKind::terminate())?;
tokio::select! {
_ = tokio::signal::ctrl_c() => {
tracing::info!("received SIGINT, shutting down");
},
_ = sigterm.recv() => {
tracing::info!("received SIGTERM, shutting down");
},
_ = idle_state.idle_shutdown.notified() => {
tracing::info!("idle-shutdown window elapsed, shutting down");
},
}
}
#[cfg(not(unix))]
{
tokio::select! {
result = tokio::signal::ctrl_c() => {
result?;
tracing::info!("received Ctrl+C, shutting down");
},
_ = idle_state.idle_shutdown.notified() => {
tracing::info!("idle-shutdown window elapsed, shutting down");
},
}
}
let DaemonHandle {
shutdown_tx,
server_task,
reaper_task,
..
} = handle;
reaper_task.abort();
let _ = shutdown_tx.send(());
match tokio::time::timeout(tokio::time::Duration::from_secs(5), server_task).await {
Ok(Ok(())) => {}
Ok(Err(join_err)) => tracing::warn!("daemon server task ended with join error: {join_err}"),
Err(_) => tracing::warn!("timed out waiting for daemon server task to shut down"),
}
Ok(())
}
async fn daemon_health_handler(State(state): State<SharedDaemonState>) -> Json<DaemonHealth> {
Json(state.health())
}
async fn list_projects_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
) -> Result<Json<Vec<ProjectSummary>>, StatusCode> {
let _activity = authorize_daemon_request(&state, &headers)?;
Ok(Json(state.list_projects()))
}
async fn project_health_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
AxumPath(project_id): AxumPath<String>,
) -> Result<Json<ProjectHealth>, StatusCode> {
let _activity = authorize_daemon_request(&state, &headers)?;
state
.project_health(&project_id)
.map(Json)
.ok_or(StatusCode::NOT_FOUND)
}
async fn list_sessions_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
AxumPath(project_id): AxumPath<String>,
) -> Result<Json<Vec<SessionSummary>>, StatusCode> {
let _activity = authorize_daemon_request(&state, &headers)?;
state
.list_sessions(&project_id)
.map(Json)
.ok_or(StatusCode::NOT_FOUND)
}
async fn open_project_session_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
Json(request): Json<OpenProjectRequest>,
) -> Result<Json<OpenProjectResponse>, (StatusCode, String)> {
let _activity = authorize_daemon_request(&state, &headers).map_err(daemon_auth_error)?;
let state_for_load = Arc::clone(&state);
let response =
tokio::task::spawn_blocking(move || state_for_load.open_project_session(request))
.await
.map_err(internal_error)?
.map_err(bad_request)?;
Ok(Json(response))
}
fn connection_surface_from_headers(
headers: &HeaderMap,
) -> Option<crate::protocol::surface_probe::SurfaceProfile> {
headers
.get(crate::protocol::surface_probe::CONNECTION_SURFACE_HEADER)
.and_then(|value| value.to_str().ok())
.and_then(crate::protocol::surface_probe::surface_profile_from_label)
}
async fn call_tool_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
AxumPath((session_id, tool_name)): AxumPath<(String, String)>,
Json(mut params): Json<serde_json::Value>,
) -> Result<axum::response::Response, (StatusCode, String)> {
use axum::response::IntoResponse;
let _activity = authorize_daemon_request(&state, &headers).map_err(daemon_auth_error)?;
if tool_name == "index_folder" {
let input = decode_params::<IndexFolderInput>(params).map_err(bad_request)?;
let state_for_index = state.clone();
let session_id_owned = session_id.clone();
return state
.governor
.execute_non_abortable("index_folder", async move {
tokio::task::spawn_blocking(move || {
state_for_index.index_folder_for_session(&session_id_owned, input)
})
.await
.map_err(|join_err| anyhow::anyhow!("index_folder task panicked: {join_err}"))?
})
.await
.map_err(|gov_err| bad_request(gov_err.into()))?
.map_err(bad_request)
.map(|text| text.into_response());
}
if tool_name == "curate_knowledge" {
let input = decode_params::<CurateKnowledgeInput>(params.clone()).map_err(bad_request)?;
if let Err(message) = crate::protocol::knowledge_curation::validate_input(&input) {
return Ok(message.into_response());
}
}
if matches!(tool_name.as_str(), "search_knowledge" | "review_knowledge") {
let (project, projects) = if tool_name == "search_knowledge" {
let input =
decode_params::<SearchKnowledgeInput>(params.clone()).map_err(bad_request)?;
if let Err(message) = crate::protocol::knowledge_search::validate_input(&input) {
return Ok(message.into_response());
}
(input.project, input.projects)
} else {
let input =
decode_params::<ReviewKnowledgeInput>(params.clone()).map_err(bad_request)?;
if let Err(message) = crate::protocol::knowledge_review::validate_input(&input) {
return Ok(message.into_response());
}
(input.project, input.projects)
};
let resolve_selector = |selector: &str| {
state
.runtime_for_target(&session_id, Some(selector))
.map(|runtime| runtime.project_id)
};
if let Some(selector) = project.as_deref() {
let project_id = match resolve_selector(selector) {
Ok(project_id) => project_id,
Err(message) if message.starts_with("unknown session") => {
return Err((StatusCode::NOT_FOUND, message));
}
Err(message) => return Ok(message.into_response()),
};
if let Some(object) = params.as_object_mut() {
object.insert("project".to_string(), serde_json::Value::String(project_id));
}
} else if let Some(selectors) = projects.as_deref()
&& !(selectors.len() == 1 && selectors[0] == "*")
{
let mut project_ids = Vec::with_capacity(selectors.len());
for selector in selectors {
let project_id = match resolve_selector(selector) {
Ok(project_id) => project_id,
Err(message) if message.starts_with("unknown session") => {
return Err((StatusCode::NOT_FOUND, message));
}
Err(message) => return Ok(message.into_response()),
};
if !project_ids.contains(&project_id) {
project_ids.push(project_id);
}
}
if let Some(object) = params.as_object_mut() {
object.insert("projects".to_string(), serde_json::json!(project_ids));
}
}
}
if tool_name == "status" {
#[derive(serde::Deserialize)]
struct DetailPeek {
#[serde(default)]
detail: Option<String>,
}
let peek: DetailPeek =
serde_json::from_value(params.clone()).unwrap_or(DetailPeek { detail: None });
if peek.detail.as_deref() == Some("projects") {
return state
.render_session_project_inventory(&session_id)
.ok_or_else(|| {
(
StatusCode::NOT_FOUND,
format!("unknown session '{session_id}'"),
)
})
.map(|text| text.into_response());
}
}
let runtime = if single_project_routed_tool(&tool_name) {
#[derive(serde::Deserialize)]
struct ProjectPeek {
#[serde(default)]
project: Option<String>,
#[serde(default)]
projects: Option<Vec<String>>,
}
let peek: ProjectPeek = serde_json::from_value(params.clone()).unwrap_or(ProjectPeek {
project: None,
projects: None,
});
if peek.project.is_some() && peek.projects.is_some() {
return Ok(
"project and projects are mutually exclusive: pass exactly one (a single \
id in `project`, or a list/`[\"*\"]` in `projects`)."
.into_response(),
);
}
match state.runtime_for_target(&session_id, peek.project.as_deref()) {
Ok(runtime) => {
if peek.project.is_some()
&& let Some(object) = params.as_object_mut()
{
if tool_name == "curate_knowledge" {
object.insert(
"project".to_string(),
serde_json::Value::String(runtime.project_id.clone()),
);
} else {
object.remove("project");
}
}
runtime
}
Err(message) if message.starts_with("unknown session") => {
return Err((StatusCode::NOT_FOUND, message));
}
Err(message) => return Ok(message.into_response()),
}
} else {
state.session_runtime(&session_id).ok_or_else(|| {
(
StatusCode::NOT_FOUND,
format!("unknown session '{session_id}'"),
)
})?
};
let call_evidence_json = {
let published = runtime.index.published_state();
serde_json::to_string(&crate::protocol::result_status::ProjectEvidence {
project_id: runtime.project_id.clone(),
project_name: runtime
.canonical_root
.file_name()
.and_then(|name| name.to_str())
.unwrap_or("project")
.to_string(),
canonical_root: Some(normalized_path_string(&runtime.canonical_root)),
generation: runtime.index.current_project_generation(),
index_state: published.status_label().to_string(),
load_source: format!("{:?}", runtime.index.read().load_source()),
index_files: published.file_count,
index_symbols: published.symbol_count,
})
.ok()
};
let tool_name_owned = tool_name.clone();
let tool_name_for_panic = tool_name.clone();
let state_for_refresh = Arc::clone(&state);
let connection_surface = connection_surface_from_headers(&headers);
match state
.governor
.execute_non_abortable(&tool_name, async move {
let handle = tokio::runtime::Handle::current();
tokio::task::spawn_blocking(move || {
if tool_name_owned != "search_knowledge"
&& let Some(targets) = resolve_cross_project_targets(
&tool_name_owned,
¶ms,
&runtime.project_id,
)
{
state_for_refresh.refresh_working_set_bases(&runtime.working_set, &targets);
}
handle.block_on(crate::protocol::surface_probe::with_connection_surface(
connection_surface,
execute_tool_call(runtime, &tool_name_owned, params),
))
})
.await
.map_err(|join_err| anyhow::anyhow!("tool task panicked: {join_err}"))?
})
.await
{
Ok(Ok(mut result)) => {
if matches!(tool_name_for_panic.as_str(), "health" | "health_compact")
&& let Some(inventory) =
state.render_session_project_inventory_if_multi(&session_id)
{
result.push('\n');
result.push_str(&inventory);
}
let mut response = result.into_response();
if let Some(json) = call_evidence_json
&& let Ok(value) = axum::http::HeaderValue::try_from(json)
{
response.headers_mut().insert(
crate::protocol::result_status::PROJECT_EVIDENCE_HEADER,
value,
);
}
Ok(response)
}
Ok(Err(tool_err)) => {
Ok(format!("Error in {}: {}", tool_name_for_panic, tool_err).into_response())
}
Err(gov_err) => {
let msg = format!(
"Error: tool '{}' failed — {}. The tool did not complete. Do not retry immediately.",
tool_name_for_panic, gov_err
);
tracing::error!(tool = %tool_name_for_panic, "tool execution failed: {gov_err}");
Ok(msg.into_response())
}
}
}
async fn sidecar_health_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
AxumPath(session_id): AxumPath<String>,
) -> Result<Json<crate::sidecar::handlers::HealthResponse>, StatusCode> {
let _activity = authorize_daemon_request(&state, &headers)?;
let runtime = state
.session_runtime(&session_id)
.ok_or(StatusCode::NOT_FOUND)?;
let sidecar = sidecar_state_for_runtime(&runtime);
state
.governor
.execute("sidecar/health", async move {
let handle = tokio::runtime::Handle::current();
tokio::task::spawn_blocking(move || {
handle.block_on(crate::sidecar::handlers::health_handler(State(sidecar)))
})
.await
.unwrap_or(Err(StatusCode::INTERNAL_SERVER_ERROR))
})
.await
.map_err(|_| StatusCode::GATEWAY_TIMEOUT)?
}
async fn sidecar_outline_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
AxumPath(session_id): AxumPath<String>,
Query(params): Query<crate::sidecar::handlers::OutlineParams>,
) -> Result<String, StatusCode> {
let _activity = authorize_daemon_request(&state, &headers)?;
let runtime = state
.session_runtime(&session_id)
.ok_or(StatusCode::NOT_FOUND)?;
let sidecar = sidecar_state_for_runtime(&runtime);
state
.governor
.execute("sidecar/outline", async move {
let handle = tokio::runtime::Handle::current();
tokio::task::spawn_blocking(move || {
handle.block_on(crate::sidecar::handlers::outline_handler(
State(sidecar),
Query(params),
))
})
.await
.unwrap_or(Err(StatusCode::INTERNAL_SERVER_ERROR))
})
.await
.map_err(|_| StatusCode::GATEWAY_TIMEOUT)?
}
async fn sidecar_impact_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
AxumPath(session_id): AxumPath<String>,
Query(params): Query<crate::sidecar::handlers::ImpactParams>,
) -> Result<String, StatusCode> {
let _activity = authorize_daemon_request(&state, &headers)?;
let runtime = state
.session_runtime(&session_id)
.ok_or(StatusCode::NOT_FOUND)?;
let sidecar = sidecar_state_for_runtime(&runtime);
state
.governor
.execute("sidecar/impact", async move {
let handle = tokio::runtime::Handle::current();
tokio::task::spawn_blocking(move || {
handle.block_on(crate::sidecar::handlers::impact_handler(
State(sidecar),
Query(params),
))
})
.await
.unwrap_or(Err(StatusCode::INTERNAL_SERVER_ERROR))
})
.await
.map_err(|_| StatusCode::GATEWAY_TIMEOUT)?
}
async fn sidecar_symbol_context_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
AxumPath(session_id): AxumPath<String>,
Query(params): Query<crate::sidecar::handlers::SymbolContextParams>,
) -> Result<String, StatusCode> {
let _activity = authorize_daemon_request(&state, &headers)?;
let runtime = state
.session_runtime(&session_id)
.ok_or(StatusCode::NOT_FOUND)?;
let sidecar = sidecar_state_for_runtime(&runtime);
state
.governor
.execute("sidecar/symbol-context", async move {
let handle = tokio::runtime::Handle::current();
tokio::task::spawn_blocking(move || {
handle.block_on(crate::sidecar::handlers::symbol_context_handler(
State(sidecar),
Query(params),
))
})
.await
.unwrap_or(Err(StatusCode::INTERNAL_SERVER_ERROR))
})
.await
.map_err(|_| StatusCode::GATEWAY_TIMEOUT)?
}
async fn sidecar_repo_map_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
AxumPath(session_id): AxumPath<String>,
) -> Result<String, StatusCode> {
let _activity = authorize_daemon_request(&state, &headers)?;
let runtime = state
.session_runtime(&session_id)
.ok_or(StatusCode::NOT_FOUND)?;
let sidecar = sidecar_state_for_runtime(&runtime);
state
.governor
.execute("sidecar/repo-map", async move {
let handle = tokio::runtime::Handle::current();
tokio::task::spawn_blocking(move || {
handle.block_on(crate::sidecar::handlers::repo_map_handler(State(sidecar)))
})
.await
.unwrap_or(Err(StatusCode::INTERNAL_SERVER_ERROR))
})
.await
.map_err(|_| StatusCode::GATEWAY_TIMEOUT)?
}
async fn sidecar_prompt_context_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
AxumPath(session_id): AxumPath<String>,
Query(params): Query<crate::sidecar::handlers::PromptContextParams>,
) -> Result<String, StatusCode> {
let _activity = authorize_daemon_request(&state, &headers)?;
let runtime = state
.session_runtime(&session_id)
.ok_or(StatusCode::NOT_FOUND)?;
let sidecar = sidecar_state_for_runtime(&runtime);
state
.governor
.execute("sidecar/prompt-context", async move {
let handle = tokio::runtime::Handle::current();
tokio::task::spawn_blocking(move || {
handle.block_on(crate::sidecar::handlers::prompt_context_handler(
State(sidecar),
Query(params),
))
})
.await
.unwrap_or(Err(StatusCode::INTERNAL_SERVER_ERROR))
})
.await
.map_err(|_| StatusCode::GATEWAY_TIMEOUT)?
}
async fn sidecar_stats_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
AxumPath(session_id): AxumPath<String>,
) -> Result<Json<crate::sidecar::StatsSnapshot>, StatusCode> {
let _activity = authorize_daemon_request(&state, &headers)?;
let runtime = state
.session_runtime(&session_id)
.ok_or(StatusCode::NOT_FOUND)?;
let sidecar = sidecar_state_for_runtime(&runtime);
state
.governor
.execute("sidecar/stats", async move {
let handle = tokio::runtime::Handle::current();
tokio::task::spawn_blocking(move || {
handle.block_on(async {
Ok(crate::sidecar::handlers::stats_handler(State(sidecar)).await)
})
})
.await
.unwrap_or(Err(StatusCode::INTERNAL_SERVER_ERROR))
})
.await
.map_err(|_| StatusCode::GATEWAY_TIMEOUT)?
}
async fn heartbeat_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
AxumPath(session_id): AxumPath<String>,
) -> Result<Json<HeartbeatResponse>, StatusCode> {
let _activity = authorize_daemon_request(&state, &headers)?;
Ok(Json(state.heartbeat(&session_id)))
}
async fn close_session_handler(
State(state): State<SharedDaemonState>,
headers: HeaderMap,
AxumPath(session_id): AxumPath<String>,
) -> Result<Json<CloseSessionResponse>, StatusCode> {
let _activity = authorize_daemon_request(&state, &headers)?;
state
.close_session(&session_id)
.map(Json)
.ok_or(StatusCode::NOT_FOUND)
}
fn resolve_targets(
project: Option<&str>,
projects: Option<&[String]>,
active_project_id: &str,
) -> Result<Targets, String> {
match (project, projects) {
(Some(_), Some(_)) => Err(
"project and projects are mutually exclusive: pass exactly one (a single \
id in `project`, or a list/`[\"*\"]` in `projects`)."
.to_string(),
),
(Some(id), None) => {
let id = id.trim();
if id.is_empty() {
return Err("project must be a non-empty project id/alias.".to_string());
}
if id.contains('/') || id.contains('\\') {
return Err(format!(
"project must be a project id/alias, not a filesystem path ('{id}'). \
Open the folder first with index_folder(path=\"{id}\", add=true), \
then target it by its returned project id."
));
}
Ok(Targets::One(id.to_string()))
}
(None, Some(list)) => {
if list.is_empty() {
return Err(
"projects must not be empty: pass [\"*\"] for all open projects or an \
explicit list of project ids."
.to_string(),
);
}
let trimmed: Vec<&str> = list.iter().map(|id| id.trim()).collect();
if trimmed.iter().any(|id| id.is_empty()) {
return Err(
"projects entries must be non-empty project ids/aliases (blank entry found)."
.to_string(),
);
}
if trimmed.contains(&"*") {
return Ok(Targets::All);
}
for id in &trimmed {
if id.contains('/') || id.contains('\\') {
return Err(format!(
"projects entries must be project ids/aliases, not filesystem paths \
('{id}'). Open the folder first with \
index_folder(path=\"{id}\", add=true)."
));
}
}
let mut seen = std::collections::HashSet::new();
let deduped: Vec<String> = trimmed
.into_iter()
.filter(|id| seen.insert(id.to_string()))
.map(|id| id.to_string())
.collect();
Ok(Targets::Subset(deduped))
}
(None, None) => Ok(Targets::One(active_project_id.to_string())),
}
}
fn targets_is_single_active(targets: &Targets, active_project_id: &str) -> bool {
matches!(targets, Targets::One(id) if id == active_project_id)
}
fn targets_selects(targets: &Targets, project_id: &str) -> bool {
match targets {
Targets::One(id) => id == project_id,
Targets::Subset(ids) => ids.iter().any(|id| id == project_id),
Targets::All => true,
}
}
fn is_cross_project_read_verb(tool_name: &str) -> bool {
matches!(
tool_name,
"search_symbols"
| "search_text"
| "search_knowledge"
| "review_knowledge"
| "find_references"
| "search_files"
)
}
pub(crate) fn single_project_routed_tool(tool_name: &str) -> bool {
matches!(
tool_name,
"get_symbol"
| "get_symbol_context"
| "get_file_context"
| "get_file_content"
| "get_repo_map"
| "search_files"
| "find_dependents"
| "diff_symbols"
| "what_changed"
| "analyze_file_impact"
| "validate_file_syntax"
| "explore"
| "ask"
| "conventions"
| "edit_plan"
| "investigation_suggest"
| "replace_symbol_body"
| "edit_within_symbol"
| "insert_symbol"
| "delete_symbol"
| "batch_edit"
| "batch_insert"
| "batch_rename"
| "curate_knowledge"
)
}
fn resolve_cross_project_targets(
tool_name: &str,
params: &serde_json::Value,
active_project_id: &str,
) -> Option<Targets> {
if !is_cross_project_read_verb(tool_name) {
return None;
}
#[derive(serde::Deserialize)]
struct CrossProjectPeek {
#[serde(default)]
project: Option<String>,
#[serde(default)]
projects: Option<Vec<String>>,
}
let peek: CrossProjectPeek =
serde_json::from_value(params.clone()).unwrap_or(CrossProjectPeek {
project: None,
projects: None,
});
let targets = resolve_targets(
peek.project.as_deref(),
peek.projects.as_deref(),
active_project_id,
)
.ok()?;
if targets_is_single_active(&targets, active_project_id) {
None
} else {
Some(targets)
}
}
fn ensure_targets_open(targets: &Targets, working_set: &WorkingSet) -> Result<(), String> {
let missing: Vec<&String> = match targets {
Targets::One(id) => {
if working_set.get(id).is_none() {
vec![id]
} else {
Vec::new()
}
}
Targets::Subset(ids) => ids
.iter()
.filter(|id| working_set.get(id).is_none())
.collect(),
Targets::All => Vec::new(),
};
if missing.is_empty() {
Ok(())
} else {
Err(format!(
"project not open: {}. Open it in this session first with \
index_folder(path=..., add=true), then retarget.",
missing
.iter()
.map(|id| format!("'{id}'"))
.collect::<Vec<_>>()
.join(", ")
))
}
}
const CROSS_PROJECT_DEFAULT_RESULT_CAP: usize = 200;
const CROSS_PROJECT_MAX_RESULT_CAP: usize = 1000;
fn cross_project_result_cap(limit: Option<u32>) -> usize {
match limit {
Some(l) => (l as usize).clamp(1, CROSS_PROJECT_MAX_RESULT_CAP),
None => CROSS_PROJECT_DEFAULT_RESULT_CAP,
}
}
fn apply_cross_project_token_budget(body: String, max_tokens: Option<u64>) -> String {
let Some(max_tokens) = max_tokens.filter(|t| *t > 0) else {
return body;
};
let max_bytes = (max_tokens as usize).saturating_mul(4);
if max_bytes == 0 || body.len() <= max_bytes {
return body;
}
let cut_end = body
.bytes()
.enumerate()
.filter(|&(idx, b)| b == b'\n' && idx < max_bytes)
.map(|(idx, _)| idx + 1)
.next_back();
let mut truncated = match cut_end {
Some(end) => body[..end].to_string(),
None => String::new(),
};
truncated.push_str(&format!(
"... (truncated to fit max_tokens={max_tokens}; cross-project output is \
token-bounded — raise max_tokens or query a single project for the full set)\n"
));
truncated
}
fn reject_unsupported_cross_project_scoping(
tool_name: &str,
params: &serde_json::Value,
) -> anyhow::Result<()> {
fn refuse(param: &str) -> anyhow::Result<()> {
anyhow::bail!(
"{param} scoping is not supported with cross-project targeting; \
query a single project for scoped results."
);
}
#[derive(serde::Deserialize, Default)]
struct ScopePeek {
#[serde(default)]
path: Option<String>,
#[serde(default)]
symbol_kind: Option<String>,
#[serde(default)]
direction: Option<String>,
#[serde(default)]
structural: Option<bool>,
#[serde(default)]
resolve: Option<bool>,
#[serde(default)]
changed_with: Option<String>,
#[serde(default)]
anchor_path: Option<String>,
#[serde(default)]
rank_by: Option<String>,
#[serde(default)]
current_file: Option<String>,
}
let peek: ScopePeek = serde_json::from_value(params.clone()).unwrap_or_default();
let present = |v: &Option<String>| v.as_deref().is_some_and(|s| !s.trim().is_empty());
match tool_name {
"search_text" => {
if peek.structural == Some(true) {
return refuse("structural");
}
}
"find_references" => {
if present(&peek.path) {
return refuse("path");
}
if present(&peek.symbol_kind) {
return refuse("symbol_kind");
}
if present(&peek.direction) {
return refuse("direction");
}
}
"search_files" => {
if peek.resolve == Some(true) {
return refuse("resolve");
}
if present(&peek.changed_with) {
return refuse("changed_with");
}
if present(&peek.anchor_path) {
return refuse("anchor_path");
}
if present(&peek.rank_by) {
return refuse("rank_by");
}
if present(&peek.current_file) {
return refuse("current_file");
}
}
_ => {}
}
Ok(())
}
fn execute_cross_project_read(
tool_name: &str,
params: serde_json::Value,
targets: Targets,
working_set: &WorkingSet,
) -> anyhow::Result<String> {
ensure_targets_open(&targets, working_set).map_err(|message| anyhow::anyhow!("{message}"))?;
reject_unsupported_cross_project_scoping(tool_name, ¶ms)?;
let multi = match &targets {
Targets::One(_) => false,
Targets::Subset(ids) => ids.len() > 1,
Targets::All => working_set.len() > 1,
};
match tool_name {
"search_symbols" => {
let input: SearchSymbolsInput = decode_params(params)?;
let query = input.query.as_deref().unwrap_or("").trim();
if query.is_empty() {
anyhow::bail!(
"cross-project search_symbols requires a non-empty query \
(browse mode is single-project only)."
);
}
let options = search_symbols_options_from_input(&input)
.map_err(|message| anyhow::anyhow!(message))?;
let cap = cross_project_result_cap(input.limit);
let hits = working_set.search_symbols(&targets, query, input.kind.as_deref(), &options);
let body = format_cross_project_symbols(&hits, query, multi, cap);
Ok(apply_cross_project_token_budget(body, input.max_tokens))
}
"search_text" => {
let input: SearchTextInput = decode_params(params)?;
let regex = input.regex.unwrap_or(false);
let mut options = search_text_options_from_input(&input)
.map_err(|message| anyhow::anyhow!(message))?;
options.context = None;
let cap = cross_project_result_cap(input.limit);
let results = working_set
.search_text(
&targets,
input.query.as_deref(),
input.terms.as_deref(),
regex,
&options,
)
.map_err(|error| anyhow::anyhow!("text search failed: {error:?}"))?;
let body = format_cross_project_text(&results, multi, cap);
Ok(apply_cross_project_token_budget(body, input.max_tokens))
}
"find_references" => {
let input: FindReferencesInput = decode_params(params)?;
let name = input.name.trim();
if name.is_empty() {
anyhow::bail!("cross-project find_references requires a non-empty name.");
}
let kind_filter = match input.kind.as_deref() {
Some("call") => Some(crate::domain::ReferenceKind::Call),
Some("import") => Some(crate::domain::ReferenceKind::Import),
Some("type_usage") => Some(crate::domain::ReferenceKind::TypeUsage),
Some("macro_use") => Some(crate::domain::ReferenceKind::MacroUse),
Some("value_use") => Some(crate::domain::ReferenceKind::ValueUse),
_ => None,
};
let cap = cross_project_result_cap(input.limit);
let hits = working_set.find_references(&targets, name, kind_filter, false);
let body = format_cross_project_references(&hits, name, multi, cap);
Ok(apply_cross_project_token_budget(body, input.max_tokens))
}
"search_files" => {
let input: SearchFilesInput = decode_params(params)?;
let query = input.query.trim();
if query.is_empty() {
anyhow::bail!("cross-project search_files requires a non-empty query.");
}
let path_scope = match input.path_prefix.as_deref().map(str::trim) {
Some(prefix) if !prefix.is_empty() => {
crate::live_index::search::PathScope::Prefix(prefix.to_string())
}
_ => crate::live_index::search::PathScope::Any,
};
let cap = cross_project_result_cap(input.limit);
let per_project_limit = input.limit.unwrap_or(20).clamp(1, 50) as usize;
let hits = working_set.search_files(
&targets,
query,
per_project_limit,
input.include_vendor.unwrap_or(false),
input.include_personal_tooling.unwrap_or(false),
&path_scope,
);
let body = format_cross_project_files(&hits, query, multi, cap);
Ok(apply_cross_project_token_budget(body, input.max_tokens))
}
other => anyhow::bail!("'{other}' is not a cross-project read verb"),
}
}
fn execute_cross_project_knowledge(
mut input: SearchKnowledgeInput,
targets: Targets,
project_indexes: &HashMap<String, SharedIndex>,
ccr_server: &SymForgeServer,
) -> anyhow::Result<String> {
let mut selected_ids: Vec<String> = match targets {
Targets::One(id) => vec![id],
Targets::Subset(ids) => ids,
Targets::All => project_indexes.keys().cloned().collect(),
};
selected_ids.sort();
selected_ids.dedup();
let missing: Vec<String> = selected_ids
.iter()
.filter(|id| !project_indexes.contains_key(*id))
.cloned()
.collect();
if !missing.is_empty() {
anyhow::bail!(
"project not open: {}. Open it in this session first with \
index_folder(path=..., add=true), then retarget.",
missing
.iter()
.map(|id| format!("'{id}'"))
.collect::<Vec<_>>()
.join(", ")
);
}
input.project = None;
input.projects = None;
let max_tokens = input.max_tokens;
let captured: Vec<_> = selected_ids
.iter()
.map(|id| {
let source_set = project_indexes
.get(id)
.expect("selected projects were validated")
.published_source_set();
(id.clone(), source_set)
})
.collect();
let multi = captured.len() > 1;
let mut sections = Vec::with_capacity(captured.len());
for (project_id, source_set) in captured {
let result = crate::protocol::knowledge_search::search_scoped(&source_set, &input);
if multi {
sections.push(format!("── project: {project_id} ──\n{result}"));
} else {
sections.push(result);
}
}
let body = sections.join("\n\n");
Ok(ccr_server.apply_ccr_budget("search_knowledge", body, max_tokens))
}
fn execute_cross_project_review(
mut input: ReviewKnowledgeInput,
targets: Targets,
project_indexes: &HashMap<String, SharedIndex>,
ccr_server: &SymForgeServer,
) -> anyhow::Result<String> {
let mut selected_ids: Vec<String> = match targets {
Targets::One(id) => vec![id],
Targets::Subset(ids) => ids,
Targets::All => project_indexes.keys().cloned().collect(),
};
selected_ids.sort();
selected_ids.dedup();
let missing: Vec<String> = selected_ids
.iter()
.filter(|id| !project_indexes.contains_key(*id))
.cloned()
.collect();
if !missing.is_empty() {
anyhow::bail!(
"project not open: {}. Open it in this session first with \
index_folder(path=..., add=true), then retarget.",
missing
.iter()
.map(|id| format!("'{id}'"))
.collect::<Vec<_>>()
.join(", ")
);
}
input.project = None;
input.projects = None;
let max_tokens = input.max_tokens;
let captured: Vec<_> = selected_ids
.iter()
.map(|id| {
let source_set = project_indexes
.get(id)
.expect("selected projects were validated")
.published_source_set();
(id.clone(), source_set)
})
.collect();
let mut plans = Vec::with_capacity(captured.len());
for (project_id, source_set) in captured {
let output = crate::protocol::knowledge_review::review_scoped(&source_set, &input)
.map_err(anyhow::Error::msg)?;
plans.push((project_id, output));
}
let top_result_hash = if plans.len() == 1 {
plans[0].1.result_hash.clone()
} else {
crate::protocol::knowledge_review::combined_result_hash(
&plans
.iter()
.map(|(_, output)| (output.source_key.clone(), output.review_hash.clone()))
.collect::<Vec<_>>(),
)
};
let multi = plans.len() > 1;
let sections = plans
.iter()
.map(|(project_id, output)| {
if multi {
format!("── project: {project_id} ──\n{}", output.source_section)
} else {
output.source_section.clone()
}
})
.collect::<Vec<_>>()
.join("\n\n");
let budget_sections = plans
.iter()
.map(|(project_id, output)| {
if multi {
format!(
"── project: {project_id} ──\n{}",
output.budget_source_section
)
} else {
output.budget_source_section.clone()
}
})
.collect::<Vec<_>>()
.join("\n\n");
let body = format!("top_result_hash={top_result_hash}\n{sections}");
let budget_body = format!("top_result_hash={top_result_hash}\n{budget_sections}");
Ok(ccr_server.apply_ccr_budget_with_summary("review_knowledge", body, budget_body, max_tokens))
}
fn format_cross_project_files(
hits: &[crate::live_index::view::ProjectHit<crate::live_index::SearchFilesHit>],
query: &str,
multi: bool,
cap: usize,
) -> String {
if hits.is_empty() {
return format!("No files matching '{query}' in the targeted project(s).");
}
let total = hits.len();
let shown = total.min(cap);
let mut out = String::new();
if shown < total {
out.push_str(&format!(
"{shown} of {total} file matches across projects (truncated; cross-project results \
are capped — pass a larger `limit` or query a single project for the full set)\n"
));
} else {
out.push_str(&format!("{total} file matches across projects\n"));
}
let mut current: Option<&str> = None;
for ph in hits.iter().take(shown) {
if multi && current != Some(ph.project_id.as_str()) {
current = Some(ph.project_id.as_str());
out.push_str(&format!(
"\n\u{2500}\u{2500} project: {} \u{2500}\u{2500}\n",
ph.project_id
));
}
let h = &ph.hit;
match &h.metadata_reason {
Some(reason) => out.push_str(&format!(" {} [metadata-only: {reason}]\n", h.path)),
None => out.push_str(&format!(" {}\n", h.path)),
}
}
out
}
fn format_cross_project_symbols(
hits: &[crate::live_index::view::ProjectHit<crate::live_index::view::ViewSymbolHit>],
query: &str,
multi: bool,
cap: usize,
) -> String {
if hits.is_empty() {
return format!("No symbols matching '{query}' in the targeted project(s).");
}
let total = hits.len();
let shown = total.min(cap);
let mut out = String::new();
let mut current: Option<&str> = None;
if shown < total {
out.push_str(&format!(
"{shown} of {total} matches across projects (truncated; cross-project results \
are capped — pass a larger `limit` or query a single project for the full set)\n"
));
} else {
out.push_str(&format!("{total} matches across projects\n"));
}
for ph in hits.iter().take(shown) {
if multi && current != Some(ph.project_id.as_str()) {
current = Some(ph.project_id.as_str());
out.push_str(&format!(
"\n\u{2500}\u{2500} project: {} \u{2500}\u{2500}\n",
ph.project_id
));
}
let h = &ph.hit;
out.push_str(&format!(
" {}: {} {} ({})\n",
h.line, h.kind, h.name, h.path
));
}
out
}
fn format_cross_project_text(
results: &[crate::live_index::view::ProjectHit<crate::live_index::search::TextSearchResult>],
multi: bool,
cap: usize,
) -> String {
let total: usize = results.iter().map(|ph| ph.hit.total_matches).sum();
if total == 0 {
return "No text matches in the targeted project(s).".to_string();
}
let mut body = String::new();
let mut shown = 0usize;
'projects: for ph in results {
if ph.hit.files.is_empty() {
continue;
}
let mut header_written = false;
for file in &ph.hit.files {
if file.matches.is_empty() {
continue;
}
if shown >= cap {
break 'projects;
}
if multi && !header_written {
body.push_str(&format!(
"\n\u{2500}\u{2500} project: {} \u{2500}\u{2500}\n",
ph.project_id
));
header_written = true;
}
body.push_str(&format!("{}\n", file.path));
for m in &file.matches {
if shown >= cap {
break 'projects;
}
body.push_str(&format!(" {}: {}\n", m.line_number, m.line));
shown += 1;
}
}
}
let mut out = String::new();
if shown < total {
out.push_str(&format!(
"{shown} of {total} text matches across projects (truncated; cross-project results \
are capped — pass a larger `limit` or query a single project for the full set)\n"
));
} else {
out.push_str(&format!("{total} text matches across projects\n"));
}
out.push_str(&body);
out
}
fn format_cross_project_references(
hits: &[crate::live_index::view::ProjectHit<(String, crate::domain::ReferenceRecord)>],
name: &str,
multi: bool,
cap: usize,
) -> String {
if hits.is_empty() {
return format!("No references to '{name}' in the targeted project(s).");
}
let total = hits.len();
let shown = total.min(cap);
let mut out = String::new();
let mut current: Option<&str> = None;
if shown < total {
out.push_str(&format!(
"{shown} of {total} references across projects (truncated; cross-project results \
are capped — pass a larger `limit` or query a single project for the full set)\n"
));
} else {
out.push_str(&format!("{total} references across projects\n"));
}
for ph in hits.iter().take(shown) {
if multi && current != Some(ph.project_id.as_str()) {
current = Some(ph.project_id.as_str());
out.push_str(&format!(
"\n\u{2500}\u{2500} project: {} \u{2500}\u{2500}\n",
ph.project_id
));
}
let (path, reference) = &ph.hit;
out.push_str(&format!(
" {}:{} [{:?}] {}\n",
path,
reference.line_range.0 + 1,
reference.kind,
reference.name
));
}
out
}
fn strip_cross_project_targeting(mut params: serde_json::Value) -> serde_json::Value {
if let serde_json::Value::Object(ref mut object) = params {
object.remove("project");
object.remove("projects");
}
params
}
async fn execute_tool_call(
runtime: SessionRuntime,
tool_name: &str,
mut params: serde_json::Value,
) -> anyhow::Result<String> {
runtime.token_stats.record_tool_call(tool_name);
if is_cross_project_read_verb(tool_name) {
#[derive(serde::Deserialize)]
struct CrossProjectPeek {
#[serde(default)]
project: Option<String>,
#[serde(default)]
projects: Option<Vec<String>>,
}
let peek: CrossProjectPeek =
serde_json::from_value(params.clone()).unwrap_or(CrossProjectPeek {
project: None,
projects: None,
});
let targets = resolve_targets(
peek.project.as_deref(),
peek.projects.as_deref(),
&runtime.project_id,
)
.map_err(|message| anyhow::anyhow!("{message}"))?;
if !targets_is_single_active(&targets, &runtime.project_id) {
if tool_name == "search_knowledge" {
let input = decode_params::<SearchKnowledgeInput>(params)?;
return execute_cross_project_knowledge(
input,
targets,
&runtime.project_indexes,
&runtime.server,
);
}
if tool_name == "review_knowledge" {
let input = decode_params::<ReviewKnowledgeInput>(params)?;
return execute_cross_project_review(
input,
targets,
&runtime.project_indexes,
&runtime.server,
);
}
let working_set = runtime.working_set.read();
return execute_cross_project_read(tool_name, params, targets, &working_set);
}
params = strip_cross_project_targeting(params);
}
let server = runtime.server;
match tool_name {
"get_symbol" => Ok(server
.get_symbol(Parameters(decode_params::<GetSymbolInput>(params)?))
.await),
"get_repo_map" => Ok(server
.get_repo_map(Parameters(decode_params::<GetRepoMapInput>(params)?))
.await),
"get_file_context" => Ok(server
.get_file_context(Parameters(decode_params::<GetFileContextInput>(params)?))
.await),
"get_symbol_context" => Ok(server
.get_symbol_context(Parameters(decode_params::<GetSymbolContextInput>(params)?))
.await),
"analyze_file_impact" => Ok(server
.analyze_file_impact(Parameters(decode_params::<AnalyzeFileImpactInput>(params)?))
.await),
"search_symbols" => Ok(server
.search_symbols(Parameters(decode_params::<SearchSymbolsInput>(params)?))
.await),
"search_text" => Ok(server
.search_text(Parameters(decode_params::<SearchTextInput>(params)?))
.await),
"search_knowledge" => Ok(server
.search_knowledge(Parameters(decode_params::<SearchKnowledgeInput>(params)?))
.await),
"review_knowledge" => Ok(server
.review_knowledge(Parameters(decode_params::<ReviewKnowledgeInput>(params)?))
.await),
"curate_knowledge" => Ok(server
.curate_knowledge(Parameters(decode_params::<CurateKnowledgeInput>(params)?))
.await),
"trace_symbol" => {
let tp: TraceSymbolInput = decode_params(params)?;
let sections = tp.sections.unwrap_or_default();
let output = server
.get_symbol_context(Parameters(GetSymbolContextInput {
project: None,
name: tp.name,
file: None,
path: Some(tp.path),
symbol_kind: tp.kind,
symbol_line: tp.symbol_line,
verbosity: tp.verbosity,
bundle: None,
sections: Some(sections),
max_tokens: None,
estimate: None,
}))
.await;
Ok(format!("{TRACE_SYMBOL_ALIAS_DEPRECATION}\n\n{output}"))
}
"inspect_match" => Ok(server
.inspect_match(Parameters(decode_params::<InspectMatchInput>(params)?))
.await),
"search_files" => Ok(server
.search_files(Parameters(decode_params::<SearchFilesInput>(params)?))
.await),
"health" => {
let input: HealthInput = decode_params(params)?;
Ok(server.health_for_daemon_session(
runtime.project_id.clone(),
runtime.session_id.clone(),
runtime.canonical_root.clone(),
crate::protocol::format::QuarantineWindow::from_args(
input.quarantine_offset.map(|n| n as usize),
input.quarantine_limit.map(|n| n as usize),
),
))
}
"health_compact" => Ok(server.health_compact_for_daemon_session(
runtime.project_id.clone(),
runtime.session_id.clone(),
runtime.canonical_root.clone(),
)),
"index_folder" => Ok(server
.index_folder(Parameters(decode_params::<IndexFolderInput>(params)?))
.await),
"what_changed" => Ok(server
.what_changed(Parameters(decode_params::<WhatChangedInput>(params)?))
.await),
"get_file_content" => Ok(server
.get_file_content(Parameters(decode_params::<GetFileContentInput>(params)?))
.await),
"find_references" => Ok(server
.find_references(Parameters(decode_params::<FindReferencesInput>(params)?))
.await),
"find_dependents" => Ok(server
.find_dependents(Parameters(decode_params::<FindDependentsInput>(params)?))
.await),
"explore" => Ok(server
.explore(Parameters(decode_params::<ExploreInput>(params)?))
.await),
"diff_symbols" => Ok(server
.diff_symbols(Parameters(decode_params::<DiffSymbolsInput>(params)?))
.await),
"replace_symbol_body" => Ok(server
.replace_symbol_body(Parameters(decode_params::<ReplaceSymbolBodyInput>(params)?))
.await),
"insert_symbol" => Ok(server
.insert_symbol(Parameters(decode_params::<InsertSymbolInput>(params)?))
.await),
"delete_symbol" => Ok(server
.delete_symbol(Parameters(decode_params::<DeleteSymbolInput>(params)?))
.await),
"edit_within_symbol" => Ok(server
.edit_within_symbol(Parameters(decode_params::<EditWithinSymbolInput>(params)?))
.await),
"batch_edit" => Ok(server
.batch_edit(Parameters(decode_params::<BatchEditInput>(params)?))
.await),
"batch_rename" => Ok(server
.batch_rename(Parameters(decode_params::<BatchRenameInput>(params)?))
.await),
"batch_insert" => Ok(server
.batch_insert(Parameters(decode_params::<BatchInsertInput>(params)?))
.await),
"validate_file_syntax" => Ok(server
.validate_file_syntax(Parameters(decode_params::<ValidateFileSyntaxInput>(
params,
)?))
.await),
"conventions" => Ok(server.conventions().await),
"edit_plan" => Ok(server
.edit_plan(Parameters(decode_params::<EditPlanInput>(params)?))
.await),
"investigation_suggest" => Ok(server
.investigation_suggest(Parameters(decode_params::<InvestigationInput>(params)?))
.await),
"context_inventory" => Ok(server.context_inventory().await),
"symforge_retrieve" => Ok(server
.symforge_retrieve(Parameters(decode_params::<SymforgeRetrieveInput>(params)?))
.await),
"ask" => Ok(server
.ask(Parameters(decode_params::<SmartQueryInput>(params)?))
.await),
"checkpoint_now" => Ok(server
.checkpoint_now(Parameters(decode_params::<CheckpointNowInput>(params)?))
.await),
"detect_impact" => Ok(server
.detect_impact(Parameters(decode_params::<DetectImpactInput>(params)?))
.await),
"detect_changes" => {
let output = server
.detect_impact(Parameters(decode_params::<DetectImpactInput>(params)?))
.await;
Ok(format!("{DETECT_CHANGES_ALIAS_DEPRECATION}\n\n{output}"))
}
"status" => Ok(server
.status_for_daemon_session(&decode_params::<crate::stel::StelStatusRequest>(params)?)),
other => anyhow::bail!("unknown tool '{other}'"),
}
}
fn sidecar_state_for_runtime(runtime: &SessionRuntime) -> SidecarState {
SidecarState {
index: Arc::clone(&runtime.index),
token_stats: Arc::clone(&runtime.token_stats),
repo_root: Some(runtime.canonical_root.clone()),
symbol_cache: Arc::clone(&runtime.symbol_cache),
}
}
fn decode_params<T>(params: serde_json::Value) -> anyhow::Result<T>
where
T: serde::de::DeserializeOwned,
{
serde_json::from_value(params).context("invalid tool parameters")
}
fn bad_request(error: anyhow::Error) -> (axum::http::StatusCode, String) {
(axum::http::StatusCode::BAD_REQUEST, error.to_string())
}
fn internal_error(error: tokio::task::JoinError) -> (axum::http::StatusCode, String) {
(
axum::http::StatusCode::INTERNAL_SERVER_ERROR,
error.to_string(),
)
}
fn canonical_project_root(root: &Path) -> anyhow::Result<PathBuf> {
root.canonicalize()
.with_context(|| format!("failed to canonicalize project root {}", root.display()))
}
pub(crate) fn project_key(root: &Path) -> String {
crate::discovery::project_id_for_canonical_root(root).0
}
fn normalized_path_string(path: &Path) -> String {
path.to_string_lossy().replace('\\', "/")
}
fn process_control_state_dir() -> io::Result<&'static ControlStateDir> {
paths::process_control_state_placement()
.directory()
.ok_or_else(|| {
io::Error::new(
io::ErrorKind::NotFound,
"process control state is unavailable",
)
})
}
fn daemon_dir_for(control_state_dir: &ControlStateDir) -> io::Result<PathBuf> {
paths::ensure_control_state_dir(control_state_dir)?;
let dir = paths::control_state_path(control_state_dir, "daemon");
std::fs::create_dir_all(&dir)?;
Ok(dir)
}
fn write_daemon_port_file_at(control_state_dir: &ControlStateDir, port: u16) -> io::Result<()> {
let path = daemon_dir_for(control_state_dir)?.join(daemon_port_file_name());
std::fs::write(&path, port.to_string()).map_err(|e| {
io::Error::new(
e.kind(),
format!("writing daemon port file at {}: {}", path.display(), e),
)
})
}
fn write_daemon_pid_file_at(control_state_dir: &ControlStateDir, pid: u32) -> io::Result<()> {
let path = daemon_dir_for(control_state_dir)?.join(daemon_pid_file_name());
std::fs::write(&path, pid.to_string()).map_err(|e| {
io::Error::new(
e.kind(),
format!("writing daemon pid file at {}: {}", path.display(), e),
)
})
}
fn read_daemon_pid_file_at(control_state_dir: &ControlStateDir) -> io::Result<u32> {
let contents = read_daemon_runtime(
&daemon_dir_for(control_state_dir)?,
&daemon_pid_file_name(),
LEGACY_DAEMON_PID_FILE,
)?;
contents
.trim()
.parse::<u32>()
.map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))
}
pub(crate) fn read_daemon_port_file() -> io::Result<u16> {
read_daemon_port_file_at(process_control_state_dir()?)
}
fn read_daemon_port_file_at(control_state_dir: &ControlStateDir) -> io::Result<u16> {
let contents = read_daemon_runtime(
&daemon_dir_for(control_state_dir)?,
&daemon_port_file_name(),
LEGACY_DAEMON_PORT_FILE,
)?;
contents
.trim()
.parse::<u16>()
.map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))
}
#[cfg(test)]
fn cleanup_daemon_files_at(control_state_dir: &ControlStateDir) {
cleanup_daemon_runtime_files_at(control_state_dir);
if let Ok(dir) = daemon_dir_for(control_state_dir) {
let _ = std::fs::remove_file(dir.join(daemon_start_lock_file_name()));
let _ = std::fs::remove_file(dir.join(LEGACY_DAEMON_START_LOCK_FILE));
}
}
fn cleanup_daemon_runtime_files_if_owner_at(
control_state_dir: &ControlStateDir,
port: u16,
pid: u32,
token: &str,
) {
if let Ok(dir) = daemon_dir_for(control_state_dir) {
let owns = |path: &std::path::Path, expected: &str| {
std::fs::read_to_string(path)
.map(|contents| contents.trim() == expected)
.unwrap_or(false)
};
let port_path = dir.join(daemon_port_file_name());
if owns(&port_path, &port.to_string()) {
let _ = std::fs::remove_file(&port_path);
}
let pid_path = dir.join(daemon_pid_file_name());
if owns(&pid_path, &pid.to_string()) {
let _ = std::fs::remove_file(&pid_path);
}
let token_path = dir.join(daemon_token_file_name());
if owns(&token_path, token) {
let _ = std::fs::remove_file(&token_path);
}
let _ = std::fs::remove_file(dir.join(LEGACY_DAEMON_PORT_FILE));
let _ = std::fs::remove_file(dir.join(LEGACY_DAEMON_PID_FILE));
}
}
fn cleanup_daemon_runtime_files_at(control_state_dir: &ControlStateDir) {
if let Ok(dir) = daemon_dir_for(control_state_dir) {
let _ = std::fs::remove_file(dir.join(daemon_port_file_name()));
let _ = std::fs::remove_file(dir.join(daemon_pid_file_name()));
let _ = std::fs::remove_file(dir.join(daemon_token_file_name()));
let _ = std::fs::remove_file(dir.join(LEGACY_DAEMON_PORT_FILE));
let _ = std::fs::remove_file(dir.join(LEGACY_DAEMON_PID_FILE));
}
}
#[allow(unsafe_code)] pub(crate) fn terminate_process(pid: u32) -> io::Result<()> {
#[cfg(windows)]
{
let status = crate::process_util::hidden_command("taskkill")
.args(["/PID", &pid.to_string(), "/T", "/F"])
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null())
.status()?;
if status.success() || status.code() == Some(128) {
Ok(())
} else {
Err(io::Error::other(format!(
"taskkill exited with status {status}"
)))
}
}
#[cfg(not(windows))]
{
let result = unsafe { libc::kill(pid as i32, libc::SIGTERM) };
if result == 0 {
for _ in 0..10 {
std::thread::sleep(std::time::Duration::from_millis(100));
if unsafe { libc::kill(pid as i32, 0) } != 0 {
return Ok(());
}
}
Ok(()) } else {
let errno = std::io::Error::last_os_error();
if errno.raw_os_error() == Some(libc::ESRCH) {
Ok(()) } else {
Err(errno)
}
}
}
}
fn unix_seconds(time: SystemTime) -> u64 {
time.duration_since(SystemTime::UNIX_EPOCH)
.unwrap_or_default()
.as_secs()
}
#[cfg(test)]
mod tests {
use super::*;
use std::ffi::OsString;
use std::path::{Path, PathBuf};
use std::time::Duration;
use once_cell::sync::Lazy;
use tempfile::TempDir;
use tokio::sync::{Mutex, MutexGuard};
static ENV_LOCK: Lazy<Mutex<()>> = Lazy::new(|| Mutex::new(()));
fn project_dir(name: &str) -> TempDir {
let dir = TempDir::with_prefix(name).expect("temp dir");
std::fs::create_dir_all(dir.path().join("src")).expect("src dir");
dir
}
fn test_control_state(home: &Path) -> ControlStateDir {
ControlStateDir::new(home.to_path_buf())
}
fn test_daemon_path(home: &Path, file_name: impl AsRef<Path>) -> PathBuf {
daemon_dir_for(&test_control_state(home))
.expect("create test daemon control-state directory")
.join(file_name)
}
async fn spawn_test_daemon(bind_host: &str, home: &Path) -> anyhow::Result<DaemonHandle> {
let control_state_dir = test_control_state(home);
spawn_daemon_at(bind_host, &control_state_dir).await
}
fn test_daemon_state(home: &Path) -> DaemonState {
DaemonState::with_token_at(establish_daemon_auth_token(), test_control_state(home))
}
async fn env_lock() -> MutexGuard<'static, ()> {
ENV_LOCK.lock().await
}
fn authed_client(handle: &DaemonHandle) -> reqwest::Client {
let token = handle.state.auth_token.clone();
let headers = bearer_headers(&token);
reqwest::Client::builder()
.default_headers(headers)
.build()
.expect("build authed reqwest client")
}
fn bearer_headers(token: &str) -> HeaderMap {
let mut headers = header::HeaderMap::new();
let mut value =
header::HeaderValue::from_str(&format!("Bearer {token}")).expect("valid bearer header");
value.set_sensitive(true);
headers.insert(header::AUTHORIZATION, value);
headers
}
#[tokio::test]
async fn daemon_idle_shutdown_env_parsing() {
let _guard = env_lock().await;
{
let _env = EnvVarGuard::unset(DAEMON_IDLE_SHUTDOWN_ENV);
assert_eq!(daemon_idle_shutdown_from_env(), None);
}
{
let _env = EnvVarGuard::set_str(DAEMON_IDLE_SHUTDOWN_ENV, "0");
assert_eq!(daemon_idle_shutdown_from_env(), None);
}
{
let _env = EnvVarGuard::set_str(DAEMON_IDLE_SHUTDOWN_ENV, "5");
assert_eq!(
daemon_idle_shutdown_from_env(),
Some(Duration::from_secs(60))
);
}
{
let _env = EnvVarGuard::set_str(DAEMON_IDLE_SHUTDOWN_ENV, "soon");
assert_eq!(
daemon_idle_shutdown_from_env(),
Some(Duration::from_secs(DEFAULT_DAEMON_IDLE_SHUTDOWN_SECS))
);
}
}
fn ref_lane_commit(
repository: &git2::Repository,
root: &Path,
rel: &str,
bytes: &[u8],
message: &str,
) {
let full = root.join(rel);
if let Some(parent) = full.parent() {
std::fs::create_dir_all(parent).expect("mkdir");
}
std::fs::write(&full, bytes).expect("write file");
let mut index = repository.index().expect("index");
index
.add_all(["*"], git2::IndexAddOption::DEFAULT, None)
.expect("stage");
index.write().expect("write index");
let tree_id = index.write_tree().expect("write tree");
let tree = repository.find_tree(tree_id).expect("find tree");
let signature =
git2::Signature::now("SymForge Test", "symforge@example.invalid").expect("signature");
let parent = repository
.head()
.ok()
.and_then(|head| head.peel_to_commit().ok());
let parents: Vec<&git2::Commit<'_>> = parent.iter().collect();
repository
.commit(
Some("HEAD"),
&signature,
&signature,
message,
&tree,
&parents,
)
.expect("commit");
}
#[tokio::test]
async fn local_ref_lanes_gate_on_publishes_bare_branch_lane() {
let _env = env_lock().await;
let _gate = EnvVarGuard::set_str(LOCAL_REF_LANES_ENV, "1");
let dir = tempfile::tempdir().expect("tempdir");
let root = dir.path();
let repository = git2::Repository::init(root).expect("init repo");
ref_lane_commit(
&repository,
root,
"src/lib.rs",
b"pub fn a() {}\n",
"initial",
);
let head_commit = repository
.head()
.expect("head")
.peel_to_commit()
.expect("peel");
repository
.branch("bare-lane", &head_commit, false)
.expect("bare branch");
let index: SharedIndex = Arc::new(crate::live_index::SharedIndexHandle::new(
LiveIndex::from_source_files(HashMap::new()),
));
let task = spawn_local_ref_reconcile(Arc::clone(&index), root.to_path_buf())
.expect("gate ON must spawn the reconcile task");
task.await.expect("reconcile task completes");
let set = index.published_source_set();
assert!(
set.sources
.keys()
.any(|id| id.as_str().starts_with("symforge:git-ref:")),
"gate ON publishes at least one git-ref lane: {:?}",
set.sources.keys().map(|id| id.as_str()).collect::<Vec<_>>()
);
}
#[tokio::test]
async fn local_ref_lanes_gate_off_publishes_no_ref_lane() {
let _env = env_lock().await;
let _gate = EnvVarGuard::unset(LOCAL_REF_LANES_ENV);
let dir = tempfile::tempdir().expect("tempdir");
let root = dir.path();
let repository = git2::Repository::init(root).expect("init repo");
ref_lane_commit(
&repository,
root,
"src/lib.rs",
b"pub fn a() {}\n",
"initial",
);
let head_commit = repository
.head()
.expect("head")
.peel_to_commit()
.expect("peel");
repository
.branch("bare-lane", &head_commit, false)
.expect("bare branch");
let index: SharedIndex = Arc::new(crate::live_index::SharedIndexHandle::new(
LiveIndex::from_source_files(HashMap::new()),
));
let before = index.published_source_set().registry_generation;
assert!(
spawn_local_ref_reconcile(Arc::clone(&index), root.to_path_buf()).is_none(),
"gate OFF must not spawn a reconcile task"
);
let set = index.published_source_set();
assert!(
!set.sources
.keys()
.any(|id| id.as_str().starts_with("symforge:git-ref:")),
"gate OFF publishes no git-ref lane"
);
assert_eq!(
set.registry_generation, before,
"gate OFF leaves the published source map untouched"
);
}
#[tokio::test]
async fn local_ref_lanes_env_gate_parsing() {
let _guard = env_lock().await;
{
let _env = EnvVarGuard::unset(LOCAL_REF_LANES_ENV);
assert!(!local_ref_lanes_enabled(), "unset is OFF");
}
for on in ["1", "true", "on", "TRUE", "On", " on "] {
let _env = EnvVarGuard::set_str(LOCAL_REF_LANES_ENV, on);
assert!(local_ref_lanes_enabled(), "{on:?} is ON");
}
for off in ["0", "false", "off", "no", "", "2"] {
let _env = EnvVarGuard::set_str(LOCAL_REF_LANES_ENV, off);
assert!(!local_ref_lanes_enabled(), "{off:?} is OFF");
}
}
#[tokio::test(start_paused = true)]
async fn daemon_idle_shutdown_waits_for_authenticated_activity_then_notifies() {
let _guard = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _home = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let _idle = EnvVarGuard::set_str(DAEMON_IDLE_SHUTDOWN_ENV, "60");
let handle = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn daemon");
let state = Arc::clone(&handle.state);
tokio::task::yield_now().await;
state
.last_activity_at
.store(now_epoch_millis().saturating_sub(60_001), Ordering::Relaxed);
authed_client(&handle)
.get(format!("http://127.0.0.1:{}/v1/projects", handle.port))
.send()
.await
.expect("authenticated request")
.error_for_status()
.expect("authenticated status");
tokio::time::advance(Duration::from_secs(15)).await;
tokio::task::yield_now().await;
assert!(
tokio::time::timeout(Duration::from_millis(1), state.idle_shutdown.notified())
.await
.is_err(),
"authenticated activity must defer idle shutdown"
);
state
.last_activity_at
.store(now_epoch_millis().saturating_sub(60_001), Ordering::Relaxed);
tokio::time::advance(Duration::from_secs(15)).await;
tokio::task::yield_now().await;
tokio::time::timeout(Duration::from_millis(1), state.idle_shutdown.notified())
.await
.expect("idle reaper must request shutdown");
handle.reaper_task.abort();
let _ = handle.shutdown_tx.send(());
handle.server_task.await.expect("daemon server task");
}
#[tokio::test(start_paused = true)]
async fn daemon_idle_shutdown_waits_for_in_flight_authenticated_request() {
let _guard = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _home = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let _idle = EnvVarGuard::set_str(DAEMON_IDLE_SHUTDOWN_ENV, "60");
let handle = spawn_daemon("127.0.0.1").await.expect("spawn daemon");
let state = Arc::clone(&handle.state);
tokio::task::yield_now().await;
let activity = authorize_daemon_request(&state, &bearer_headers(&state.auth_token))
.expect("authenticated request guard");
state
.last_activity_at
.store(now_epoch_millis().saturating_sub(60_001), Ordering::Relaxed);
tokio::time::advance(Duration::from_secs(15)).await;
tokio::task::yield_now().await;
assert!(
tokio::time::timeout(Duration::from_millis(1), state.idle_shutdown.notified())
.await
.is_err(),
"idle shutdown must not fire while an authenticated handler is still in flight"
);
drop(activity);
assert_eq!(
state.active_authenticated_requests.load(Ordering::Relaxed),
0
);
handle.reaper_task.abort();
let _ = handle.shutdown_tx.send(());
handle.server_task.await.expect("daemon server task");
}
#[test]
fn project_instance_load_consumes_exported_team_artifact() {
let tmp = TempDir::new().expect("tempdir");
std::fs::write(tmp.path().join("main.rs"), b"fn main() { helper(); }\n").unwrap();
std::fs::write(tmp.path().join("helper.rs"), b"pub fn helper() {}\n").unwrap();
let fresh = live_index::LiveIndex::load(tmp.path()).expect("cold load");
{
let guard = fresh.read();
let root = dunce::canonicalize(tmp.path()).expect("canonical root");
let placement = crate::domain::StatePlacement::ProjectLocal {
directory: crate::domain::ProjectStateDir::new(root.join(".symforge")),
};
live_index::persist::export_artifact(
&guard,
&root,
crate::domain::SourceAccessMode::NormalProject,
&placement,
&crate::domain::CapabilityStatus::Available,
)
.expect("export artifact");
}
assert!(
!tmp.path().join(".symforge").join("index.bin").exists(),
"only the .zst team artifact should exist for the clone scenario"
);
assert!(
tmp.path().join(".symforge").join("index.bin.zst").exists(),
"the exported team artifact must be present"
);
let project = ProjectInstance::load(tmp.path()).expect("project load");
let guard = project.index.read();
assert_eq!(
guard.load_source(),
crate::live_index::store::IndexLoadSource::SnapshotRestore,
"daemon bootstrap must consume the team artifact (SnapshotRestore), \
not fall back to a cold full scan (FreshLoad)"
);
assert!(
guard.get_file("main.rs").is_some(),
"the artifact-restored index must serve the indexed files"
);
}
#[test]
fn daemon_sessions_share_one_project_curation_coordinator() {
let tmp = TempDir::new().expect("tempdir");
std::fs::write(tmp.path().join("main.rs"), b"fn main() {}\n").unwrap();
let slot = ProjectSlot::new(ProjectInstance::load(tmp.path()).expect("project load"));
let left = slot.server_for_session();
let right = slot.server_for_session();
assert!(
Arc::ptr_eq(&left.curation_coordinator, &right.curation_coordinator),
"all daemon sessions for one project must serialize through one curation coordinator"
);
}
#[test]
fn constant_time_eq_accepts_equal_and_rejects_unequal() {
assert!(constant_time_eq(b"sekret-token", b"sekret-token"));
assert!(constant_time_eq(b"", b""));
assert!(!constant_time_eq(b"short", b"longer-token"));
assert!(!constant_time_eq(b"longer-token", b"short"));
assert!(!constant_time_eq(b"sekret-token", b"sekret-tokeX"));
assert!(!constant_time_eq(b"sekret-token", b"Xekret-token"));
}
#[test]
fn constant_time_eq_has_no_early_out_on_first_mismatch() {
let base = vec![0u8; 64];
let mut differ_first = base.clone();
differ_first[0] = 1;
assert!(!constant_time_eq(&base, &differ_first));
let mut differ_last = base.clone();
differ_last[63] = 1;
assert!(!constant_time_eq(&base, &differ_last));
assert!(constant_time_eq(&base, &base.clone()));
}
#[test]
fn connection_surface_header_resolves_profile_and_ignores_junk() {
use crate::protocol::surface_probe::{CONNECTION_SURFACE_HEADER, SurfaceProfile};
let mut headers = HeaderMap::new();
assert_eq!(connection_surface_from_headers(&headers), None);
headers.insert(CONNECTION_SURFACE_HEADER, "compact".parse().unwrap());
assert_eq!(
connection_surface_from_headers(&headers),
Some(SurfaceProfile::Compact)
);
headers.insert(CONNECTION_SURFACE_HEADER, "full".parse().unwrap());
assert_eq!(
connection_surface_from_headers(&headers),
Some(SurfaceProfile::Full)
);
headers.insert(CONNECTION_SURFACE_HEADER, "garbage".parse().unwrap());
assert_eq!(connection_surface_from_headers(&headers), None);
}
#[test]
fn authorize_daemon_request_constant_time_token_check() {
fn state_with_token(token: &str) -> SharedDaemonState {
Arc::new(DaemonState::with_token(token.to_string()))
}
fn raw_auth_headers(value: &str) -> HeaderMap {
let mut headers = HeaderMap::new();
headers.insert(
header::AUTHORIZATION,
header::HeaderValue::from_str(value).expect("valid header value"),
);
headers
}
let state = state_with_token("the-real-token-value");
assert!(
authorize_daemon_request(&state, &raw_auth_headers("Bearer the-real-token-value"))
.is_ok()
);
assert_eq!(
state.active_authenticated_requests.load(Ordering::Relaxed),
0,
"successful auth guard should decrement on drop"
);
assert!(
matches!(
authorize_daemon_request(&state, &raw_auth_headers("Bearer the-real-token-WRONG")),
Err(StatusCode::UNAUTHORIZED)
),
"wrong token must 401"
);
assert!(
matches!(
authorize_daemon_request(&state, &raw_auth_headers("Bearer ")),
Err(StatusCode::UNAUTHORIZED)
),
"empty token must 401"
);
assert!(
matches!(
authorize_daemon_request(&state, &HeaderMap::new()),
Err(StatusCode::UNAUTHORIZED)
),
"missing Authorization must 401"
);
assert!(
matches!(
authorize_daemon_request(&state, &raw_auth_headers("Basic the-real-token-value")),
Err(StatusCode::UNAUTHORIZED)
),
"wrong scheme must 401"
);
}
async fn wait_for_path_absent(path: &Path) {
let deadline = tokio::time::Instant::now() + Duration::from_secs(2);
while path.exists() {
if tokio::time::Instant::now() >= deadline {
break;
}
tokio::time::sleep(Duration::from_millis(25)).await;
}
}
async fn spawn_fake_health_server(
health: DaemonHealth,
) -> (u16, tokio::sync::oneshot::Sender<()>) {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind fake daemon");
let port = listener.local_addr().expect("listener addr").port();
let app = Router::new().route(
"/health",
get({
let health = health.clone();
move || {
let health = health.clone();
async move { Json(health) }
}
}),
);
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;
});
(port, shutdown_tx)
}
struct EnvVarGuard {
key: &'static str,
previous: Option<OsString>,
}
#[allow(unsafe_code)] impl EnvVarGuard {
fn set(key: &'static str, value: &std::path::Path) -> Self {
let previous = std::env::var_os(key);
unsafe {
std::env::set_var(key, value);
}
Self { key, previous }
}
fn set_str(key: &'static str, value: &str) -> Self {
let previous = std::env::var_os(key);
unsafe {
std::env::set_var(key, value);
}
Self { key, previous }
}
fn unset(key: &'static str) -> Self {
let previous = std::env::var_os(key);
unsafe {
std::env::remove_var(key);
}
Self { key, previous }
}
}
#[allow(unsafe_code)] impl Drop for EnvVarGuard {
fn drop(&mut self) {
match &self.previous {
Some(previous) => unsafe {
std::env::set_var(self.key, previous);
},
None => unsafe {
std::env::remove_var(self.key);
},
}
}
}
struct CwdGuard {
previous: PathBuf,
}
impl CwdGuard {
fn set(path: &Path) -> Self {
let previous = std::env::current_dir().expect("current dir");
std::env::set_current_dir(path).expect("set current dir");
Self { previous }
}
}
impl Drop for CwdGuard {
fn drop(&mut self) {
if std::env::set_current_dir(&self.previous).is_err() {
std::env::set_current_dir(env!("CARGO_MANIFEST_DIR"))
.expect("manifest dir must be a valid cwd fallback");
}
}
}
#[tokio::test]
async fn test_daemon_bind_policy_rejects_non_loopback_without_opt_in() {
let _env_lock = env_lock().await;
let _bind_guard = EnvVarGuard::set_str(DAEMON_BIND_ENV, "0.0.0.0");
let _allow_guard = EnvVarGuard::unset(DAEMON_ALLOW_NON_LOOPBACK_ENV);
let error = resolve_daemon_bind_host("127.0.0.1")
.expect_err("non-loopback bind must require explicit opt-in");
let message = error.to_string();
assert!(
message.contains("refusing non-loopback daemon bind"),
"unexpected bind rejection: {message}"
);
assert!(
message.contains(DAEMON_ALLOW_NON_LOOPBACK_ENV),
"rejection should name the explicit opt-in env var: {message}"
);
}
#[tokio::test]
async fn test_daemon_bind_policy_allows_non_loopback_with_explicit_opt_in() {
let _env_lock = env_lock().await;
let _bind_guard = EnvVarGuard::set_str(DAEMON_BIND_ENV, "0.0.0.0");
let _allow_guard = EnvVarGuard::set_str(DAEMON_ALLOW_NON_LOOPBACK_ENV, "1");
let resolved = resolve_daemon_bind_host("127.0.0.1")
.expect("explicit opt-in should allow non-loopback bind");
assert_eq!(resolved, "0.0.0.0");
}
#[test]
fn test_open_same_root_reuses_project_instance() {
let project = project_dir("symforge-daemon-a");
let state = DaemonState::new();
let first = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "claude".to_string(),
pid: Some(100),
})
.expect("first session");
let second = state
.open_project_session(OpenProjectRequest {
project_root: project.path().join(".").display().to_string(),
client_name: "codex".to_string(),
pid: Some(200),
})
.expect("second session");
assert_eq!(first.project_id, second.project_id);
assert_ne!(first.session_id, second.session_id);
let projects = state.list_projects();
assert_eq!(projects.len(), 1);
assert_eq!(projects[0].session_count, 2);
}
#[test]
fn test_open_distinct_roots_creates_distinct_projects() {
let project_a = project_dir("symforge-daemon-b");
let project_b = project_dir("symforge-daemon-c");
let state = DaemonState::new();
let first = state
.open_project_session(OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "claude".to_string(),
pid: None,
})
.expect("first project");
let second = state
.open_project_session(OpenProjectRequest {
project_root: project_b.path().display().to_string(),
client_name: "codex".to_string(),
pid: None,
})
.expect("second project");
assert_ne!(first.project_id, second.project_id);
assert_eq!(state.list_projects().len(), 2);
assert_eq!(state.health().session_count, 2);
}
fn session_seeded_base(state: &DaemonState, session_id: &str) -> Arc<IndexBase> {
let sessions = state.sessions.read();
let session = sessions.get(session_id).expect("session present");
let working_set = session.working_set.read();
assert_eq!(
working_set.len(),
1,
"Phase 1 seeds exactly one working-set entry"
);
let entry = working_set
.get(&session.active_project_id)
.expect("seeded entry for the active project");
Arc::clone(&entry.base)
}
#[test]
fn test_open_same_root_twice_shares_interned_base() {
let project = project_dir("symforge-daemon-base-intern");
let state = DaemonState::new();
let first = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "claude".to_string(),
pid: Some(11),
})
.expect("first session");
let second = state
.open_project_session(OpenProjectRequest {
project_root: project.path().join(".").display().to_string(),
client_name: "codex".to_string(),
pid: Some(22),
})
.expect("second session");
assert_eq!(
first.project_id, second.project_id,
"same canonical root -> same project"
);
let base_first = session_seeded_base(&state, &first.session_id);
let base_second = session_seeded_base(&state, &second.session_id);
assert!(
Arc::ptr_eq(&base_first, &base_second),
"two sessions on the same (root, commit) must share one Arc<IndexBase>"
);
assert_eq!(
state.bases.read().len(),
1,
"one canonical root -> one interned base"
);
}
#[test]
fn test_open_distinct_roots_intern_distinct_bases() {
let project_a = project_dir("symforge-daemon-base-distinct-a");
let project_b = project_dir("symforge-daemon-base-distinct-b");
let state = DaemonState::new();
let first = state
.open_project_session(OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "claude".to_string(),
pid: None,
})
.expect("project a session");
let second = state
.open_project_session(OpenProjectRequest {
project_root: project_b.path().display().to_string(),
client_name: "codex".to_string(),
pid: None,
})
.expect("project b session");
let base_a = session_seeded_base(&state, &first.session_id);
let base_b = session_seeded_base(&state, &second.session_id);
assert!(
!Arc::ptr_eq(&base_a, &base_b),
"distinct roots must NOT share a base"
);
assert_ne!(
base_a.key, base_b.key,
"distinct roots -> distinct BaseKeys"
);
assert_eq!(
state.bases.read().len(),
2,
"two roots -> two interned bases"
);
}
#[test]
fn test_gc_orphaned_bases_evicts_orphan_keeps_live() {
use crate::live_index::store::LiveIndex;
use crate::live_index::view::{CommitId, WorkingSet};
let state = DaemonState::new();
let root = "/synthetic/gc-root";
let orphan_key = BaseKey::new(root, CommitId::Sha("old-commit".to_string()));
state.bases.write().insert(
orphan_key.clone(),
Arc::new(IndexBase::new(
orphan_key.clone(),
Arc::new(LiveIndex::empty_live_index()),
1,
)),
);
let live_key = BaseKey::new(root, CommitId::Sha("new-commit".to_string()));
let live_base = Arc::new(IndexBase::new(
live_key.clone(),
Arc::new(LiveIndex::empty_live_index()),
2,
));
state
.bases
.write()
.insert(live_key.clone(), Arc::clone(&live_base));
let working_set = Arc::new(RwLock::new(WorkingSet::new()));
working_set.write().add("proj", Arc::clone(&live_base));
drop(live_base);
{
let bases = state.bases.read();
assert!(
bases.contains_key(&orphan_key),
"precondition: orphan must be present before GC (proves the leak)"
);
assert_eq!(bases.len(), 2, "precondition: both bases interned");
assert_eq!(
Arc::strong_count(bases.get(&orphan_key).unwrap()),
1,
"orphan must be map-only (the eviction signal)"
);
assert_eq!(
Arc::strong_count(bases.get(&live_key).unwrap()),
2,
"live base is held by map + working-set entry"
);
}
state.gc_orphaned_bases();
let bases = state.bases.read();
assert!(
!bases.contains_key(&orphan_key),
"GC must evict the orphaned (map-only) base"
);
assert!(
bases.contains_key(&live_key),
"GC must NOT evict a base a live working set still references"
);
assert_eq!(bases.len(), 1, "only the orphan is removed");
let table_live = bases.get(&live_key).unwrap();
let ws = working_set.read();
let entry = ws.get("proj").expect("live entry present");
assert!(
Arc::ptr_eq(table_live, &entry.base),
"SC-002: survivor is the same shared Arc the working set holds"
);
}
#[test]
fn test_close_last_session_gcs_orphaned_base() {
let project = project_dir("symforge-daemon-close-gc");
let state = DaemonState::new();
let opened = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "claude".to_string(),
pid: None,
})
.expect("session");
assert_eq!(
state.bases.read().len(),
1,
"open interns one base for the root"
);
state
.close_session(&opened.session_id)
.expect("close the only session");
assert_eq!(
state.bases.read().len(),
0,
"close_session must GC the base no session references anymore"
);
}
#[test]
fn test_resolve_targets_contract() {
let active = "project-active";
assert_eq!(
resolve_targets(None, None, active).unwrap(),
Targets::One(active.to_string())
);
assert_eq!(
resolve_targets(Some(active), None, active).unwrap(),
Targets::One(active.to_string())
);
assert_eq!(
resolve_targets(Some("project-other"), None, active).unwrap(),
Targets::One("project-other".to_string())
);
assert_eq!(
resolve_targets(None, Some(&["*".to_string()]), active).unwrap(),
Targets::All
);
assert_eq!(
resolve_targets(
None,
Some(&["project-a".to_string(), "project-b".to_string()]),
active
)
.unwrap(),
Targets::Subset(vec!["project-a".to_string(), "project-b".to_string()])
);
assert!(
resolve_targets(Some("project-a"), Some(&["project-b".to_string()]), active).is_err()
);
assert!(resolve_targets(None, Some(&[]), active).is_err());
let err = resolve_targets(Some("E:/project/symforge"), None, active).unwrap_err();
assert!(
err.contains("index_folder") && err.contains("add"),
"path-in-project error must point at index_folder(add:true): {err}"
);
assert!(resolve_targets(Some("/abs/path"), None, active).is_err());
assert!(resolve_targets(None, Some(&["src/lib.rs".to_string()]), active).is_err());
assert!(resolve_targets(Some(" "), None, active).is_err());
}
#[test]
fn test_targets_is_single_active() {
let active = "project-active";
assert!(targets_is_single_active(
&Targets::One(active.to_string()),
active
));
assert!(!targets_is_single_active(
&Targets::One("project-other".to_string()),
active
));
assert!(!targets_is_single_active(&Targets::All, active));
assert!(!targets_is_single_active(
&Targets::Subset(vec![active.to_string()]),
active
));
}
#[test]
fn test_set_active_and_remove_project_management() {
let project_a = project_dir("symforge-mgmt-a");
let project_b = project_dir("symforge-mgmt-b");
std::fs::write(project_b.path().join("src").join("b.rs"), "fn b() {}\n")
.expect("write source b");
let state = DaemonState::new();
let opened = state
.open_project_session(OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "mgmt".to_string(),
pid: None,
})
.expect("open A");
let active_a = opened.project_id.clone();
state
.index_folder_for_session(
&opened.session_id,
IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: Some(true),
allow_protected_root: None,
},
)
.expect("additive open B");
let project_b_id =
project_key(&canonical_project_root(project_b.path()).expect("canonical b"));
{
let sessions = state.sessions.read();
let session = sessions.get(&opened.session_id).expect("session");
let ws = session.working_set.read();
assert_eq!(ws.len(), 2, "working set holds A and B");
assert_eq!(session.active_project_id, active_a, "A still active");
assert!(ws.get(&active_a).is_some());
assert!(ws.get(&project_b_id).is_some());
}
assert!(
!state.set_active_project(&opened.session_id, "project-not-open"),
"activating a non-open project must fail"
);
assert!(
state.set_active_project(&opened.session_id, &project_b_id),
"activating an open project must succeed"
);
assert_eq!(
state
.sessions
.read()
.get(&opened.session_id)
.unwrap()
.active_project_id,
project_b_id,
"B is now active"
);
assert!(
!state.remove_project_from_session(&opened.session_id, &project_b_id),
"removing the active project must be refused"
);
assert!(
state.remove_project_from_session(&opened.session_id, &active_a),
"removing a non-active open project must succeed"
);
{
let sessions = state.sessions.read();
let ws = sessions.get(&opened.session_id).unwrap().working_set.read();
assert_eq!(ws.len(), 1, "only B remains");
assert!(ws.get(&active_a).is_none(), "A removed");
assert!(ws.get(&project_b_id).is_some(), "B remains");
}
assert!(
!state
.list_projects()
.iter()
.any(|p| p.project_id == active_a),
"project A removed after its last session reference dropped"
);
let _ = state.close_session(&opened.session_id);
}
#[test]
fn test_index_folder_additive_keeps_active_and_adds_to_working_set() {
let project_a = project_dir("symforge-additive-a");
let project_b = project_dir("symforge-additive-b");
std::fs::write(project_b.path().join("src").join("b.rs"), "fn b() {}\n")
.expect("write source b");
let state = DaemonState::new();
let opened = state
.open_project_session(OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "additive".to_string(),
pid: None,
})
.expect("open A");
let active_a = opened.project_id.clone();
let output = state
.index_folder_for_session(
&opened.session_id,
IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: Some(true),
allow_protected_root: None,
},
)
.expect("additive open B");
assert!(
output.contains("added to working set"),
"additive open should report working-set addition: {output}"
);
let sessions = state.sessions.read();
let session = sessions.get(&opened.session_id).expect("session");
assert_eq!(session.active_project_id, active_a, "A still active");
let ws = session.working_set.read();
assert_eq!(ws.len(), 2, "working set has A and B after additive open");
for entry in ws.iter() {
assert_eq!(
entry.overlay.delta_count(),
0,
"no overlay write on additive open (project {})",
entry.project_id
);
}
}
#[test]
fn test_runtime_for_target_resolution_contract() {
let project_a = project_dir("symforge-resolver-home-a");
let parent_one = TempDir::new().expect("parent one");
let parent_two = TempDir::new().expect("parent two");
let same_name_one = parent_one.path().join("samename");
let same_name_two = parent_two.path().join("samename");
for root in [&same_name_one, &same_name_two] {
std::fs::create_dir_all(root.join("src")).expect("create src");
std::fs::write(root.join("src").join("lib.rs"), "fn f() {}\n").expect("write src");
}
let state = DaemonState::new();
let opened = state
.open_project_session(OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "resolver".to_string(),
pid: None,
})
.expect("open home A");
for root in [&same_name_one, &same_name_two] {
state
.index_folder_for_session(
&opened.session_id,
IndexFolderInput {
path: root.display().to_string(),
idempotency_key: None,
add: None,
allow_protected_root: None,
},
)
.expect("open same-name project");
}
let id_one = project_key(&canonical_project_root(&same_name_one).expect("canonical 1"));
let id_two = project_key(&canonical_project_root(&same_name_two).expect("canonical 2"));
let home = state
.runtime_for_target(&opened.session_id, None)
.expect("home runtime");
assert_eq!(home.project_id, opened.project_id);
let by_id = state
.runtime_for_target(&opened.session_id, Some(&id_one))
.expect("runtime by id");
assert_eq!(by_id.project_id, id_one);
let by_name = state
.runtime_for_target(&opened.session_id, Some(&opened.project_name))
.expect("runtime by unique name");
assert_eq!(by_name.project_id, opened.project_id);
let ambiguous = match state.runtime_for_target(&opened.session_id, Some("samename")) {
Err(message) => message,
Ok(_) => panic!("ambiguous name must not resolve"),
};
assert!(
ambiguous.contains("ambiguous")
&& ambiguous.contains(&id_one)
&& ambiguous.contains(&id_two),
"ambiguity error must name candidates: {ambiguous}"
);
let unknown = match state.runtime_for_target(&opened.session_id, Some("nope")) {
Err(message) => message,
Ok(_) => panic!("unknown selector must not resolve"),
};
assert!(
unknown.contains("not open") && unknown.contains(&opened.project_id),
"unknown-selector error must list open projects: {unknown}"
);
}
#[test]
fn test_default_index_folder_open_keeps_home_and_adds_to_working_set() {
let project_a = project_dir("symforge-reseed-a");
let project_b = project_dir("symforge-reseed-b");
std::fs::write(project_b.path().join("src").join("b.rs"), "fn b() {}\n")
.expect("write source b");
let state = DaemonState::new();
let opened = state
.open_project_session(OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "reseed".to_string(),
pid: None,
})
.expect("open A");
let active_a = opened.project_id.clone();
let output = state
.index_folder_for_session(
&opened.session_id,
IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: None,
allow_protected_root: None,
},
)
.expect("open B");
let project_b_id =
project_key(&canonical_project_root(project_b.path()).expect("canonical b"));
assert!(
output.contains(&format!("project_id={project_b_id}")),
"receipt must identify the opened project: {output}"
);
assert!(
output.contains("checkpoint=written"),
"successful daemon reload must report its checkpoint: {output}"
);
let sessions = state.sessions.read();
let session = sessions.get(&opened.session_id).expect("session");
assert_eq!(
session.active_project_id, active_a,
"default index_folder must preserve immutable home A"
);
let ws = session.working_set.read();
assert_eq!(ws.len(), 2, "default open must keep A and add B");
assert!(
ws.get(&active_a).is_some(),
"home project A must stay in the working set"
);
let entry = ws
.get(&project_b_id)
.expect("working set gains newly opened project B");
assert_eq!(
entry.overlay.delta_count(),
0,
"opened-project overlay must be empty"
);
assert!(
entry.overlay.is_valid_against(&entry.base),
"re-seeded overlay fenced to its base"
);
}
#[test]
fn daemon_index_folder_reconciles_existing_root_gitignore() {
let home = project_dir("symforge-hygiene-home");
let target = project_dir("symforge-hygiene-target");
std::fs::create_dir(target.path().join(".git")).expect("create git metadata marker");
std::fs::write(target.path().join(".gitignore"), b"target/\r\n")
.expect("write root gitignore");
std::fs::write(
target.path().join("src").join("lib.rs"),
"fn indexed() {}\n",
)
.expect("write target source");
let state = DaemonState::new();
let opened = state
.open_project_session(OpenProjectRequest {
project_root: home.path().display().to_string(),
client_name: "gitignore-hygiene".to_string(),
pid: None,
})
.expect("open home");
let receipt = state
.index_folder_for_session(
&opened.session_id,
IndexFolderInput {
path: target.path().display().to_string(),
idempotency_key: None,
add: None,
allow_protected_root: None,
},
)
.expect("open target");
assert!(
receipt.contains("gitignore_hygiene=effective changed=true"),
"daemon indexing must report the hygiene mutation: {receipt}"
);
assert_eq!(
std::fs::read(target.path().join(".gitignore")).expect("read reconciled gitignore"),
b"target/\r\n/.symforge/\r\n",
"daemon indexing must preserve existing bytes and newline style"
);
}
#[test]
fn test_concurrent_session_lifecycle_no_deadlock_or_panic() {
use std::sync::Arc as StdArc;
let shared_roots: Vec<TempDir> = (0..4)
.map(|i| project_dir(&format!("symforge-stress-shared-{i}")))
.collect();
let shared_root_paths: StdArc<Vec<String>> = StdArc::new(
shared_roots
.iter()
.map(|d| d.path().display().to_string())
.collect(),
);
let state = StdArc::new(DaemonState::new());
const THREADS: usize = 8;
const ITERS: usize = 40;
let mut handles = Vec::with_capacity(THREADS);
for t in 0..THREADS {
let state = StdArc::clone(&state);
let shared_root_paths = StdArc::clone(&shared_root_paths);
let private_root = project_dir(&format!("symforge-stress-private-{t}"));
let private_path = private_root.path().display().to_string();
let retarget_root = project_dir(&format!("symforge-stress-retarget-{t}"));
let retarget_path = retarget_root.path().display().to_string();
handles.push(std::thread::spawn(move || {
let _private_root = private_root;
let _retarget_root = retarget_root;
for i in 0..ITERS {
let root = if i % 2 == 0 {
shared_root_paths[(t + i) % shared_root_paths.len()].clone()
} else {
private_path.clone()
};
let opened = state
.open_project_session(OpenProjectRequest {
project_root: root.clone(),
client_name: "stress".to_string(),
pid: Some((t * 1000 + i) as u32),
})
.expect(
"open_project_session must succeed under contention (D17 fail-never)",
);
let _ = state.session_runtime(&opened.session_id);
let _ = state.health();
let _ = state.list_projects();
let _ = state.list_sessions(&opened.project_id);
let _ = state.index_folder_for_session(
&opened.session_id,
IndexFolderInput {
path: retarget_path.clone(),
idempotency_key: None,
add: Some(i % 2 == 1),
allow_protected_root: None,
},
);
let _ = state.close_session(&opened.session_id);
}
}));
}
for handle in handles {
handle.join().expect("stress worker thread panicked");
}
drop(shared_roots);
assert_eq!(
state.health().session_count,
0,
"all sessions closed after the stress loop"
);
assert!(
state.list_projects().is_empty(),
"all projects removed after their last session closed"
);
}
#[tokio::test]
async fn test_index_folder_for_session_refuses_sensitive_root() {
let _guard = env_lock().await;
let state_home = TempDir::new().expect("private user-local state base");
let _home = EnvVarGuard::set("SYMFORGE_HOME", state_home.path());
let project = project_dir("symforge-daemon-sensitive");
let state = DaemonState::new();
let opened = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "claude".to_string(),
pid: None,
})
.expect("session");
let fixture = TempDir::new().expect("protected-root fixture parent");
let sensitive = fixture.path().join("System32");
std::fs::create_dir(&sensitive).expect("create modeled protected root");
std::fs::write(
sensitive.join("lib.rs"),
"pub fn protected_daemon_symbol() {}\n",
)
.expect("write protected source");
let result = state
.index_folder_for_session(
&opened.session_id,
IndexFolderInput {
path: sensitive.display().to_string(),
idempotency_key: None,
add: None,
allow_protected_root: None,
},
)
.expect("refusal must be a clean Ok response, never an Err or panic");
assert!(
result.contains("protected_root_requires_explicit_override"),
"daemon path must refuse the modeled protected root, got: {result}"
);
let projects = state.list_projects();
assert_eq!(
projects.len(),
1,
"refusal must not create a project for the sensitive root"
);
let indexed = state
.index_folder_for_session(
&opened.session_id,
IndexFolderInput {
path: sensitive.display().to_string(),
idempotency_key: None,
add: None,
allow_protected_root: Some(true),
},
)
.expect("direct protected authority should produce a clean result");
assert!(
indexed.contains("Indexed 1 files"),
"daemon override should index the exact protected root: {indexed}"
);
assert!(!sensitive.join(".symforge").exists());
let canonical = sensitive.canonicalize().unwrap();
assert!(
state_home
.path()
.join("projects")
.join(project_key(&canonical))
.is_dir(),
"explicit protected daemon state should be user-local"
);
}
#[tokio::test]
async fn protected_membership_is_per_session_and_requires_each_direct_override() {
let _guard = env_lock().await;
let state_home = TempDir::new().expect("private user-local state base");
let _home = EnvVarGuard::set("SYMFORGE_HOME", state_home.path());
let home_a = project_dir("symforge-protected-session-a");
let home_b = project_dir("symforge-protected-session-b");
let state = DaemonState::new();
let session_a = state
.open_project_session(OpenProjectRequest {
project_root: home_a.path().display().to_string(),
client_name: "protected-a".to_string(),
pid: None,
})
.expect("open session A");
let session_b = state
.open_project_session(OpenProjectRequest {
project_root: home_b.path().display().to_string(),
client_name: "protected-b".to_string(),
pid: None,
})
.expect("open session B");
let fixture = TempDir::new().expect("protected-root fixture parent");
let protected = fixture.path().join("System32");
std::fs::create_dir(&protected).expect("create modeled protected root");
std::fs::write(
protected.join("lib.rs"),
"pub fn protected_session_symbol() {}\n",
)
.expect("write protected source");
let protected_id = project_key(&protected.canonicalize().unwrap());
let opened_a = state
.index_folder_for_session(
&session_a.session_id,
IndexFolderInput {
path: protected.display().to_string(),
idempotency_key: None,
add: Some(true),
allow_protected_root: Some(true),
},
)
.expect("session A direct protected open");
assert!(opened_a.contains("Indexed 1 files"), "{opened_a}");
let protected_name = {
let projects = state.projects.read();
let slot = projects.get(&protected_id).expect("shared protected slot");
slot.metadata.read().project_name.clone()
};
{
let sessions = state.sessions.read();
assert!(
sessions
.get(&session_a.session_id)
.unwrap()
.working_set
.read()
.get(&protected_id)
.is_some(),
"the directly authorized session must gain membership"
);
assert!(
sessions
.get(&session_b.session_id)
.unwrap()
.working_set
.read()
.get(&protected_id)
.is_none(),
"another session must not inherit protected membership"
);
}
assert!(
!state.set_active_project(&session_b.session_id, &protected_id),
"a global project id must not grant session membership"
);
assert!(
state
.runtime_for_target(&session_b.session_id, Some(&protected_id))
.is_err(),
"a protected project id must not address another session's membership"
);
assert!(
state
.runtime_for_target(&session_b.session_id, Some(&protected_name))
.is_err(),
"a protected project alias must not address another session's membership"
);
let refused_b = state
.index_folder_for_session(
&session_b.session_id,
IndexFolderInput {
path: protected.display().to_string(),
idempotency_key: None,
add: Some(true),
allow_protected_root: None,
},
)
.expect("missing override is a typed refusal");
assert!(
refused_b.contains("protected_root_requires_explicit_override"),
"{refused_b}"
);
assert!(
state
.runtime_for_target(&session_b.session_id, Some(&protected_id))
.is_err(),
"a refused request must not attach protected membership"
);
let opened_b = state
.index_folder_for_session(
&session_b.session_id,
IndexFolderInput {
path: protected.display().to_string(),
idempotency_key: None,
add: Some(true),
allow_protected_root: Some(true),
},
)
.expect("session B direct protected open");
assert!(opened_b.contains("Indexed 1 files"), "{opened_b}");
assert!(
state
.runtime_for_target(&session_b.session_id, Some(&protected_id))
.is_ok(),
"session B gains membership only after its own direct override"
);
let projects = state.projects.read();
let protected_slot = projects.get(&protected_id).expect("one protected slot");
let protected_meta = protected_slot.metadata.read();
assert_eq!(protected_meta.session_ids.len(), 2);
assert!(protected_meta.session_ids.contains(&session_a.session_id));
assert!(protected_meta.session_ids.contains(&session_b.session_id));
}
#[tokio::test]
async fn l_r11_second_session_cannot_reach_protected_project_via_wildcard_or_ref_mapping() {
let _guard = env_lock().await;
let state_home = TempDir::new().expect("private user-local state base");
let _home = EnvVarGuard::set("SYMFORGE_HOME", state_home.path());
let home_a = project_dir("symforge-l-r11-session-a");
let home_b = project_dir("symforge-l-r11-session-b");
let state = DaemonState::new();
let session_a = state
.open_project_session(OpenProjectRequest {
project_root: home_a.path().display().to_string(),
client_name: "l-r11-a".to_string(),
pid: None,
})
.expect("open session A");
let session_b = state
.open_project_session(OpenProjectRequest {
project_root: home_b.path().display().to_string(),
client_name: "l-r11-b".to_string(),
pid: None,
})
.expect("open session B");
let fixture = TempDir::new().expect("protected-root fixture parent");
let protected = fixture.path().join("System32");
std::fs::create_dir(&protected).expect("create modeled protected root");
std::fs::write(
protected.join("guide.md"),
"# Protected Guide\n\nThe orbital lattice resonates across the protected source.\n",
)
.expect("write protected knowledge doc");
let protected_id = project_key(&protected.canonicalize().unwrap());
let opened_a = state
.index_folder_for_session(
&session_a.session_id,
IndexFolderInput {
path: protected.display().to_string(),
idempotency_key: None,
add: Some(true),
allow_protected_root: Some(true),
},
)
.expect("session A direct protected open");
assert!(opened_a.contains("Indexed"), "{opened_a}");
let query = || SearchKnowledgeInput {
query: "orbital lattice".to_string(),
path_prefix: None,
source_scope: None,
authority_scope: None,
project: None,
projects: None,
limit: None,
max_tokens: None,
};
let runtime_b = state
.runtime_for_target(&session_b.session_id, None)
.expect("session B home runtime");
assert!(
matches!(
resolve_targets(None, Some(&["*".to_string()]), &runtime_b.project_id),
Ok(Targets::All)
),
"projects=[\"*\"] must resolve to Targets::All"
);
assert!(
!runtime_b.project_indexes.contains_key(&protected_id),
"projects=[\"*\"] (Targets::All = project_indexes.keys()) must NOT include \
another session's protected project"
);
let wildcard = execute_cross_project_knowledge(
query(),
Targets::All,
&runtime_b.project_indexes,
&runtime_b.server,
)
.expect("wildcard over session B's own projects succeeds");
assert!(
!wildcard.contains(protected_id.as_str()),
"the protected project must not appear in a second session's wildcard scope: {wildcard}"
);
for targets in [
Targets::One(protected_id.clone()),
Targets::Subset(vec![protected_id.clone()]),
] {
let refused = execute_cross_project_knowledge(
query(),
targets,
&runtime_b.project_indexes,
&runtime_b.server,
)
.expect_err("a protected project the session never opened is not addressable");
assert!(
refused.to_string().contains("project not open"),
"{refused}"
);
}
let opened_b = state
.index_folder_for_session(
&session_b.session_id,
IndexFolderInput {
path: protected.display().to_string(),
idempotency_key: None,
add: Some(true),
allow_protected_root: Some(true),
},
)
.expect("session B direct protected open");
assert!(opened_b.contains("Indexed"), "{opened_b}");
let runtime_b2 = state
.runtime_for_target(&session_b.session_id, None)
.expect("session B home runtime after its own override");
assert!(
runtime_b2.project_indexes.contains_key(&protected_id),
"session B gains wildcard-addressable membership only after its own direct override"
);
execute_cross_project_knowledge(
query(),
Targets::One(protected_id.clone()),
&runtime_b2.project_indexes,
&runtime_b2.server,
)
.expect("session B can address the protected project after its own direct override");
}
fn cross_project_current_and_ref_lanes() -> (TempDir, TempDir, SharedIndex) {
let current_dir = tempfile::tempdir().expect("current tempdir");
let current_repo = git2::Repository::init(current_dir.path()).expect("init current repo");
ref_lane_commit(
¤t_repo,
current_dir.path(),
"docs/current.md",
b"# Current\n\nThe quantum meridian anchors only the current worktree.\n",
"current worktree doc",
);
let index = LiveIndex::load(current_dir.path()).expect("load current worktree lane");
let ref_dir = tempfile::tempdir().expect("ref tempdir");
let ref_repo = git2::Repository::init(ref_dir.path()).expect("init ref repo");
ref_lane_commit(
&ref_repo,
ref_dir.path(),
"docs/reflane.md",
b"# Ref Lane\n\nThe orbital lattice resonates only on the ref lane.\n",
"ref lane doc",
);
live_index::local_ref_scout::ingest_and_publish_local_ref(
&index,
&ref_repo,
"HEAD",
crate::domain::index::RepositoryId::new("repo-cross-scope"),
&live_index::local_ref_scout::LocalRefScoutBudget::default(),
)
.expect("publish P1 ref lane");
assert!(
index
.published_source_set()
.sources
.keys()
.any(|id| id.as_str().starts_with("symforge:git-ref:")),
"a P1 git-ref lane must exist for the scope-composition test to be meaningful"
);
(current_dir, ref_dir, index)
}
#[tokio::test]
async fn cross_project_search_source_scope_composes_local_ref_lane() {
use crate::protocol::search_tools::KnowledgeSourceScope;
let _guard = env_lock().await;
let _gate = EnvVarGuard::set_str(LOCAL_REF_LANES_ENV, "1");
let (current_dir, _ref_dir, index) = cross_project_current_and_ref_lanes();
let project_indexes: HashMap<String, SharedIndex> =
HashMap::from([("proj-cross-scope".to_string(), Arc::clone(&index))]);
let server = SymForgeServer::new(
Arc::clone(&index),
"proj-cross-scope".to_string(),
Arc::new(parking_lot::Mutex::new(WatcherInfo::default())),
Some(current_dir.path().to_path_buf()),
None,
);
let query = |term: &str, scope: Option<KnowledgeSourceScope>| SearchKnowledgeInput {
query: term.to_string(),
path_prefix: None,
source_scope: scope,
authority_scope: None,
project: None,
projects: None,
limit: None,
max_tokens: None,
};
let refs = execute_cross_project_knowledge(
query("orbital lattice", Some(KnowledgeSourceScope::LocalRefs)),
Targets::All,
&project_indexes,
&server,
)
.expect("local_refs cross-project search");
assert!(
refs.contains("docs/reflane.md"),
"local_refs must compose the P1 ref lane: {refs}"
);
let all = execute_cross_project_knowledge(
query("orbital lattice", Some(KnowledgeSourceScope::All)),
Targets::All,
&project_indexes,
&server,
)
.expect("all cross-project search");
assert!(
all.contains("docs/reflane.md"),
"all must compose the P1 ref lane: {all}"
);
let subset = execute_cross_project_knowledge(
query("orbital lattice", Some(KnowledgeSourceScope::LocalRefs)),
Targets::Subset(vec!["proj-cross-scope".to_string()]),
&project_indexes,
&server,
)
.expect("subset local_refs cross-project search");
assert!(
subset.contains("docs/reflane.md"),
"subset local_refs must compose the P1 ref lane: {subset}"
);
let default_ref_term = execute_cross_project_knowledge(
query("orbital lattice", None),
Targets::All,
&project_indexes,
&server,
)
.expect("default cross-project search");
assert!(
!default_ref_term.contains("docs/reflane.md"),
"default scope must not compose the ref lane: {default_ref_term}"
);
let default_current_term = execute_cross_project_knowledge(
query("quantum meridian", None),
Targets::All,
&project_indexes,
&server,
)
.expect("default current-lane search");
assert!(
default_current_term.contains("docs/current.md"),
"default scope must search the current lane: {default_current_term}"
);
}
#[tokio::test]
async fn cross_project_review_source_scope_composes_local_ref_lane() {
use crate::protocol::search_tools::{KnowledgeSourceScope, ReviewKnowledgeMode};
let _guard = env_lock().await;
let _gate = EnvVarGuard::set_str(LOCAL_REF_LANES_ENV, "1");
let (current_dir, _ref_dir, index) = cross_project_current_and_ref_lanes();
let project_indexes: HashMap<String, SharedIndex> =
HashMap::from([("proj-cross-scope".to_string(), Arc::clone(&index))]);
let server = SymForgeServer::new(
Arc::clone(&index),
"proj-cross-scope".to_string(),
Arc::new(parking_lot::Mutex::new(WatcherInfo::default())),
Some(current_dir.path().to_path_buf()),
None,
);
let review = |path: &str, scope: Option<KnowledgeSourceScope>| ReviewKnowledgeInput {
mode: ReviewKnowledgeMode::Document,
path: Some(path.to_string()),
path_prefix: None,
source_scope: scope,
project: None,
projects: None,
limit: None,
max_tokens: None,
};
let refs = execute_cross_project_review(
review("docs/reflane.md", Some(KnowledgeSourceScope::LocalRefs)),
Targets::All,
&project_indexes,
&server,
)
.expect("local_refs cross-project review");
assert!(
refs.contains("docs/reflane.md"),
"local_refs review must compose the P1 ref lane: {refs}"
);
assert!(
refs.contains("top_result_hash="),
"composed review preserves the top-level hash envelope: {refs}"
);
let all = execute_cross_project_review(
review("docs/reflane.md", Some(KnowledgeSourceScope::All)),
Targets::All,
&project_indexes,
&server,
)
.expect("all cross-project review (per-source readiness is not a scope failure)");
assert!(
all.contains("docs/reflane.md"),
"all review must compose the P1 ref lane: {all}"
);
let default_ref_doc = execute_cross_project_review(
review("docs/reflane.md", None),
Targets::All,
&project_indexes,
&server,
);
assert!(
default_ref_doc.is_err(),
"default scope must not reach the ref-only document: {default_ref_doc:?}"
);
let default_current_doc = execute_cross_project_review(
review("docs/current.md", None),
Targets::All,
&project_indexes,
&server,
)
.expect("default current-lane review");
assert!(
default_current_doc.contains("docs/current.md"),
"default review must serve the current lane: {default_current_doc}"
);
}
#[tokio::test]
async fn l_r11_tool_dispatch_blocks_wildcard_and_ref_mapping_for_second_session() {
let _guard = env_lock().await;
let state_home = TempDir::new().expect("private user-local state base");
let _home = EnvVarGuard::set("SYMFORGE_HOME", state_home.path());
let home_a = project_dir("symforge-l-r11-dispatch-a");
let home_b = project_dir("symforge-l-r11-dispatch-b");
let state = DaemonState::new();
let session_a = state
.open_project_session(OpenProjectRequest {
project_root: home_a.path().display().to_string(),
client_name: "l-r11-dispatch-a".to_string(),
pid: None,
})
.expect("open session A");
let session_b = state
.open_project_session(OpenProjectRequest {
project_root: home_b.path().display().to_string(),
client_name: "l-r11-dispatch-b".to_string(),
pid: None,
})
.expect("open session B");
let fixture = TempDir::new().expect("protected-root fixture parent");
let protected = fixture.path().join("System32");
std::fs::create_dir(&protected).expect("create modeled protected root");
std::fs::write(
protected.join("guide.md"),
"# Protected Guide\n\nThe orbital lattice resonates across the protected source.\n",
)
.expect("write protected knowledge doc");
let protected_id = project_key(&protected.canonicalize().unwrap());
state
.index_folder_for_session(
&session_a.session_id,
IndexFolderInput {
path: protected.display().to_string(),
idempotency_key: None,
add: Some(true),
allow_protected_root: Some(true),
},
)
.expect("session A direct protected open");
let runtime_b = state
.runtime_for_target(&session_b.session_id, None)
.expect("session B runtime");
let wildcard = execute_tool_call(
runtime_b,
"search_knowledge",
serde_json::json!({ "query": "orbital lattice", "projects": ["*"] }),
)
.await
.expect("wildcard over session B's own projects succeeds");
assert!(
!wildcard.contains(protected_id.as_str()),
"projects=[\"*\"] must not reach another session's protected project: {wildcard}"
);
assert!(
!wildcard.contains("guide.md"),
"the protected document must not leak into session B's wildcard scope: {wildcard}"
);
let runtime_b = state
.runtime_for_target(&session_b.session_id, None)
.expect("session B runtime");
let refused = execute_tool_call(
runtime_b,
"search_knowledge",
serde_json::json!({ "query": "orbital lattice", "project": protected_id.clone() }),
)
.await
.expect_err("a protected project session B never opened is not addressable");
assert!(
refused.to_string().contains("project not open"),
"{refused}"
);
state
.index_folder_for_session(
&session_b.session_id,
IndexFolderInput {
path: protected.display().to_string(),
idempotency_key: None,
add: Some(true),
allow_protected_root: Some(true),
},
)
.expect("session B direct protected open");
let runtime_b = state
.runtime_for_target(&session_b.session_id, None)
.expect("session B runtime after its own override");
let after = execute_tool_call(
runtime_b,
"search_knowledge",
serde_json::json!({ "query": "orbital lattice", "project": protected_id.clone() }),
)
.await
.expect("session B can address the protected project after its own direct override");
assert!(
after.contains("guide.md"),
"session B now sees the protected document it opened directly: {after}"
);
}
#[tokio::test]
async fn protected_membership_is_not_inherited_by_reconnect_alias_or_restart() {
let _guard = env_lock().await;
let state_home = TempDir::new().expect("private user-local state base");
let _home = EnvVarGuard::set("SYMFORGE_HOME", state_home.path());
let home = project_dir("symforge-protected-restart-home");
let fixture = TempDir::new().expect("protected-root fixture parent");
let protected = fixture.path().join("System32");
std::fs::create_dir(&protected).expect("create modeled protected root");
std::fs::write(
protected.join("lib.rs"),
"pub fn protected_restart_symbol() {}\n",
)
.expect("write protected source");
let protected_id = project_key(&protected.canonicalize().unwrap());
let protected_state = state_home.path().join("projects").join(&protected_id);
let state = DaemonState::new();
let authorized = state
.open_project_session(OpenProjectRequest {
project_root: home.path().display().to_string(),
client_name: "protected-authorized".to_string(),
pid: None,
})
.expect("open authorized session home");
let opened = state
.index_folder_for_session(
&authorized.session_id,
IndexFolderInput {
path: protected.display().to_string(),
idempotency_key: None,
add: Some(true),
allow_protected_root: Some(true),
},
)
.expect("direct protected open");
assert!(opened.contains("Indexed 1 files"), "{opened}");
assert!(protected_state.join("index.bin").is_file());
let reconnect = state.open_project_session(OpenProjectRequest {
project_root: protected.display().to_string(),
client_name: "protected-reconnect".to_string(),
pid: None,
});
assert!(
reconnect.is_err(),
"reconnect metadata must not inherit direct protected authority"
);
{
let projects = state.projects.read();
let slot = projects.get(&protected_id).expect("live protected slot");
let metadata = slot.metadata.read();
assert_eq!(metadata.session_ids.len(), 1);
assert!(metadata.session_ids.contains(&authorized.session_id));
}
assert!(state.close_session(&authorized.session_id).is_some());
assert!(
state.list_projects().is_empty(),
"closing the last session must remove the live protected slot"
);
drop(state);
assert!(
protected_state.join("index.bin").is_file(),
"persisted protected state remains available but dormant"
);
let restarted = DaemonState::new();
let fresh = restarted
.open_project_session(OpenProjectRequest {
project_root: home.path().display().to_string(),
client_name: "protected-after-restart".to_string(),
pid: None,
})
.expect("open normal session after restart");
assert!(
restarted
.list_projects()
.iter()
.all(|project| project.project_id != protected_id),
"persisted protected state must not auto-attach after restart"
);
assert!(
!restarted.set_active_project(&fresh.session_id, &protected_id),
"a persisted project id must not grant membership after restart"
);
assert!(
restarted
.runtime_for_target(&fresh.session_id, Some("System32"))
.is_err(),
"a persisted protected display alias must remain dormant after restart"
);
assert!(
restarted
.open_project_session(OpenProjectRequest {
project_root: protected.display().to_string(),
client_name: "protected-reconnect-after-restart".to_string(),
pid: None,
})
.is_err(),
"reconnect after restart must still refuse protected membership"
);
let refused = restarted
.index_folder_for_session(
&fresh.session_id,
IndexFolderInput {
path: protected.display().to_string(),
idempotency_key: None,
add: Some(true),
allow_protected_root: None,
},
)
.expect("missing override is a typed refusal");
assert!(
refused.contains("protected_root_requires_explicit_override"),
"{refused}"
);
assert!(
restarted
.list_projects()
.iter()
.all(|project| project.project_id != protected_id),
"refusal must leave persisted protected state dormant"
);
let reopened = restarted
.index_folder_for_session(
&fresh.session_id,
IndexFolderInput {
path: protected.display().to_string(),
idempotency_key: None,
add: Some(true),
allow_protected_root: Some(true),
},
)
.expect("fresh direct override after restart");
assert!(reopened.contains("Indexed 1 files"), "{reopened}");
assert!(
restarted
.runtime_for_target(&fresh.session_id, Some(&protected_id))
.is_ok(),
"fresh direct override must reactivate the dormant protected state"
);
}
#[tokio::test]
async fn index_folder_replay_reestablishes_live_binding_or_returns_live_postcondition_unavailable()
{
let _guard = env_lock().await;
let state_home = TempDir::new().expect("private replay state base");
let _home = EnvVarGuard::set("SYMFORGE_HOME", state_home.path());
let home = project_dir("symforge-replay-home");
let target = project_dir("symforge-replay-target");
let other = project_dir("symforge-replay-other");
std::fs::write(target.path().join("src").join("one.rs"), "fn one() {}\n")
.expect("write first target source");
std::fs::write(other.path().join("src").join("other.rs"), "fn other() {}\n")
.expect("write other target source");
let target_id = project_key(&canonical_project_root(target.path()).unwrap());
let other_id = project_key(&canonical_project_root(other.path()).unwrap());
let state = test_daemon_state(state_home.path());
let session = state
.open_project_session(OpenProjectRequest {
project_root: home.path().display().to_string(),
client_name: "replay".to_string(),
pid: None,
})
.expect("open replay home");
let key = "b-r27-replay";
let first_receipt = {
let _limit = EnvVarGuard::set("SYMFORGE_MAX_INDEX_FILES", Path::new("100"));
state
.index_folder_for_session(
&session.session_id,
IndexFolderInput {
path: target.path().display().to_string(),
idempotency_key: Some(key.to_string()),
add: Some(true),
allow_protected_root: None,
},
)
.expect("first replay execution")
};
assert!(first_receipt.contains("Indexed 1 files"), "{first_receipt}");
assert!(state.remove_project_from_session(&session.session_id, &target_id));
std::fs::write(target.path().join("src").join("two.rs"), "fn two() {}\n")
.expect("write second target source");
let unavailable = {
let _limit = EnvVarGuard::set("SYMFORGE_MAX_INDEX_FILES", Path::new("1"));
state
.index_folder_for_session(
&session.session_id,
IndexFolderInput {
path: target.path().display().to_string(),
idempotency_key: Some(key.to_string()),
add: Some(true),
allow_protected_root: None,
},
)
.expect("replay failure is a successful typed tool result")
};
assert!(unavailable.contains("applied=false"), "{unavailable}");
assert!(
unavailable.contains("outcome=live_postcondition_unavailable"),
"{unavailable}"
);
assert!(
unavailable.contains(&first_receipt),
"typed failure must preserve the immutable historical receipt: {unavailable}"
);
assert!(
state
.runtime_for_target(&session.session_id, Some(&target_id))
.is_err(),
"failed replay must not claim or attach a live binding"
);
let restored = {
let _limit = EnvVarGuard::set("SYMFORGE_MAX_INDEX_FILES", Path::new("100"));
state
.index_folder_for_session(
&session.session_id,
IndexFolderInput {
path: target.path().display().to_string(),
idempotency_key: Some(key.to_string()),
add: Some(true),
allow_protected_root: None,
},
)
.expect("replay restores live postcondition")
};
assert_eq!(
restored, first_receipt,
"stored receipt must remain immutable"
);
assert!(
state
.runtime_for_target(&session.session_id, Some(&target_id))
.is_ok(),
"stored success may return only after live membership is restored"
);
assert!(state.remove_project_from_session(&session.session_id, &target_id));
let override_conflict = state
.index_folder_for_session(
&session.session_id,
IndexFolderInput {
path: target.path().display().to_string(),
idempotency_key: Some(key.to_string()),
add: Some(true),
allow_protected_root: Some(true),
},
)
.expect("override change is a deterministic tool-level conflict");
assert!(
override_conflict.contains("Idempotency conflict"),
"{override_conflict}"
);
assert!(
state
.runtime_for_target(&session.session_id, Some(&target_id))
.is_err(),
"override conflict must happen before live attachment"
);
let path_conflict = state
.index_folder_for_session(
&session.session_id,
IndexFolderInput {
path: other.path().display().to_string(),
idempotency_key: Some(key.to_string()),
add: Some(true),
allow_protected_root: None,
},
)
.expect("path change is a deterministic tool-level conflict");
assert!(
path_conflict.contains("Idempotency conflict"),
"{path_conflict}"
);
assert!(
state
.runtime_for_target(&session.session_id, Some(&other_id))
.is_err(),
"path conflict must happen before loading or attaching the other project"
);
}
#[tokio::test]
async fn post_bind_state_write_failure_degrades_durability_not_live_readiness() {
let _guard = env_lock().await;
let project = project_dir("symforge-post-bind-state-failure");
std::fs::write(
project.path().join("src").join("main.rs"),
"fn main() { println!(\"still live\"); }\n",
)
.expect("write queryable source");
let state = DaemonState::new();
let session = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "durability-oracle".to_string(),
pid: None,
})
.expect("bind and publish project before failing state writes");
let slot = state
.projects
.read()
.get(&session.project_id)
.cloned()
.expect("bound project slot");
let (canonical_root, placement, publication_before, watcher_info) = {
let project = slot.metadata.read();
(
project.canonical_root.clone(),
project.state_placement.clone(),
project.index.published_generation(),
Arc::clone(&project.watcher_info),
)
};
let state_dir = match &placement {
StatePlacement::ProjectLocal { directory }
| StatePlacement::UserLocal { directory, .. } => directory.as_path().to_path_buf(),
StatePlacement::MemoryOnly { failures } => {
panic!("fixture requires durable placement, got memory-only: {failures:?}")
}
};
let before = state
.project_health(&session.project_id)
.expect("health before state failure");
assert_eq!(before.index_state, "Ready");
assert_eq!(
before.durability,
crate::domain::CapabilityStatus::Available
);
assert_eq!(
before.capabilities.checkpoint,
crate::domain::CapabilityStatus::Available
);
std::fs::remove_dir_all(&state_dir).expect("remove writable state directory");
std::fs::write(&state_dir, b"state owner became unwritable")
.expect("replace state directory with a blocking file");
let checkpoint = execute_tool_call(
state
.session_runtime(&session.session_id)
.expect("session runtime before checkpoint"),
"checkpoint_now",
serde_json::json!({ "verify_after_write": true }),
)
.await
.expect("checkpoint failure remains a typed tool response");
assert!(
checkpoint.contains("Checkpoint failed"),
"state write must fail in the fixture: {checkpoint}"
);
let after = state
.project_health(&session.project_id)
.expect("health after state failure");
assert_eq!(after.project_id, before.project_id);
assert_eq!(after.canonical_root, before.canonical_root);
assert_eq!(after.index_state, "Ready");
assert_eq!(
after.durability,
crate::domain::CapabilityStatus::Unavailable {
reason: crate::domain::CapabilityUnavailableReason::PersistentStateUnavailable,
}
);
assert_eq!(
after.capabilities.checkpoint,
crate::domain::CapabilityStatus::Unavailable {
reason: crate::domain::CapabilityUnavailableReason::PersistentStateUnavailable,
}
);
assert_eq!(
after.capabilities.repository_curation,
crate::domain::CapabilityStatus::Unavailable {
reason:
crate::domain::CapabilityUnavailableReason::DurableMutationReplayUnavailable,
}
);
{
let project = slot.metadata.read();
assert_eq!(project.canonical_root, canonical_root);
assert_eq!(project.state_placement, placement);
let publication_after = project.index.published_generation();
assert!(
publication_after.publication_generation
>= publication_before.publication_generation,
"derived-only background publication may advance but never rewind"
);
assert_eq!(
publication_after.content_generation, publication_before.content_generation,
"failed durability must not mutate live content identity"
);
assert_eq!(
publication_after.project_generation,
publication_before.project_generation
);
assert_eq!(publication_after.source, publication_before.source);
assert_eq!(
publication_after.source_version,
publication_before.source_version
);
assert_eq!(
publication_after
.manifest
.as_ref()
.map(|manifest| &manifest.digest),
publication_before
.manifest
.as_ref()
.map(|manifest| &manifest.digest)
);
assert!(Arc::ptr_eq(&project.watcher_info, &watcher_info));
}
let query = execute_tool_call(
state
.session_runtime(&session.session_id)
.expect("session runtime after checkpoint failure"),
"get_file_content",
serde_json::json!({ "path": "src/main.rs" }),
)
.await
.expect("live query after state failure");
assert!(
query.contains("still live"),
"live query regressed: {query}"
);
}
#[tokio::test]
async fn reindex_preserves_resolved_placement_until_new_project_instance() {
let _guard = env_lock().await;
let project = project_dir("symforge-placement-lifetime");
std::fs::write(
project.path().join("src").join("lib.rs"),
"pub fn placement_lifetime() {}\n",
)
.expect("write source");
let project_state = project.path().join(".symforge");
std::fs::write(&project_state, b"block project-local state")
.expect("install project-local blocker");
let home = TempDir::new().expect("isolated user-local state");
let _home = EnvVarGuard::set("SYMFORGE_HOME", home.path());
let state = DaemonState::with_token_and_control_state(
"placement-lifetime-token".to_string(),
Some(ControlStateDir::new(home.path().to_path_buf())),
);
let first = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "placement-lifetime-first".to_string(),
pid: None,
})
.expect("open with user-local fallback");
let first_slot = state
.projects
.read()
.get(&first.project_id)
.cloned()
.expect("first project slot");
let (canonical_root, first_placement) = {
let project = first_slot.metadata.read();
(
project.canonical_root.clone(),
project.state_placement.clone(),
)
};
let first_state_dir = match &first_placement {
StatePlacement::UserLocal { directory, .. } => directory.as_path().to_path_buf(),
other => panic!("blocked project-local state must fall back, got {other:?}"),
};
assert!(first_state_dir.starts_with(home.path()));
std::fs::remove_file(&project_state).expect("make project-local state available");
let output = state
.index_folder_for_session(
&first.session_id,
IndexFolderInput {
path: project.path().display().to_string(),
idempotency_key: None,
add: None,
allow_protected_root: None,
},
)
.expect("reindex same live project");
assert!(
output.starts_with("Indexed "),
"unexpected receipt: {output}"
);
let same_slot = state
.projects
.read()
.get(&first.project_id)
.cloned()
.expect("same live project slot");
assert!(Arc::ptr_eq(&first_slot, &same_slot));
assert_eq!(
same_slot.metadata.read().state_placement,
first_placement,
"same live ProjectInstance must keep its resolved owner"
);
assert!(
!project_state.exists(),
"same live ProjectInstance must not re-run placement or probe/create a new owner"
);
drop(same_slot);
drop(first_slot);
let closed = state
.close_session(&first.session_id)
.expect("close first project instance");
assert!(closed.project_removed);
let second = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "placement-lifetime-second".to_string(),
pid: None,
})
.expect("construct fresh project instance");
let second_slot = state
.projects
.read()
.get(&second.project_id)
.cloned()
.expect("fresh project slot");
match &second_slot.metadata.read().state_placement {
StatePlacement::ProjectLocal { directory } => {
assert_eq!(directory.as_path(), canonical_root.join(".symforge"));
assert_ne!(directory.as_path(), first_state_dir);
}
other => panic!("fresh instance must recover project-local durability, got {other:?}"),
}
assert!(project_state.is_dir());
assert!(
state
.close_session(&second.session_id)
.expect("close fresh project instance")
.project_removed
);
}
#[tokio::test]
async fn cold_start_capacity_refusal_stays_nonready_with_typed_freshness() {
let _guard = env_lock().await;
let _entry_limit = EnvVarGuard::set("SYMFORGE_MAX_INDEX_FILES", Path::new("1"));
let project = project_dir("symforge-capacity-refusal");
std::fs::write(
project.path().join("src").join("lib.rs"),
"pub fn one() {}\n",
)
.expect("write first source");
std::fs::write(project.path().join("README.md"), "# second catalog entry\n")
.expect("write second source");
let control = TempDir::new().expect("isolated daemon control state");
let state = DaemonState::with_token_and_control_state(
"capacity-refusal-token".to_string(),
Some(ControlStateDir::new(control.path().to_path_buf())),
);
let opened = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "capacity-refusal-client".to_string(),
pid: None,
})
.expect("typed capacity refusal must keep the daemon responsive");
let slot = state
.projects
.read()
.get(&opened.project_id)
.cloned()
.expect("non-ready project slot remains registered");
let project = slot.metadata.read();
assert!(!project.index.read().is_ready());
assert!(
project.index.scout_plan().is_none(),
"no partial plan may publish"
);
assert!(matches!(
project.index.freshness_status().as_ref(),
crate::domain::FreshnessStatus::Degraded {
last_valid_content_generation: 0,
reason_codes,
} if reason_codes == &[crate::domain::FreshnessReason::CatalogEntryCapacityExceeded]
));
drop(project);
let health = state
.project_health(&opened.project_id)
.expect("registered non-ready project health");
assert!(matches!(
health.freshness,
crate::domain::FreshnessStatus::Degraded {
last_valid_content_generation: 0,
ref reason_codes,
} if reason_codes == &[crate::domain::FreshnessReason::CatalogEntryCapacityExceeded]
));
assert!(
state
.close_session(&opened.session_id)
.expect("close capacity-refusal session")
.project_removed
);
}
#[test]
fn test_open_project_session_refuses_sensitive_root() {
let state = DaemonState::new();
#[cfg(windows)]
let sensitive = r"C:\Windows";
#[cfg(unix)]
let sensitive = "/etc";
let result = state.open_project_session(OpenProjectRequest {
project_root: sensitive.to_string(),
client_name: "claude".to_string(),
pid: None,
});
let err = result.expect_err("sensitive root must be refused, not opened");
let msg = err.to_string();
assert!(
msg.contains("Refused to open session for sensitive system path"),
"open_project_session must refuse sensitive root `{sensitive}`, got: {msg}"
);
assert!(
state.list_projects().is_empty(),
"refusal must not create a project for the sensitive root"
);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn test_close_session_reaps_all_working_set_projects_and_watchers() {
let project_a = project_dir("symforge-reap-a");
let project_b = project_dir("symforge-reap-b");
std::fs::write(project_b.path().join("src").join("b.rs"), "fn b() {}\n")
.expect("write source b");
let state = DaemonState::new();
let opened = state
.open_project_session(OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "reap".to_string(),
pid: None,
})
.expect("open A");
let active_a = opened.project_id.clone();
state
.index_folder_for_session(
&opened.session_id,
IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: Some(true),
allow_protected_root: None,
},
)
.expect("additive open B");
let project_b_id =
project_key(&canonical_project_root(project_b.path()).expect("canonical b"));
assert_eq!(
state.list_projects().len(),
2,
"A and B both open before close"
);
let (token_a, token_b, watcher_a_live, watcher_b_live) = {
let projects = state.projects.read();
let a_slot = projects.get(&active_a).expect("A loaded");
let b_slot = projects.get(&project_b_id).expect("B loaded");
let a = a_slot.metadata.read();
let b = b_slot.metadata.read();
(
Arc::clone(&a.stop_token),
Arc::clone(&b.stop_token),
a.watcher_task.is_some(),
b.watcher_task.is_some(),
)
};
assert!(
watcher_a_live && watcher_b_live,
"both projects must have a live watcher task before close \
(A: {watcher_a_live}, B: {watcher_b_live})"
);
assert!(
!token_a.load(Ordering::Acquire) && !token_b.load(Ordering::Acquire),
"watcher stop tokens must be unset (false) while the projects are live"
);
let closed = state
.close_session(&opened.session_id)
.expect("close session");
assert_eq!(
closed.project_id, active_a,
"reported pid is the active project A"
);
assert_eq!(closed.remaining_sessions, 0);
assert!(closed.project_removed, "active project A reaped");
assert!(
state.list_projects().is_empty(),
"close_session must reap BOTH A and B, leaving no open project: {:?}",
state.list_projects()
);
assert!(
token_a.load(Ordering::Acquire),
"A's watcher stop_token must be set after close (watcher torn down)"
);
assert!(
token_b.load(Ordering::Acquire),
"B's watcher stop_token must be set after close (additive sibling watcher torn down)"
);
}
#[test]
fn test_close_session_removes_project_when_last_session_leaves() {
let project = project_dir("symforge-daemon-d");
let state = DaemonState::new();
let first = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "claude".to_string(),
pid: None,
})
.expect("first session");
let second = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "codex".to_string(),
pid: None,
})
.expect("second session");
let close_first = state
.close_session(&first.session_id)
.expect("close first session");
assert_eq!(close_first.remaining_sessions, 1);
assert!(!close_first.project_removed);
assert_eq!(state.list_projects().len(), 1);
let close_second = state
.close_session(&second.session_id)
.expect("close second session");
assert_eq!(close_second.remaining_sessions, 0);
assert!(close_second.project_removed);
assert!(state.list_projects().is_empty());
}
#[test]
fn test_close_session_handles_orphan_session_record_without_panic() {
let state = DaemonState::new();
let session_id = "stale-session".to_string();
state.sessions.write().insert(
session_id.clone(),
SessionRecord {
session_id: session_id.clone(),
active_project_id: "missing-project".to_string(),
working_set: Arc::new(RwLock::new(WorkingSet::new())),
servers: HashMap::new(),
client_name: "codex".to_string(),
pid: Some(777),
opened_at: SystemTime::now(),
last_seen_at: AtomicU64::new(now_epoch_millis()),
},
);
let closed = state
.close_session(&session_id)
.expect("orphan session should still close");
assert_eq!(closed.session_id, session_id);
assert_eq!(closed.project_id, "orphan");
assert_eq!(closed.remaining_sessions, 0);
assert!(!closed.project_removed);
assert!(state.close_session(&closed.session_id).is_none());
}
#[test]
fn test_heartbeat_updates_known_session() {
let project = project_dir("symforge-daemon-e");
let state = DaemonState::new();
let opened = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "claude".to_string(),
pid: Some(123),
})
.expect("session");
let known = state.heartbeat(&opened.session_id);
let unknown = state.heartbeat("missing-session");
assert!(known.known_session);
assert!(!unknown.known_session);
}
#[test]
fn test_project_health_and_sessions_expose_instance_metadata() {
let project = project_dir("symforge-daemon-f");
let state = DaemonState::new();
let first = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "claude".to_string(),
pid: Some(111),
})
.expect("first session");
let second = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "codex".to_string(),
pid: Some(222),
})
.expect("second session");
let health = state
.project_health(&first.project_id)
.expect("project health should exist");
assert_eq!(health.project_id, first.project_id);
assert_eq!(health.session_count, 2);
assert_eq!(health.index_state, "Ready");
let sessions = state
.list_sessions(&first.project_id)
.expect("session list should exist");
assert_eq!(sessions.len(), 2);
assert_eq!(sessions[0].project_id, first.project_id);
assert!(
sessions
.iter()
.any(|session| session.client_name == "claude")
);
assert!(
sessions
.iter()
.any(|session| session.client_name == "codex")
);
assert!(sessions.iter().any(|session| session.pid == Some(111)));
assert!(sessions.iter().any(|session| session.pid == Some(222)));
assert_ne!(first.session_id, second.session_id);
}
#[test]
fn test_sessions_on_same_project_do_not_share_context_cache() {
let project = project_dir("symforge-session-state-isolation");
std::fs::write(
project.path().join("src").join("lib.rs"),
"pub fn shared_project() {}\n",
)
.expect("write source");
let state = DaemonState::new();
let first = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "first".to_string(),
pid: None,
})
.expect("first session");
let second = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "second".to_string(),
pid: None,
})
.expect("second session");
let first_runtime = state
.session_runtime(&first.session_id)
.expect("first runtime");
let second_runtime = state
.session_runtime(&second.session_id)
.expect("second runtime");
first_runtime
.server
.session_context
.record_file_content_fetch("src/lib.rs", 42, 100);
assert!(
first_runtime
.server
.session_context
.try_file_content_cache_hit("src/lib.rs", 42, false)
.is_some(),
"the originating session should observe its own cache entry"
);
assert!(
second_runtime
.server
.session_context
.try_file_content_cache_hit("src/lib.rs", 42, false)
.is_none(),
"a second session on the same project must not inherit the first session's cache"
);
assert!(!Arc::ptr_eq(
&first_runtime.server.session_context,
&second_runtime.server.session_context,
));
assert!(!Arc::ptr_eq(
&first_runtime.server.ccr_store,
&second_runtime.server.ccr_store,
));
assert!(!Arc::ptr_eq(
&first_runtime.server.stel_ledger,
&second_runtime.server.stel_ledger,
));
assert!(Arc::ptr_eq(&first_runtime.index, &second_runtime.index,));
assert!(Arc::ptr_eq(
&first_runtime.token_stats,
&second_runtime.token_stats,
));
}
#[test]
fn test_project_b_reads_while_project_a_reloads() {
let project_a = project_dir("symforge-slot-isolation-a");
let project_b = project_dir("symforge-slot-isolation-b");
std::fs::write(
project_a.path().join("src").join("lib.rs"),
"pub fn project_a() {}\n",
)
.expect("write A");
std::fs::write(
project_b.path().join("src").join("lib.rs"),
"pub fn project_b() {}\n",
)
.expect("write B");
let state = Arc::new(DaemonState::new());
let opened_a = state
.open_project_session(OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "a".to_string(),
pid: None,
})
.expect("open A");
let opened_b = state
.open_project_session(OpenProjectRequest {
project_root: project_b.path().display().to_string(),
client_name: "b".to_string(),
pid: None,
})
.expect("open B");
let root_a = canonical_project_root(project_a.path()).expect("canonical A");
let slot_a = state
.projects
.read()
.get(&opened_a.project_id)
.cloned()
.expect("A slot");
let (reload_entered_tx, reload_entered_rx) = std::sync::mpsc::sync_channel(1);
let (release_reload_tx, release_reload_rx) = std::sync::mpsc::sync_channel(1);
let reload = std::thread::spawn(move || {
slot_a.reload_with(&root_a, |index, root| {
reload_entered_tx.send(()).expect("signal reload entered");
release_reload_rx.recv().expect("release reload");
index.reload(root)
})
});
reload_entered_rx
.recv_timeout(Duration::from_secs(2))
.expect("A reload should enter its mutation lane");
let state_for_read = Arc::clone(&state);
let session_b = opened_b.session_id.clone();
let project_b_id = opened_b.project_id.clone();
let (read_done_tx, read_done_rx) = std::sync::mpsc::sync_channel(1);
let reader = std::thread::spawn(move || {
let runtime = state_for_read.session_runtime(&session_b).is_some();
let health = state_for_read.project_health(&project_b_id).is_some();
let sessions = state_for_read.list_sessions(&project_b_id).is_some();
read_done_tx
.send((runtime, health, sessions))
.expect("report B reads");
});
assert_eq!(
read_done_rx
.recv_timeout(Duration::from_secs(1))
.expect("project B reads must not wait for project A reload"),
(true, true, true)
);
release_reload_tx.send(()).expect("release A reload");
reload
.join()
.expect("A reload thread")
.expect("A reload result");
reader.join().expect("B reader thread");
}
#[test]
fn test_same_project_reads_prior_generation_during_reload() {
let project = project_dir("symforge-slot-same-project");
let source = project.path().join("src").join("lib.rs");
std::fs::write(&source, "pub fn prior_generation() {}\n").expect("write prior");
let state = Arc::new(DaemonState::new());
let opened = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "same-project".to_string(),
pid: None,
})
.expect("open project");
let prior = Arc::clone(
&state
.session_runtime(&opened.session_id)
.expect("prior runtime")
.index
.read(),
);
std::fs::write(&source, "pub fn next_generation() {}\n").expect("write next");
let slot = state
.projects
.read()
.get(&opened.project_id)
.cloned()
.expect("project slot");
let root = canonical_project_root(project.path()).expect("canonical project");
let (first_entered_tx, first_entered_rx) = std::sync::mpsc::sync_channel(1);
let (release_first_tx, release_first_rx) = std::sync::mpsc::sync_channel(1);
let first_slot = Arc::clone(&slot);
let first_root = root.clone();
let first_reload = std::thread::spawn(move || {
first_slot.reload_with(&first_root, |index, root| {
first_entered_tx.send(()).expect("signal first reload");
release_first_rx.recv().expect("release first reload");
index.reload(root)
})
});
first_entered_rx
.recv_timeout(Duration::from_secs(2))
.expect("first reload should enter");
let (second_entered_tx, second_entered_rx) = std::sync::mpsc::sync_channel(1);
let second_reload = std::thread::spawn(move || {
slot.reload_with(&root, |index, root| {
second_entered_tx.send(()).expect("signal second reload");
index.reload(root)
})
});
assert!(
second_entered_rx
.recv_timeout(Duration::from_millis(150))
.is_err(),
"same-project reloads must serialize on the mutation lane"
);
let during = Arc::clone(
&state
.session_runtime(&opened.session_id)
.expect("runtime during reload")
.index
.read(),
);
assert!(
Arc::ptr_eq(&prior, &during),
"reads must retain the prior published index while reload builds"
);
release_first_tx.send(()).expect("release first reload");
first_reload
.join()
.expect("first reload thread")
.expect("first reload result");
second_entered_rx
.recv_timeout(Duration::from_secs(2))
.expect("second reload should enter after first finishes");
second_reload
.join()
.expect("second reload thread")
.expect("second reload result");
let after = Arc::clone(
&state
.session_runtime(&opened.session_id)
.expect("runtime after reload")
.index
.read(),
);
assert!(
!Arc::ptr_eq(&prior, &after),
"successful reload must atomically publish a new index generation"
);
}
#[tokio::test]
async fn test_spawn_daemon_serves_project_and_session_endpoints() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project = project_dir("symforge-daemon-http");
let handle = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn daemon");
let client = authed_client(&handle);
let base_url = format!("http://127.0.0.1:{}", handle.port);
let daemon_health = client
.get(format!("{base_url}/health"))
.send()
.await
.expect("health request")
.error_for_status()
.expect("health status")
.json::<DaemonHealth>()
.await
.expect("health body");
assert_eq!(daemon_health.project_count, 0);
assert_eq!(daemon_health.session_count, 0);
assert_eq!(daemon_health.daemon_version, env!("CARGO_PKG_VERSION"));
assert!(daemon_health.auth_required);
assert!(!daemon_health.executable_path.is_empty());
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "codex".to_string(),
pid: Some(4242),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let project_health = client
.get(format!(
"{base_url}/v1/projects/{}/health",
opened.project_id
))
.send()
.await
.expect("project health request")
.error_for_status()
.expect("project health status")
.json::<ProjectHealth>()
.await
.expect("project health body");
assert_eq!(project_health.project_id, opened.project_id);
assert_eq!(project_health.session_count, 1);
assert_eq!(project_health.index_state, "Ready");
let sessions = client
.get(format!(
"{base_url}/v1/projects/{}/sessions",
opened.project_id
))
.send()
.await
.expect("sessions request")
.error_for_status()
.expect("sessions status")
.json::<Vec<SessionSummary>>()
.await
.expect("sessions body");
assert_eq!(sessions.len(), 1);
assert_eq!(sessions[0].session_id, opened.session_id);
assert_eq!(sessions[0].client_name, "codex");
assert_eq!(sessions[0].pid, Some(4242));
let heartbeat = client
.post(format!(
"{base_url}/v1/sessions/{}/heartbeat",
opened.session_id
))
.send()
.await
.expect("heartbeat request")
.error_for_status()
.expect("heartbeat status")
.json::<HeartbeatResponse>()
.await
.expect("heartbeat body");
assert!(heartbeat.known_session);
let closed = client
.delete(format!("{base_url}/v1/sessions/{}", opened.session_id))
.send()
.await
.expect("close request")
.error_for_status()
.expect("close status")
.json::<CloseSessionResponse>()
.await
.expect("close body");
assert!(closed.project_removed);
assert_eq!(closed.remaining_sessions, 0);
let final_health = client
.get(format!("{base_url}/health"))
.send()
.await
.expect("final health request")
.error_for_status()
.expect("final health status")
.json::<DaemonHealth>()
.await
.expect("final health body");
assert_eq!(final_health.project_count, 0);
assert_eq!(final_health.session_count, 0);
assert_eq!(final_health.daemon_version, env!("CARGO_PKG_VERSION"));
assert!(!final_health.executable_path.is_empty());
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PID_FILE,
))
.await;
assert!(
!test_daemon_path(daemon_home.path(), LEGACY_DAEMON_PORT_FILE).exists(),
"daemon port file should be removed on shutdown"
);
assert!(
!test_daemon_path(daemon_home.path(), LEGACY_DAEMON_PID_FILE).exists(),
"daemon pid file should be removed on shutdown"
);
}
#[tokio::test]
async fn test_daemon_auth_token_protects_session_tool_and_sidecar_routes() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _home_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let _bind_guard = EnvVarGuard::unset(DAEMON_BIND_ENV);
let _allow_guard = EnvVarGuard::unset(DAEMON_ALLOW_NON_LOOPBACK_ENV);
let token = "sfr03-test-token";
let _auth_guard = EnvVarGuard::set_str(DAEMON_AUTH_TOKEN_ENV, token);
let project = project_dir("symforge-daemon-auth");
let handle = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn daemon");
let client = reqwest::Client::new();
let base_url = format!("http://127.0.0.1:{}", handle.port);
let health_body = client
.get(format!("{base_url}/health"))
.send()
.await
.expect("health request")
.error_for_status()
.expect("health status")
.text()
.await
.expect("health body");
assert!(
!health_body.contains(token),
"health body must not leak auth token"
);
let daemon_health: DaemonHealth = serde_json::from_str(&health_body).expect("health json");
assert!(daemon_health.auth_required);
let missing_projects = client
.get(format!("{base_url}/v1/projects"))
.send()
.await
.expect("projects request");
assert_eq!(missing_projects.status(), StatusCode::UNAUTHORIZED);
let missing_body = missing_projects.text().await.expect("missing auth body");
assert!(
!missing_body.contains(token),
"401 body must not leak auth token"
);
let wrong_open = client
.post(format!("{base_url}/v1/sessions/open"))
.bearer_auth("wrong-token")
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "codex".to_string(),
pid: Some(5150),
})
.send()
.await
.expect("wrong auth open request");
assert_eq!(wrong_open.status(), StatusCode::UNAUTHORIZED);
let wrong_body = wrong_open.text().await.expect("wrong auth body");
assert!(
!wrong_body.contains(token),
"wrong-token body must not leak auth token"
);
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.bearer_auth(token)
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "codex".to_string(),
pid: Some(5150),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
client
.get(format!("{base_url}/v1/projects"))
.bearer_auth(token)
.send()
.await
.expect("authorized projects request")
.error_for_status()
.expect("authorized projects status");
let missing_tool = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/health",
opened.session_id
))
.json(&serde_json::json!({}))
.send()
.await
.expect("missing tool auth request");
assert_eq!(missing_tool.status(), StatusCode::UNAUTHORIZED);
let tool_body = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/health",
opened.session_id
))
.bearer_auth(token)
.json(&serde_json::json!({}))
.send()
.await
.expect("authorized tool request")
.error_for_status()
.expect("authorized tool status")
.text()
.await
.expect("authorized tool body");
assert!(
tool_body.contains("Status:"),
"health tool response should succeed: {tool_body}"
);
assert!(
!tool_body.contains(token),
"tool response must not leak auth token"
);
let missing_sidecar = client
.get(format!(
"{base_url}/v1/sessions/{}/sidecar/health",
opened.session_id
))
.send()
.await
.expect("missing sidecar auth request");
assert_eq!(missing_sidecar.status(), StatusCode::UNAUTHORIZED);
client
.get(format!(
"{base_url}/v1/sessions/{}/sidecar/health",
opened.session_id
))
.bearer_auth(token)
.send()
.await
.expect("authorized sidecar request")
.error_for_status()
.expect("authorized sidecar status");
client
.post(format!(
"{base_url}/v1/sessions/{}/heartbeat",
opened.session_id
))
.bearer_auth(token)
.send()
.await
.expect("authorized heartbeat request")
.error_for_status()
.expect("authorized heartbeat status");
client
.delete(format!("{base_url}/v1/sessions/{}", opened.session_id))
.bearer_auth(token)
.send()
.await
.expect("authorized close request")
.error_for_status()
.expect("authorized close status");
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
}
#[tokio::test]
async fn test_cross_project_query_returns_attributed_hits_from_both_projects() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project_a = project_dir("symforge-xproj-a");
let project_b = project_dir("symforge-xproj-b");
std::fs::write(
project_a.path().join("src").join("a.rs"),
"pub fn xproj_marker_alpha() -> u32 { 1 }\n",
)
.expect("write source a");
std::fs::write(
project_b.path().join("src").join("b.rs"),
"pub fn xproj_marker_beta() -> u32 { 2 }\n",
)
.expect("write source b");
let handle = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn daemon");
let base_url = format!("http://127.0.0.1:{}", handle.port);
let http = authed_client(&handle);
let opened = http
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "xproj".to_string(),
pid: Some(std::process::id()),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let project_a_id = opened.project_id.clone();
let project_b_id =
project_key(&canonical_project_root(project_b.path()).expect("canonical b"));
let index_a = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/index_folder",
opened.session_id
))
.json(&IndexFolderInput {
path: project_a.path().display().to_string(),
idempotency_key: None,
add: None,
allow_protected_root: None,
})
.send()
.await
.expect("index A request")
.error_for_status()
.expect("index A status")
.text()
.await
.expect("index A body");
assert!(index_a.contains("Indexed"), "index A: {index_a}");
let index_b = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/index_folder",
opened.session_id
))
.json(&IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: Some(true),
allow_protected_root: None,
})
.send()
.await
.expect("index B request")
.error_for_status()
.expect("index B status")
.text()
.await
.expect("index B body");
assert!(
index_b.contains("added to working set"),
"additive index B: {index_b}"
);
let cross = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/search_symbols",
opened.session_id
))
.json(&serde_json::json!({
"query": "xproj_marker",
"projects": ["*"]
}))
.send()
.await
.expect("cross query request")
.error_for_status()
.expect("cross query status")
.text()
.await
.expect("cross query body");
assert!(
cross.contains("xproj_marker_alpha"),
"cross-project query must surface A's symbol: {cross}"
);
assert!(
cross.contains("xproj_marker_beta"),
"cross-project query must surface B's symbol: {cross}"
);
assert!(
cross.contains(&format!("project: {project_a_id}")),
"A must be attributed by project id: {cross}"
);
assert!(
cross.contains(&format!("project: {project_b_id}")),
"B must be attributed by project id: {cross}"
);
let active_only = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/search_symbols",
opened.session_id
))
.json(&serde_json::json!({
"query": "xproj_marker"
}))
.send()
.await
.expect("active query request")
.error_for_status()
.expect("active query status")
.text()
.await
.expect("active query body");
assert!(
active_only.contains("xproj_marker_alpha"),
"active-only query must surface A's symbol: {active_only}"
);
assert!(
!active_only.contains("xproj_marker_beta"),
"active-only query must NOT surface B's symbol (single active project): {active_only}"
);
assert!(
!active_only.contains("project: "),
"single-active query must render flat (no project header): {active_only}"
);
let explicit_active = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/search_symbols",
opened.session_id
))
.json(&serde_json::json!({
"query": "xproj_marker",
"project": project_a_id
}))
.send()
.await
.expect("explicit active query request")
.error_for_status()
.expect("explicit active query status")
.text()
.await
.expect("explicit active query body");
assert!(
explicit_active.contains("xproj_marker_alpha"),
"explicit active project query must surface A's symbol: {explicit_active}"
);
assert!(
!explicit_active.contains("xproj_marker_beta"),
"explicit active project query must NOT surface B's symbol: {explicit_active}"
);
assert!(
!explicit_active.contains("Cross-project queries"),
"explicit active project must not hit the local cross-project refusal: {explicit_active}"
);
assert!(
!explicit_active.contains("project: "),
"explicit active project must render as the flat single-project route: {explicit_active}"
);
let scoped_out = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/search_symbols",
opened.session_id
))
.json(&serde_json::json!({
"query": "xproj_marker",
"projects": ["*"],
"path_prefix": "no_such_dir"
}))
.send()
.await
.expect("scoped query request")
.error_for_status()
.expect("B1: path_prefix must NOT be refused (HTTP 200, not 400)")
.text()
.await
.expect("scoped query body");
assert!(
!scoped_out.contains("xproj_marker_alpha") && !scoped_out.contains("xproj_marker_beta"),
"B1: a non-matching path_prefix must scope BOTH projects out \
(honored, not ignored): {scoped_out}"
);
let lang_python = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/search_symbols",
opened.session_id
))
.json(&serde_json::json!({
"query": "xproj_marker",
"projects": ["*"],
"language": "Python"
}))
.send()
.await
.expect("python query request")
.error_for_status()
.expect("B1: language must NOT be refused (HTTP 200, not 400)")
.text()
.await
.expect("python query body");
assert!(
!lang_python.contains("xproj_marker_alpha")
&& !lang_python.contains("xproj_marker_beta"),
"B1: language=Python must scope out the Rust symbols cross-project: {lang_python}"
);
let lang_rust = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/search_symbols",
opened.session_id
))
.json(&serde_json::json!({
"query": "xproj_marker",
"projects": ["*"],
"language": "Rust"
}))
.send()
.await
.expect("rust query request")
.error_for_status()
.expect("rust query status")
.text()
.await
.expect("rust query body");
assert!(
lang_rust.contains("xproj_marker_alpha") && lang_rust.contains("xproj_marker_beta"),
"B1: language=Rust keeps both Rust symbols cross-project: {lang_rust}"
);
let text_all = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/search_text",
opened.session_id
))
.json(&serde_json::json!({ "query": "xproj_marker", "projects": ["*"] }))
.send()
.await
.expect("text all request")
.error_for_status()
.expect("text all status")
.text()
.await
.expect("text all body");
assert!(
text_all.contains("xproj_marker_alpha") && text_all.contains("xproj_marker_beta"),
"B1 control: unscoped cross-project text search finds both projects: {text_all}"
);
let text_scoped = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/search_text",
opened.session_id
))
.json(&serde_json::json!({
"query": "xproj_marker",
"projects": ["*"],
"path_prefix": "no_such_dir"
}))
.send()
.await
.expect("text scoped request")
.error_for_status()
.expect("B1: search_text path_prefix must NOT be refused (200, not 400)")
.text()
.await
.expect("text scoped body");
assert!(
!text_scoped.contains("xproj_marker_alpha")
&& !text_scoped.contains("xproj_marker_beta"),
"B1: non-matching path_prefix must scope BOTH projects' text out (honored): {text_scoped}"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
}
#[tokio::test]
async fn test_cross_project_knowledge_captures_selected_session_projects_only() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project_a = project_dir("symforge-knowledge-a");
let project_b = project_dir("symforge-knowledge-b");
let project_c = project_dir("symforge-knowledge-c");
for (project, source_name, source, document) in [
(
&project_a,
"a.rs",
"pub fn alpha_anchor() {}\n",
"# Alpha knowledge\nQuartz boundary alpha. See [alpha](../src/a.rs).\n",
),
(
&project_b,
"b.rs",
"pub fn beta_anchor() {}\n",
"# Beta knowledge\nQuartz boundary beta. See [beta](../src/b.rs).\n",
),
(
&project_c,
"c.rs",
"pub fn gamma_anchor() {}\n",
"# Gamma knowledge\nQuartz boundary gamma. See [gamma](../src/c.rs).\n",
),
] {
std::fs::create_dir_all(project.path().join("docs")).expect("docs dir");
std::fs::write(project.path().join("src").join(source_name), source)
.expect("source fixture");
std::fs::write(project.path().join("docs").join("knowledge.md"), document)
.expect("knowledge fixture");
}
let handle = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn daemon");
let base_url = format!("http://127.0.0.1:{}", handle.port);
let http = authed_client(&handle);
let opened = http
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "knowledge-xproj".to_string(),
pid: Some(std::process::id()),
})
.send()
.await
.expect("open A")
.error_for_status()
.expect("open A status")
.json::<OpenProjectResponse>()
.await
.expect("open A body");
let project_a_id = opened.project_id.clone();
let project_b_id =
project_key(&canonical_project_root(project_b.path()).expect("canonical B"));
let project_a_alias = project_a
.path()
.file_name()
.and_then(|name| name.to_str())
.expect("A project-name alias")
.to_string();
let project_b_alias = project_b
.path()
.file_name()
.and_then(|name| name.to_str())
.expect("B project-name alias")
.to_string();
for (path, add) in [(project_a.path(), None), (project_b.path(), Some(true))] {
let response = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/index_folder",
opened.session_id
))
.json(&IndexFolderInput {
path: path.display().to_string(),
idempotency_key: None,
add,
allow_protected_root: None,
})
.send()
.await
.expect("index request")
.error_for_status()
.expect("index status")
.text()
.await
.expect("index body");
assert!(
response.contains("Indexed") || response.contains("added to working set"),
"index response: {response}"
);
}
let _other_session = http
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project_c.path().display().to_string(),
client_name: "knowledge-other-session".to_string(),
pid: Some(std::process::id()),
})
.send()
.await
.expect("open C")
.error_for_status()
.expect("open C status")
.json::<OpenProjectResponse>()
.await
.expect("open C body");
let wildcard = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/search_knowledge",
opened.session_id
))
.json(&serde_json::json!({
"query": "quartz boundary",
"projects": ["*"]
}))
.send()
.await
.expect("wildcard request")
.error_for_status()
.expect("wildcard status")
.text()
.await
.expect("wildcard body");
assert!(
wildcard.contains("Quartz boundary alpha"),
"A hit: {wildcard}"
);
assert!(
wildcard.contains("Quartz boundary beta"),
"B hit: {wildcard}"
);
assert!(
!wildcard.contains("Quartz boundary gamma"),
"session wildcard leaked C: {wildcard}"
);
let explicit_b = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/search_knowledge",
opened.session_id
))
.json(&serde_json::json!({
"query": "quartz boundary",
"project": project_b_id
}))
.send()
.await
.expect("B request")
.error_for_status()
.expect("B status")
.text()
.await
.expect("B body");
assert!(
explicit_b.contains("Quartz boundary beta"),
"B hit: {explicit_b}"
);
assert!(
!explicit_b.contains("Quartz boundary alpha") && !explicit_b.contains("src/a.rs"),
"explicit B leaked A hit/bridge: {explicit_b}"
);
let alias_b = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/search_knowledge",
opened.session_id
))
.json(&serde_json::json!({
"query": "quartz boundary",
"project": project_b_alias.clone()
}))
.send()
.await
.expect("B alias request")
.error_for_status()
.expect("B alias status")
.text()
.await
.expect("B alias body");
assert!(
alias_b.contains("Quartz boundary beta"),
"unique project-name aliases must resolve: {alias_b}"
);
assert!(
!alias_b.contains("Quartz boundary alpha") && !alias_b.contains("src/a.rs"),
"project-name alias leaked A hit/bridge: {alias_b}"
);
let reversed_subset = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/search_knowledge",
opened.session_id
))
.json(&serde_json::json!({
"query": "quartz boundary",
"projects": [project_b_alias.clone(), project_a_alias.clone()]
}))
.send()
.await
.expect("subset request")
.error_for_status()
.expect("subset status")
.text()
.await
.expect("subset body");
let mut sorted_ids = [project_a_id.clone(), project_b_id.clone()];
sorted_ids.sort();
let first = reversed_subset
.find(&format!("project: {}", sorted_ids[0]))
.expect("first deterministic project header");
let second = reversed_subset
.find(&format!("project: {}", sorted_ids[1]))
.expect("second deterministic project header");
assert!(
first < second,
"project envelopes must be canonical: {reversed_subset}"
);
let review_subset = |selectors: Vec<String>| {
let http = http.clone();
let url = format!(
"{base_url}/v1/sessions/{}/tools/review_knowledge",
opened.session_id
);
async move {
http.post(url)
.json(&serde_json::json!({
"mode": "remediation",
"projects": selectors,
"limit": 1
}))
.send()
.await
.expect("review subset request")
.error_for_status()
.expect("review subset status")
.text()
.await
.expect("review subset body")
}
};
let reversed_review =
review_subset(vec![project_b_alias.clone(), project_a_alias.clone()]).await;
let forward_review =
review_subset(vec![project_a_alias.clone(), project_b_alias.clone()]).await;
assert_eq!(
reversed_review, forward_review,
"selector order must not affect the captured per-source plans or hashes"
);
assert_eq!(
reversed_review.matches("top_result_hash=").count(),
1,
"one top-level result hash: {reversed_review}"
);
assert_eq!(
reversed_review.matches("review_hash=").count(),
2,
"one isolated plan hash per selected source: {reversed_review}"
);
let review_first = reversed_review
.find(&format!("project: {}", sorted_ids[0]))
.expect("first review project header");
let review_second = reversed_review
.find(&format!("project: {}", sorted_ids[1]))
.expect("second review project header");
assert!(
review_first < review_second,
"review project envelopes must be canonical: {reversed_review}"
);
let conflict = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/search_knowledge",
opened.session_id
))
.json(&serde_json::json!({
"query": "quartz boundary",
"project": project_a_id,
"projects": ["*"]
}))
.send()
.await
.expect("conflict request")
.error_for_status()
.expect("conflict status")
.text()
.await
.expect("conflict body");
assert!(
conflict.contains("mutually exclusive"),
"selector conflict: {conflict}"
);
let unknown = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/search_knowledge",
opened.session_id
))
.json(&serde_json::json!({
"query": "quartz boundary",
"project": "project-not-open"
}))
.send()
.await
.expect("unknown request")
.error_for_status()
.expect("unknown status")
.text()
.await
.expect("unknown body");
assert!(unknown.contains("not open"), "unknown selector: {unknown}");
let review_conflict = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/review_knowledge",
opened.session_id
))
.json(&serde_json::json!({
"mode": "summary",
"project": project_a_id,
"projects": ["*"]
}))
.send()
.await
.expect("review conflict request")
.error_for_status()
.expect("review conflict status")
.text()
.await
.expect("review conflict body");
assert!(
review_conflict.contains("mutually exclusive"),
"review selector conflict: {review_conflict}"
);
let review_unknown = http
.post(format!(
"{base_url}/v1/sessions/{}/tools/review_knowledge",
opened.session_id
))
.json(&serde_json::json!({
"mode": "summary",
"project": "project-not-open"
}))
.send()
.await
.expect("review unknown request")
.error_for_status()
.expect("review unknown status")
.text()
.await
.expect("review unknown body");
assert!(
review_unknown.contains("not open"),
"unknown review selector: {review_unknown}"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
}
#[tokio::test]
async fn test_cross_project_read_is_fresh_after_watcher_reindex() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project_a = project_dir("symforge-fresh-a");
let project_b = project_dir("symforge-fresh-b");
let b_source = project_b.path().join("src").join("b.rs");
std::fs::write(
project_a.path().join("src").join("a.rs"),
"pub fn xproj_marker_alpha() -> u32 { 1 }\n",
)
.expect("write source a");
std::fs::write(&b_source, "pub fn xproj_marker_beta() -> u32 { 2 }\n")
.expect("write source b");
let handle = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn daemon");
let base_url = format!("http://127.0.0.1:{}", handle.port);
let http = authed_client(&handle);
let opened = http
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "fresh".to_string(),
pid: Some(std::process::id()),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let session_id = opened.session_id.clone();
let canonical_b = canonical_project_root(project_b.path()).expect("canonical b");
let project_b_id = project_key(&canonical_b);
http.post(format!(
"{base_url}/v1/sessions/{session_id}/tools/index_folder"
))
.json(&IndexFolderInput {
path: project_a.path().display().to_string(),
idempotency_key: None,
add: None,
allow_protected_root: None,
})
.send()
.await
.expect("index A request")
.error_for_status()
.expect("index A status");
http.post(format!(
"{base_url}/v1/sessions/{session_id}/tools/index_folder"
))
.json(&IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: Some(true),
allow_protected_root: None,
})
.send()
.await
.expect("index B request")
.error_for_status()
.expect("index B status");
let baseline = http
.post(format!(
"{base_url}/v1/sessions/{session_id}/tools/search_symbols"
))
.json(&serde_json::json!({ "query": "xproj_marker", "projects": ["*"] }))
.send()
.await
.expect("baseline request")
.error_for_status()
.expect("baseline status")
.text()
.await
.expect("baseline body");
assert!(
baseline.contains("xproj_marker_beta"),
"baseline cross-read must surface B's original symbol: {baseline}"
);
assert!(
!baseline.contains("xproj_marker_gamma"),
"baseline must NOT yet contain the not-written symbol: {baseline}"
);
let b_key = BaseKey::new(canonical_b.clone(), CommitId::Dirtyless);
let gen_before =
state_base_generation(&handle.state, &b_key).expect("B base interned at open");
let key_count_before = handle.state.bases.read().len();
let canonical_a = canonical_project_root(project_a.path()).expect("canonical a");
let a_key = BaseKey::new(canonical_a, CommitId::Dirtyless);
let a_gen_before =
state_base_generation(&handle.state, &a_key).expect("A base interned at open");
std::fs::write(&b_source, "pub fn xproj_marker_gamma() -> u32 { 3 }\n")
.expect("rewrite source b");
{
let index = {
let projects = handle.state.projects.read();
let slot = projects
.get(&project_b_id)
.expect("project B loaded in daemon");
Arc::clone(&slot.metadata.read().index)
};
index
.reload(&canonical_b)
.expect("deterministic B reload (watcher-equivalent publish)");
}
let fresh = http
.post(format!(
"{base_url}/v1/sessions/{session_id}/tools/search_symbols"
))
.json(&serde_json::json!({ "query": "xproj_marker", "projects": ["*"] }))
.send()
.await
.expect("fresh request")
.error_for_status()
.expect("fresh status")
.text()
.await
.expect("fresh body");
assert!(
fresh.contains("xproj_marker_gamma"),
"SC-1: cross-read after watcher reindex must surface B's NEW symbol: {fresh}"
);
assert!(
!fresh.contains("xproj_marker_beta"),
"SC-2: cross-read must NOT surface B's DELETED symbol (stale ghost): {fresh}"
);
assert!(
fresh.contains("xproj_marker_alpha"),
"A must remain present after B's refresh: {fresh}"
);
let gen_after = state_base_generation(&handle.state, &b_key)
.expect("B base still interned after refresh");
assert!(
gen_after > gen_before,
"control: force-replace must advance B's base_generation \
(before={gen_before}, after={gen_after}); a frozen base would not"
);
let a_gen_after = state_base_generation(&handle.state, &a_key)
.expect("A base still interned after refresh");
assert_eq!(
a_gen_after, a_gen_before,
"mismatch-gate: untouched project A must NOT be re-interned \
(before={a_gen_before}, after={a_gen_after})"
);
{
let bases = handle.state.bases.read();
let table_base = bases.get(&b_key).expect("B base in table after refresh");
let sessions = handle.state.sessions.read();
let session = sessions.get(&session_id).expect("session present");
let ws = session.working_set.read();
let entry = ws.get(&project_b_id).expect("B entry in working set");
assert!(
Arc::ptr_eq(table_base, &entry.base),
"SC-002: the working-set entry must share the SAME interned base Arc"
);
assert_eq!(
bases.len(),
key_count_before,
"SC-002: force-replace must REPLACE the value, not add a duplicate key"
);
}
std::fs::write(&b_source, "pub fn xproj_marker_delta() -> u32 { 4 }\n")
.expect("rewrite source b (delta)");
{
let index = {
let projects = handle.state.projects.read();
let slot = projects
.get(&project_b_id)
.expect("project B loaded in daemon");
Arc::clone(&slot.metadata.read().index)
};
index
.reload(&canonical_b)
.expect("deterministic B reload (delta)");
}
let lone_b = http
.post(format!(
"{base_url}/v1/sessions/{session_id}/tools/search_symbols"
))
.json(&serde_json::json!({ "query": "xproj_marker", "projects": [project_b_id] }))
.send()
.await
.expect("lone-B request")
.error_for_status()
.expect("lone-B status")
.text()
.await
.expect("lone-B body");
assert!(
lone_b.contains("xproj_marker_delta"),
"lone non-active target: refresh must fire for Targets::One(B) too: {lone_b}"
);
assert!(
!lone_b.contains("xproj_marker_gamma"),
"lone non-active target: B's superseded symbol must be gone: {lone_b}"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
}
fn state_base_generation(state: &SharedDaemonState, key: &BaseKey) -> Option<u64> {
state.bases.read().get(key).map(|b| b.base_generation)
}
#[test]
fn test_cross_project_symbols_output_is_capped_and_discloses_truncation() {
use crate::live_index::search::SymbolMatchTier;
use crate::live_index::view::{ProjectHit, ViewSymbolHit};
let hits: Vec<ProjectHit<ViewSymbolHit>> = (0..5)
.map(|i| ProjectHit {
project_id: if i < 3 { "proj-a" } else { "proj-b" }.to_string(),
hit: ViewSymbolHit {
name: format!("sym_{i}"),
path: format!("src/f{i}.rs"),
kind: "fn".to_string(),
line: i + 1,
tier: SymbolMatchTier::Exact,
},
})
.collect();
let capped = format_cross_project_symbols(&hits, "sym", true, 2);
assert!(
capped.starts_with("2 of 5 matches across projects (truncated;"),
"header must disclose shown-of-total truncation: {capped}"
);
assert!(
capped.contains("query a single project for the full set"),
"truncation must carry the corrective hint: {capped}"
);
assert!(capped.contains("sym_0") && capped.contains("sym_1"));
assert!(
!capped.contains("sym_2") && !capped.contains("sym_4"),
"hits beyond the cap must NOT be rendered: {capped}"
);
let full = format_cross_project_symbols(&hits, "sym", true, 100);
assert!(
full.starts_with("5 matches across projects\n"),
"uncapped header must not claim truncation: {full}"
);
assert!(
full.contains("sym_4"),
"all hits rendered when under cap: {full}"
);
assert!(
!full.contains("truncated"),
"no truncation notice when under cap: {full}"
);
}
#[test]
fn test_cross_project_result_cap_clamps_limit() {
assert_eq!(
cross_project_result_cap(None),
CROSS_PROJECT_DEFAULT_RESULT_CAP,
"no limit -> default cap"
);
assert_eq!(
cross_project_result_cap(Some(10)),
10,
"small limit honored"
);
assert_eq!(
cross_project_result_cap(Some(0)),
1,
"zero clamps up to 1 (cap never disabled)"
);
assert_eq!(
cross_project_result_cap(Some(u32::MAX)),
CROSS_PROJECT_MAX_RESULT_CAP,
"absurd limit clamps to the hard ceiling"
);
}
#[test]
fn test_cross_project_token_budget_truncates_and_discloses() {
let body = (0..50)
.map(|i| format!("line {i} with some content\n"))
.collect::<String>();
let out = apply_cross_project_token_budget(body.clone(), Some(10));
assert!(out.len() < body.len(), "budget must shrink the body");
assert!(
out.contains("truncated to fit max_tokens=10"),
"truncation must be disclosed: {out}"
);
assert!(
out.ends_with('\n'),
"truncated body ends on a line boundary"
);
assert_eq!(apply_cross_project_token_budget(body.clone(), None), body);
assert_eq!(
apply_cross_project_token_budget(body.clone(), Some(0)),
body
);
}
#[test]
fn test_reject_unsupported_cross_project_scoping_per_tool() {
use serde_json::json;
assert!(
reject_unsupported_cross_project_scoping(
"search_symbols",
&json!({ "query": "x", "path_prefix": "src/" }),
)
.is_ok(),
"path_prefix is now honored cross-project and must NOT be refused"
);
assert!(
reject_unsupported_cross_project_scoping(
"search_symbols",
&json!({ "query": "x", "language": "Rust" }),
)
.is_ok(),
"language is now honored cross-project and must NOT be refused"
);
assert!(
reject_unsupported_cross_project_scoping(
"search_symbols",
&json!({ "query": "x", "kind": "fn" }),
)
.is_ok(),
"kind IS honored cross-project and must NOT be refused"
);
assert!(
reject_unsupported_cross_project_scoping(
"search_text",
&json!({ "query": "x", "path_prefix": "src/", "language": "Rust" }),
)
.is_ok(),
"search_text path_prefix/language are now honored cross-project"
);
let structural_err = reject_unsupported_cross_project_scoping(
"search_text",
&json!({ "query": "x", "structural": true }),
)
.expect_err("structural must be refused");
assert!(
structural_err
.to_string()
.contains("structural scoping is not supported")
&& structural_err
.to_string()
.contains("query a single project for scoped results"),
"structural refusal must name the param + corrective hint: {structural_err}"
);
for (field, value) in [
("path", json!("src/db.rs")),
("symbol_kind", json!("fn")),
("direction", json!("trait")),
] {
let err = reject_unsupported_cross_project_scoping(
"find_references",
&json!({ "name": "x", field: value }),
)
.unwrap_err()
.to_string();
assert!(
err.contains(&format!("{field} scoping is not supported")),
"{field} must be refused on find_references: {err}"
);
}
assert!(
reject_unsupported_cross_project_scoping(
"find_references",
&json!({ "name": "x", "path": " " }),
)
.is_ok(),
"blank path value must not trip the refusal"
);
}
#[test]
fn test_execute_cross_project_read_rejects_scoping_before_query() {
use crate::live_index::store::LiveIndex;
use crate::live_index::view::{BaseKey, CommitId, IndexBase, WorkingSet};
use serde_json::json;
let base = Arc::new(IndexBase::new(
BaseKey::new("/synthetic/root", CommitId::Dirtyless),
Arc::new(LiveIndex::empty_live_index()),
1,
));
let mut ws = WorkingSet::new();
ws.add("proj-x", base);
let err = execute_cross_project_read(
"find_references",
json!({ "name": "anything", "direction": "trait" }),
Targets::Subset(vec!["proj-x".to_string()]),
&ws,
)
.expect_err("scoping param must be refused");
assert!(
err.to_string()
.contains("direction scoping is not supported with cross-project targeting"),
"cross-project read must refuse the unsupported scoping param: {err}"
);
}
#[tokio::test]
async fn test_daemon_is_fail_closed_without_env_token() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _home_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let _bind_guard = EnvVarGuard::unset(DAEMON_BIND_ENV);
let _allow_guard = EnvVarGuard::unset(DAEMON_ALLOW_NON_LOOPBACK_ENV);
let _auth_guard = EnvVarGuard::unset(DAEMON_AUTH_TOKEN_ENV);
let project = project_dir("symforge-daemon-failclosed");
let control_state_dir = test_control_state(daemon_home.path());
let handle = spawn_daemon_at("127.0.0.1", &control_state_dir)
.await
.expect("spawn daemon");
let base_url = format!("http://127.0.0.1:{}", handle.port);
let token_path = test_daemon_path(daemon_home.path(), daemon_token_file_name());
assert!(
token_path.exists(),
"daemon must persist an auth token file even without an env pin"
);
let file_token = std::fs::read_to_string(&token_path)
.expect("read token file")
.trim()
.to_string();
assert!(!file_token.is_empty(), "persisted token must be non-empty");
assert_eq!(
file_token, handle.state.auth_token,
"the persisted token must match the token the daemon enforces"
);
let bare = reqwest::Client::new();
let health_body = bare
.get(format!("{base_url}/health"))
.send()
.await
.expect("health request")
.error_for_status()
.expect("health status")
.text()
.await
.expect("health body");
assert!(
!health_body.contains(&file_token),
"health body must not leak the auth token"
);
let health: DaemonHealth = serde_json::from_str(&health_body).expect("health json");
assert!(health.auth_required, "auth must always be required");
let unauth = bare
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "codex".to_string(),
pid: Some(7000),
})
.send()
.await
.expect("unauth open request");
assert_eq!(
unauth.status(),
StatusCode::UNAUTHORIZED,
"a request without the token must be rejected"
);
let opened = bare
.post(format!("{base_url}/v1/sessions/open"))
.bearer_auth(&file_token)
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "codex".to_string(),
pid: Some(7000),
})
.send()
.await
.expect("authed open request")
.error_for_status()
.expect("authed open status")
.json::<OpenProjectResponse>()
.await
.expect("authed open body");
assert!(!opened.session_id.is_empty());
assert_eq!(
resolve_daemon_auth_token_at(&control_state_dir).as_deref(),
Some(file_token.as_str()),
"client token resolution must read the persisted token file"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
}
#[tokio::test]
async fn test_daemon_executes_session_scoped_tool_calls() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project = project_dir("symforge-daemon-tool");
std::fs::write(project.path().join("src").join("main.rs"), "fn main() {}\n")
.expect("write source");
let handle = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn daemon");
let client = authed_client(&handle);
let base_url = format!("http://127.0.0.1:{}", handle.port);
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "codex".to_string(),
pid: Some(9001),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let response = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/get_repo_map",
opened.session_id
))
.json(&serde_json::json!({
"detail": "full"
}))
.send()
.await
.expect("tool request");
assert!(
response.status().is_success(),
"tool endpoint should succeed, got {}",
response.status()
);
let body = response.text().await.expect("tool body");
assert!(
body.contains("main.rs"),
"repo outline should include the indexed file, got: {body}"
);
let search_files = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/search_files",
opened.session_id
))
.json(&serde_json::json!({
"query": "main.rs",
"limit": 5
}))
.send()
.await
.expect("search_files request");
assert!(
search_files.status().is_success(),
"search_files endpoint should succeed, got {}",
search_files.status()
);
let search_files_body = search_files.text().await.expect("search_files body");
assert!(
search_files_body.contains("src/main.rs"),
"search_files should return the indexed file, got: {search_files_body}"
);
let resolved_path = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/search_files",
opened.session_id
))
.json(&serde_json::json!({
"query": "main.rs",
"resolve": true
}))
.send()
.await
.expect("search_files resolve request");
assert!(
resolved_path.status().is_success(),
"search_files resolve mode should succeed, got {}",
resolved_path.status()
);
let resolved_path_body = resolved_path
.text()
.await
.expect("search_files resolve body");
assert!(
resolved_path_body.contains("src/main.rs"),
"search_files resolve mode should return the indexed file, got: {resolved_path_body}"
);
let curation_preview = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/curate_knowledge",
opened.session_id
))
.json(&serde_json::json!({
"project": opened.project_id.clone(),
"actions": [{
"action_id": "action-daemon-route-oracle",
"mutation": {
"operation": "upsert",
"entry": {
"entry_id": "entry-daemon-route-oracle",
"target": {
"path": "src/main.rs",
"content_hash": "0".repeat(64)
},
"lifecycle": "unknown",
"evidence": [],
"justification_code": "daemon-route-oracle"
}
}
}],
"if_source_review_hash": "0".repeat(64),
"if_manifest_digest": "0".repeat(64),
"if_policy_digest": "0".repeat(64)
}))
.send()
.await
.expect("curate_knowledge preview request")
.error_for_status()
.expect("curate_knowledge preview status")
.text()
.await
.expect("curate_knowledge preview body");
assert!(
curation_preview.contains("stale_review_hash"),
"daemon must dispatch curate_knowledge to the project runtime: {curation_preview}"
);
let reused = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "codex-reused".to_string(),
pid: Some(9002),
})
.send()
.await
.expect("reused open request")
.error_for_status()
.expect("reused open status")
.json::<OpenProjectResponse>()
.await
.expect("reused open body");
assert_eq!(reused.project_id, opened.project_id);
assert_ne!(reused.session_id, opened.session_id);
let health = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/health_compact",
reused.session_id
))
.json(&serde_json::json!({}))
.send()
.await
.expect("health request")
.error_for_status()
.expect("health status")
.text()
.await
.expect("health body");
assert!(
health.contains("Runtime: mode=daemon_reused_session"),
"daemon health should distinguish reused daemon sessions, got: {health}"
);
assert!(
health.contains(&format!("project_root={}", reused.canonical_root)),
"daemon health should surface canonical project root, got: {health}"
);
assert!(
health.contains(&format!("project_id={}", reused.project_id)),
"daemon health should surface daemon project id, got: {health}"
);
assert!(
health.contains(&format!("session_id={}", reused.session_id)),
"daemon health should surface daemon session id, got: {health}"
);
assert!(
health.contains("index_id=index-"),
"daemon health should surface index identity, got: {health}"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
}
#[tokio::test]
async fn test_daemon_executes_checkpoint_now_tool_call() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project = project_dir("symforge-daemon-checkpoint");
std::fs::write(project.path().join("src").join("main.rs"), "fn main() {}\n")
.expect("write source");
let handle = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn daemon");
let client = authed_client(&handle);
let base_url = format!("http://127.0.0.1:{}", handle.port);
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "codex".to_string(),
pid: Some(9101),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let response = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/checkpoint_now",
opened.session_id
))
.json(&serde_json::json!({
"verify_after_write": true
}))
.send()
.await
.expect("checkpoint_now request");
assert!(
response.status().is_success(),
"checkpoint_now endpoint should succeed, got {}",
response.status()
);
let body = response.text().await.expect("checkpoint_now body");
assert!(
body.contains("Checkpoint complete"),
"checkpoint_now should report completion, got: {body}"
);
assert!(
!body.contains("unavailable in daemon-proxy mode"),
"checkpoint_now must not hard-fail in daemon-proxy mode, got: {body}"
);
assert!(
!body.contains("unknown tool"),
"daemon must dispatch checkpoint_now, got: {body}"
);
let canonical_root = PathBuf::from(&opened.canonical_root);
let RootResolution::Bound(binding) = crate::discovery::resolve_root_candidate(
&canonical_root,
RootCandidateSource::LaunchCwd,
RootRequestMode::Automatic,
) else {
panic!("opened daemon root must remain bound");
};
let state_placement = crate::discovery::resolve_state_placement(&binding);
assert!(
crate::live_index::persist::load_snapshot(&canonical_root, &state_placement).is_some(),
"checkpoint should write a loadable snapshot under {}/.symforge/index.bin",
canonical_root.display()
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
}
#[tokio::test]
async fn test_daemon_port_if_compatible_accepts_matching_identity() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let health = DaemonState::new().health();
let (port, shutdown_tx) = spawn_fake_health_server(health).await;
std::fs::write(
test_daemon_path(daemon_home.path(), LEGACY_DAEMON_PORT_FILE),
port.to_string(),
)
.expect("write daemon port");
let identity = current_daemon_identity();
let selected =
daemon_port_if_compatible_at(&test_control_state(daemon_home.path()), &identity)
.await
.expect("compatible health lookup");
assert_eq!(selected, Some(port));
let _ = shutdown_tx.send(());
}
#[tokio::test]
async fn test_daemon_port_if_compatible_rejects_version_mismatch() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let health = DaemonHealth {
project_count: 0,
session_count: 0,
daemon_version: "0.0.0".to_string(),
executable_path: current_daemon_identity().executable_path,
auth_required: false,
pid: None,
};
let (port, shutdown_tx) = spawn_fake_health_server(health).await;
std::fs::write(
test_daemon_path(daemon_home.path(), LEGACY_DAEMON_PORT_FILE),
port.to_string(),
)
.expect("write daemon port");
let identity = current_daemon_identity();
let selected =
daemon_port_if_compatible_at(&test_control_state(daemon_home.path()), &identity)
.await
.expect("mismatch health lookup");
assert_eq!(selected, None);
let _ = shutdown_tx.send(());
}
#[test]
fn test_daemon_health_matches_recorded_pid_requires_exact_pid() {
let mut health = DaemonHealth {
project_count: 0,
session_count: 0,
daemon_version: current_daemon_identity().version,
executable_path: current_daemon_identity().executable_path,
auth_required: false,
pid: Some(42),
};
assert!(daemon_health_matches_recorded_pid(&health, 42));
assert!(!daemon_health_matches_recorded_pid(&health, 43));
health.pid = None;
assert!(!daemon_health_matches_recorded_pid(&health, 42));
}
#[tokio::test]
async fn test_stop_incompatible_recorded_daemon_does_not_kill_unrelated_pid() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
#[cfg(windows)]
let mut child = crate::process_util::hidden_command("powershell")
.args(["-NoProfile", "-Command", "Start-Sleep -Seconds 30"])
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null())
.spawn()
.expect("spawn long-running child");
#[cfg(not(windows))]
let mut child = crate::process_util::hidden_command("sleep")
.arg("30")
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null())
.spawn()
.expect("spawn long-running child");
let child_pid = child.id();
let health = DaemonHealth {
project_count: 0,
session_count: 0,
daemon_version: current_daemon_identity().version,
executable_path: "C:/unrelated/not-symforge-daemon.exe".to_string(),
auth_required: false,
pid: Some(child_pid),
};
let (port, shutdown_tx) = spawn_fake_health_server(health).await;
std::fs::write(
test_daemon_path(daemon_home.path(), LEGACY_DAEMON_PORT_FILE),
port.to_string(),
)
.expect("write daemon port");
std::fs::write(
test_daemon_path(daemon_home.path(), LEGACY_DAEMON_PID_FILE),
child_pid.to_string(),
)
.expect("write daemon pid");
stop_incompatible_recorded_daemon_at(
&test_control_state(daemon_home.path()),
¤t_daemon_identity(),
)
.await
.expect("stop incompatible daemon");
assert!(
child.try_wait().expect("poll child").is_none(),
"daemon pid safety checks must not terminate unrelated processes"
);
let _ = child.kill();
let _ = child.wait();
let _ = shutdown_tx.send(());
}
#[tokio::test]
async fn test_stop_incompatible_recorded_daemon_cleans_port_file_without_pid() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let health = DaemonHealth {
project_count: 0,
session_count: 0,
daemon_version: "0.0.0".to_string(),
executable_path: current_daemon_identity().executable_path,
auth_required: false,
pid: None,
};
let (port, shutdown_tx) = spawn_fake_health_server(health).await;
std::fs::write(
test_daemon_path(daemon_home.path(), LEGACY_DAEMON_PORT_FILE),
port.to_string(),
)
.expect("write daemon port");
stop_incompatible_recorded_daemon_at(
&test_control_state(daemon_home.path()),
¤t_daemon_identity(),
)
.await
.expect("stop incompatible daemon");
assert!(
!test_daemon_path(daemon_home.path(), LEGACY_DAEMON_PORT_FILE).exists(),
"incompatible daemon port file should be cleared"
);
let _ = shutdown_tx.send(());
}
#[tokio::test]
async fn test_daemon_serves_session_scoped_repo_map_hook_endpoint() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project = project_dir("symforge-daemon-hook");
std::fs::write(project.path().join("src").join("main.rs"), "fn main() {}\n")
.expect("write source");
let handle = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn daemon");
let client = authed_client(&handle);
let base_url = format!("http://127.0.0.1:{}", handle.port);
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "claude".to_string(),
pid: Some(77),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let response = client
.get(format!(
"{base_url}/v1/sessions/{}/sidecar/repo-map",
opened.session_id
))
.send()
.await
.expect("hook request");
assert!(
response.status().is_success(),
"repo-map hook endpoint should succeed, got {}",
response.status()
);
let body = response.text().await.expect("hook body");
assert!(
body.contains("Index: 1 files, 1 symbols"),
"repo-map hook output should come from daemon project instance, got: {body}"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
}
#[tokio::test]
async fn test_daemon_workflow_repo_start_endpoint_matches_repo_map_route() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project = project_dir("symforge-daemon-workflow-repo-start");
std::fs::write(project.path().join("src").join("main.rs"), "fn main() {}\n")
.expect("write source");
let handle = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn daemon");
let client = authed_client(&handle);
let base_url = format!("http://127.0.0.1:{}", handle.port);
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "claude".to_string(),
pid: Some(78),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let canonical = client
.get(format!(
"{base_url}/v1/sessions/{}/sidecar/repo-map",
opened.session_id
))
.send()
.await
.expect("canonical request")
.error_for_status()
.expect("canonical status")
.text()
.await
.expect("canonical body");
let workflow = client
.get(format!(
"{base_url}/v1/sessions/{}/sidecar/workflows/repo-start",
opened.session_id
))
.send()
.await
.expect("workflow request")
.error_for_status()
.expect("workflow status")
.text()
.await
.expect("workflow body");
assert_eq!(
workflow, canonical,
"workflow repo-start route should stay identical to the canonical repo-map route"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
}
#[tokio::test]
async fn test_daemon_serves_session_scoped_prompt_context_hook_endpoint() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project = project_dir("symforge-daemon-prompt-hook");
std::fs::write(project.path().join("src").join("main.rs"), "fn main() {}\n")
.expect("write source");
let handle = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn daemon");
let client = authed_client(&handle);
let base_url = format!("http://127.0.0.1:{}", handle.port);
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "claude".to_string(),
pid: Some(88),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let response = client
.get(format!(
"{base_url}/v1/sessions/{}/sidecar/prompt-context",
opened.session_id
))
.query(&[("text", "please inspect src/main.rs")])
.send()
.await
.expect("hook request");
assert!(
response.status().is_success(),
"prompt-context hook endpoint should succeed, got {}",
response.status()
);
let body = response.text().await.expect("hook body");
assert!(
body.contains("src/main.rs") && body.contains("main"),
"prompt-context hook output should come from daemon project instance, got: {body}"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
}
#[tokio::test]
async fn test_daemon_workflow_prompt_context_endpoint_matches_canonical_route() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project = project_dir("symforge-daemon-workflow-prompt-context");
std::fs::write(project.path().join("src").join("main.rs"), "fn main() {}\n")
.expect("write source");
let handle = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn daemon");
let client = authed_client(&handle);
let base_url = format!("http://127.0.0.1:{}", handle.port);
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "claude".to_string(),
pid: Some(89),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let canonical = client
.get(format!(
"{base_url}/v1/sessions/{}/sidecar/prompt-context",
opened.session_id
))
.query(&[("text", "please inspect src/main.rs")])
.send()
.await
.expect("canonical request")
.error_for_status()
.expect("canonical status")
.text()
.await
.expect("canonical body");
let workflow = client
.get(format!(
"{base_url}/v1/sessions/{}/sidecar/workflows/prompt-context",
opened.session_id
))
.query(&[("text", "please inspect src/main.rs")])
.send()
.await
.expect("workflow request")
.error_for_status()
.expect("workflow status")
.text()
.await
.expect("workflow body");
assert_eq!(
workflow, canonical,
"workflow prompt-context route should stay identical to the canonical prompt-context route"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
}
#[tokio::test]
async fn test_index_folder_open_keeps_immutable_home() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project_a = project_dir("symforge-daemon-a");
let project_b = project_dir("symforge-daemon-b");
std::fs::write(
project_a.path().join("src").join("old.rs"),
"fn old_fn() {}\n",
)
.expect("write source a");
std::fs::write(
project_b.path().join("src").join("new.rs"),
"fn new_fn() {}\n",
)
.expect("write source b");
let handle = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn daemon");
let client = authed_client(&handle);
let base_url = format!("http://127.0.0.1:{}", handle.port);
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "codex".to_string(),
pid: Some(55),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let reload = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/index_folder",
opened.session_id
))
.json(&IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: None,
allow_protected_root: None,
})
.send()
.await
.expect("index request")
.error_for_status()
.expect("index status")
.text()
.await
.expect("index body");
assert!(
reload.contains("Indexed"),
"index_folder should report success, got: {reload}"
);
let target_sessions = client
.get(format!(
"{base_url}/v1/projects/{}/sessions",
project_key(&canonical_project_root(project_b.path()).expect("canonical root"))
))
.send()
.await
.expect("session list request")
.error_for_status()
.expect("session list status")
.json::<Vec<SessionSummary>>()
.await
.expect("session list body");
assert_eq!(target_sessions.len(), 1);
assert_eq!(target_sessions[0].session_id, opened.session_id);
let home_sessions = client
.get(format!(
"{base_url}/v1/projects/{}/sessions",
opened.project_id
))
.send()
.await
.expect("home session list request")
.error_for_status()
.expect("home session list status")
.json::<Vec<SessionSummary>>()
.await
.expect("home session list body");
assert_eq!(home_sessions.len(), 1, "opening B must not evict home A");
assert_eq!(home_sessions[0].session_id, opened.session_id);
let outline = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/get_repo_map",
opened.session_id
))
.json(&serde_json::json!({
"detail": "full"
}))
.send()
.await
.expect("outline request")
.error_for_status()
.expect("outline status")
.text()
.await
.expect("outline body");
assert!(
outline.contains("old.rs"),
"unqualified reads must remain bound to immutable home A: {outline}"
);
assert!(
!outline.contains("new.rs"),
"opening B must not retarget unqualified reads away from home A: {outline}"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
}
#[tokio::test]
async fn test_project_routing_parity_table() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project_a = project_dir("symforge-route-home-a");
let project_b = project_dir("symforge-route-open-b");
std::fs::write(
project_a.path().join("src").join("old.rs"),
"fn old_fn() {}\n",
)
.expect("write source a");
std::fs::write(
project_b.path().join("src").join("new.rs"),
"fn new_fn() {}\n",
)
.expect("write source b");
let handle = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn daemon");
let client = authed_client(&handle);
let base_url = format!("http://127.0.0.1:{}", handle.port);
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "route-parity".to_string(),
pid: Some(77),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let project_b_id =
project_key(&canonical_project_root(project_b.path()).expect("canonical b"));
let opened_b = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/index_folder",
opened.session_id
))
.json(&IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: None,
allow_protected_root: None,
})
.send()
.await
.expect("open B request")
.error_for_status()
.expect("open B status")
.text()
.await
.expect("open B body");
assert!(opened_b.contains("Indexed"), "open B: {opened_b}");
let call = |tool: &str, body: serde_json::Value| {
let client = client.clone();
let url = format!("{base_url}/v1/sessions/{}/tools/{tool}", opened.session_id);
async move {
client
.post(url)
.json(&body)
.send()
.await
.expect("tool request")
.error_for_status()
.expect("tool status")
.text()
.await
.expect("tool body")
}
};
let map_b = call(
"get_repo_map",
serde_json::json!({"detail": "full", "project": project_b_id}),
)
.await;
assert!(
map_b.contains("new.rs") && !map_b.contains("old.rs"),
"explicit project must serve B: {map_b}"
);
let map_home = call("get_repo_map", serde_json::json!({"detail": "full"})).await;
assert!(
map_home.contains("old.rs") && !map_home.contains("new.rs"),
"omission must serve immutable home A: {map_home}"
);
let content_b = call(
"get_file_content",
serde_json::json!({"path": "src/new.rs", "project": project_b_id}),
)
.await;
assert!(
content_b.contains("fn new_fn"),
"explicit project read must return B's bytes: {content_b}"
);
let content_home = call(
"get_file_content",
serde_json::json!({"path": "src/new.rs"}),
)
.await;
assert!(
!content_home.contains("fn new_fn"),
"home read must not leak B's bytes: {content_home}"
);
let files_b = call(
"search_files",
serde_json::json!({"query": "new.rs", "project": project_b_id}),
)
.await;
assert!(
files_b.contains("new.rs"),
"explicit project search_files must serve B: {files_b}"
);
let unknown = call(
"get_repo_map",
serde_json::json!({"detail": "full", "project": "no-such-project"}),
)
.await;
assert!(
unknown.contains("not open") && unknown.contains(&project_b_id),
"unknown selector must return candidates: {unknown}"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
}
#[tokio::test]
async fn test_search_files_projects_fan_out() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project_a = project_dir("symforge-files-home-a");
let project_b = project_dir("symforge-files-open-b");
std::fs::write(
project_a.path().join("src").join("widget_old.rs"),
"fn old_fn() {}\n",
)
.expect("write source a");
std::fs::write(
project_b.path().join("src").join("widget_new.rs"),
"fn new_fn() {}\n",
)
.expect("write source b");
let handle = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn daemon");
let client = authed_client(&handle);
let base_url = format!("http://127.0.0.1:{}", handle.port);
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "files-fan-out".to_string(),
pid: Some(78),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let project_b_id =
project_key(&canonical_project_root(project_b.path()).expect("canonical b"));
let opened_b = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/index_folder",
opened.session_id
))
.json(&IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: None,
allow_protected_root: None,
})
.send()
.await
.expect("open B request")
.error_for_status()
.expect("open B status")
.text()
.await
.expect("open B body");
assert!(opened_b.contains("Indexed"), "open B: {opened_b}");
let call = |body: serde_json::Value| {
let client = client.clone();
let url = format!(
"{base_url}/v1/sessions/{}/tools/search_files",
opened.session_id
);
async move {
client
.post(url)
.json(&body)
.send()
.await
.expect("tool request")
.error_for_status()
.expect("tool status")
.text()
.await
.expect("tool body")
}
};
let all = call(serde_json::json!({"query": "widget", "projects": ["*"]})).await;
assert!(
all.contains("widget_old.rs") && all.contains("widget_new.rs"),
"wildcard fan-out must surface both projects' files: {all}"
);
assert!(
all.contains(&format!("project: {}", opened.project_id))
&& all.contains(&format!("project: {project_b_id}")),
"multi-target output must attribute hits by project: {all}"
);
let only_b = call(serde_json::json!({"query": "widget", "projects": [project_b_id]})).await;
assert!(
only_b.contains("widget_new.rs") && !only_b.contains("widget_old.rs"),
"single-target fan-out must serve only B: {only_b}"
);
assert!(
!only_b.contains("── project:"),
"single-target output renders flat: {only_b}"
);
let refused =
call(serde_json::json!({"query": "widget", "resolve": true, "projects": ["*"]})).await;
assert!(
refused.contains("not supported with cross-project targeting"),
"resolve mode must refuse cross-project targeting: {refused}"
);
let conflict = call(serde_json::json!({
"query": "widget",
"project": opened.project_id,
"projects": [project_b_id],
}))
.await;
assert!(
conflict.contains("mutually exclusive"),
"project+projects must be rejected: {conflict}"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
}
#[tokio::test]
async fn test_test_builds_never_auto_spawn_daemon_processes() {
let error = spawn_daemon_process().expect_err("test build must refuse to spawn");
assert!(
error.to_string().contains("test build"),
"refusal must name the test-build guard: {error}"
);
let _env_lock = env_lock().await;
let empty_home = TempDir::new().expect("empty home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", empty_home.path());
let error = ensure_daemon_running_at(&test_control_state(empty_home.path()))
.await
.expect_err("no daemon + no spawn must error");
assert!(
error.to_string().contains("auto-spawn is disabled"),
"ensure_daemon_running must fail fast without spawning: {error}"
);
}
#[tokio::test]
async fn test_reconnect_reopens_home_and_working_set() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project_a = project_dir("symforge-reconnect-home-a");
let project_b = project_dir("symforge-reconnect-open-b");
std::fs::write(
project_a.path().join("src").join("old.rs"),
"fn old_fn() {}\n",
)
.expect("write source a");
std::fs::write(
project_b.path().join("src").join("new.rs"),
"fn new_fn() {}\n",
)
.expect("write source b");
let first = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn first daemon");
let base_url = format!("http://127.0.0.1:{}", first.port);
let http = authed_client(&first);
let opened = http
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "reconnect".to_string(),
pid: Some(std::process::id()),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let client = DaemonSessionClient::new_for_test_at(
base_url.clone(),
opened.project_id.clone(),
opened.session_id.clone(),
opened.project_name.clone(),
test_control_state(daemon_home.path()),
)
.with_project_root(project_a.path().to_path_buf());
let server = crate::protocol::SymForgeServer::new_daemon_proxy(client);
let opened_b = server
.index_folder(Parameters(IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: None,
allow_protected_root: None,
}))
.await;
assert!(opened_b.starts_with("Indexed "), "open B: {opened_b}");
let project_b_id =
project_key(&canonical_project_root(project_b.path()).expect("canonical b"));
let _ = first.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
daemon_port_file_name(),
))
.await;
let second = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn second daemon");
let map_b_input = serde_json::from_value(serde_json::json!({
"detail": "full",
"project": project_b_id,
}))
.expect("map input");
let map_b = server.get_repo_map(Parameters(map_b_input)).await;
assert!(
map_b.contains("new.rs") && !map_b.contains("old.rs"),
"explicit B must remain routable after reconnect: {map_b}"
);
let map_home_input =
serde_json::from_value(serde_json::json!({"detail": "full"})).expect("home input");
let map_home = server.get_repo_map(Parameters(map_home_input)).await;
assert!(
map_home.contains("old.rs") && !map_home.contains("new.rs"),
"home must survive reconnect unchanged: {map_home}"
);
let _ = second.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
}
#[tokio::test]
async fn test_tool_receipt_carries_project_evidence() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project_a = project_dir("symforge-receipt-home-a");
let project_b = project_dir("symforge-receipt-open-b");
std::fs::write(
project_a.path().join("src").join("old.rs"),
"fn old_fn() {}\n",
)
.expect("write source a");
std::fs::write(
project_b.path().join("src").join("new.rs"),
"fn new_fn() {}\n",
)
.expect("write source b");
let handle = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn daemon");
let client = authed_client(&handle);
let base_url = format!("http://127.0.0.1:{}", handle.port);
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "receipt".to_string(),
pid: Some(80),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let project_b_id =
project_key(&canonical_project_root(project_b.path()).expect("canonical b"));
let opened_b = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/index_folder",
opened.session_id
))
.json(&IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: None,
allow_protected_root: None,
})
.send()
.await
.expect("open B request")
.error_for_status()
.expect("open B status")
.text()
.await
.expect("open B body");
assert!(opened_b.contains("Indexed"), "open B: {opened_b}");
let evidence_for = |body: serde_json::Value| {
let client = client.clone();
let url = format!(
"{base_url}/v1/sessions/{}/tools/get_repo_map",
opened.session_id
);
async move {
let response = client
.post(url)
.json(&body)
.send()
.await
.expect("tool request")
.error_for_status()
.expect("tool status");
let header = response
.headers()
.get(crate::protocol::result_status::PROJECT_EVIDENCE_HEADER)
.expect("evidence header must be present")
.to_str()
.expect("evidence header must be ASCII")
.to_string();
serde_json::from_str::<crate::protocol::result_status::ProjectEvidence>(&header)
.expect("evidence header must parse as typed evidence")
}
};
let home_evidence = evidence_for(serde_json::json!({"detail": "compact"})).await;
assert_eq!(
home_evidence.project_id, opened.project_id,
"omitted project must be served (and attested) by home"
);
assert!(
home_evidence.canonical_root.is_some() && !home_evidence.index_state.is_empty(),
"evidence carries root and index state: {home_evidence:?}"
);
let routed_evidence =
evidence_for(serde_json::json!({"detail": "compact", "project": project_b_id})).await;
assert_eq!(
routed_evidence.project_id, project_b_id,
"explicit project must be attested by the routed sibling"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
}
#[test]
fn test_reaper_rechecks_heartbeat_before_close() {
let project = project_dir("symforge-reaper");
let state = DaemonState::new();
let opened = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "reaper".to_string(),
pid: None,
})
.expect("open session");
let ancient: u64 = 1_000;
let store_last_seen = |value: u64| {
let sessions = state.sessions.read();
sessions
.get(&opened.session_id)
.expect("session")
.last_seen_at
.store(value, Ordering::Relaxed);
};
store_last_seen(ancient);
let cutoff = now_epoch_millis().saturating_sub(60_000);
assert!(
ancient < cutoff,
"test premise: ancient observation expired"
);
state.heartbeat(&opened.session_id); assert!(
!state.close_session_if_expired(&opened.session_id, ancient, cutoff),
"a heartbeat between observation and claim must preserve the session"
);
assert!(
state.sessions.read().contains_key(&opened.session_id),
"session survives the losing claim"
);
store_last_seen(ancient);
assert!(
state.close_session_if_expired(&opened.session_id, ancient, cutoff),
"an expired unchanged observation must be claimed"
);
assert!(
!state.sessions.read().contains_key(&opened.session_id),
"claimed session is removed"
);
assert!(
!state.projects.read().contains_key(&opened.project_id),
"orphan project membership is removed once"
);
assert!(
!state.heartbeat(&opened.session_id).known_session,
"heartbeat after the claim must fail, not resurrect"
);
let reopened = state
.open_project_session(OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "reaper-sweep".to_string(),
pid: None,
})
.expect("reopen session");
{
let sessions = state.sessions.read();
sessions
.get(&reopened.session_id)
.expect("session")
.last_seen_at
.store(1, Ordering::Relaxed); }
let reaped = state.reap_expired_sessions(std::time::Duration::from_secs(60));
assert_eq!(reaped, 1, "sweep must reap exactly the expired session");
assert!(!state.sessions.read().contains_key(&reopened.session_id));
}
#[tokio::test]
async fn test_status_projects_detail_lists_session_inventory() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project_a = project_dir("symforge-inventory-home-a");
let project_b = project_dir("symforge-inventory-open-b");
std::fs::write(
project_a.path().join("src").join("old.rs"),
"fn old_fn() {}\n",
)
.expect("write source a");
std::fs::write(
project_b.path().join("src").join("new.rs"),
"fn new_fn() {}\n",
)
.expect("write source b");
let handle = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn daemon");
let client = authed_client(&handle);
let base_url = format!("http://127.0.0.1:{}", handle.port);
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "inventory".to_string(),
pid: Some(79),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let project_b_id =
project_key(&canonical_project_root(project_b.path()).expect("canonical b"));
let health_single = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/health_compact",
opened.session_id
))
.json(&serde_json::json!({}))
.send()
.await
.expect("health request")
.error_for_status()
.expect("health status")
.text()
.await
.expect("health body");
assert!(
!health_single.contains("── projects ──"),
"single-project health must stay byte-compatible: {health_single}"
);
let opened_b = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/index_folder",
opened.session_id
))
.json(&IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: None,
allow_protected_root: None,
})
.send()
.await
.expect("open B request")
.error_for_status()
.expect("open B status")
.text()
.await
.expect("open B body");
assert!(opened_b.contains("Indexed"), "open B: {opened_b}");
let inventory = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/status",
opened.session_id
))
.json(&serde_json::json!({"detail": "projects"}))
.send()
.await
.expect("status request")
.error_for_status()
.expect("status status")
.text()
.await
.expect("status body");
assert!(
inventory.contains(&opened.project_id) && inventory.contains(&project_b_id),
"inventory must list both open projects: {inventory}"
);
assert!(
inventory.contains(&format!("{} home=yes", opened.project_id)),
"home project must carry the home marker: {inventory}"
);
assert!(
inventory.contains("snapshot=present") || inventory.contains("snapshot=absent"),
"inventory rows must carry snapshot evidence: {inventory}"
);
assert!(
inventory.contains("last_seen=") && inventory.contains("ttl_secs="),
"inventory must expose session last-seen and reaper TTL evidence: {inventory}"
);
let health_multi = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/health_compact",
opened.session_id
))
.json(&serde_json::json!({}))
.send()
.await
.expect("health multi request")
.error_for_status()
.expect("health multi status")
.text()
.await
.expect("health multi body");
assert!(
health_multi.contains("── projects ──") && health_multi.contains(&project_b_id),
"multi-project health must expose the inventory: {health_multi}"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
}
#[tokio::test]
async fn test_explicit_project_edit_routes_and_preserves_worktree() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project_a = project_dir("symforge-edit-route-a");
let project_b = project_dir("symforge-edit-route-b");
let file_a = project_a.path().join("src").join("lib.rs");
let file_b = project_b.path().join("src").join("lib.rs");
std::fs::write(&file_a, "pub fn shared_name() -> u32 { 1 }\n").expect("write source a");
std::fs::write(&file_b, "pub fn shared_name() -> u32 { 1 }\n").expect("write source b");
let handle = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn daemon");
let client = authed_client(&handle);
let base_url = format!("http://127.0.0.1:{}", handle.port);
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "edit-route".to_string(),
pid: Some(78),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let project_b_id =
project_key(&canonical_project_root(project_b.path()).expect("canonical b"));
let opened_b = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/index_folder",
opened.session_id
))
.json(&IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: None,
allow_protected_root: None,
})
.send()
.await
.expect("open B request")
.error_for_status()
.expect("open B status")
.text()
.await
.expect("open B body");
assert!(opened_b.contains("Indexed"), "open B: {opened_b}");
let edit = |body: serde_json::Value| {
let client = client.clone();
let url = format!(
"{base_url}/v1/sessions/{}/tools/replace_symbol_body",
opened.session_id
);
async move {
client
.post(url)
.json(&body)
.send()
.await
.expect("edit request")
.error_for_status()
.expect("edit status")
.text()
.await
.expect("edit body")
}
};
let result_b = edit(serde_json::json!({
"path": "src/lib.rs",
"name": "shared_name",
"new_body": "pub fn shared_name() -> u32 { 2 }",
"project": project_b_id,
}))
.await;
let on_disk_b = std::fs::read_to_string(&file_b).expect("read B");
let on_disk_a = std::fs::read_to_string(&file_a).expect("read A");
assert!(
on_disk_b.contains("{ 2 }"),
"explicit B edit must mutate B: {result_b}\n{on_disk_b}"
);
assert!(
on_disk_a.contains("{ 1 }"),
"explicit B edit must not touch home A: {on_disk_a}"
);
let result_a = edit(serde_json::json!({
"path": "src/lib.rs",
"name": "shared_name",
"new_body": "pub fn shared_name() -> u32 { 3 }",
}))
.await;
let on_disk_a = std::fs::read_to_string(&file_a).expect("read A after");
let on_disk_b = std::fs::read_to_string(&file_b).expect("read B after");
assert!(
on_disk_a.contains("{ 3 }"),
"omitted edit must mutate home A: {result_a}\n{on_disk_a}"
);
assert!(
on_disk_b.contains("{ 2 }"),
"omitted edit must not touch B: {on_disk_b}"
);
let refused = edit(serde_json::json!({
"path": "src/lib.rs",
"name": "shared_name",
"new_body": "pub fn shared_name() -> u32 { 4 }",
"project": "no-such-project",
}))
.await;
assert!(
refused.contains("not open"),
"unknown edit target must refuse with candidates: {refused}"
);
assert!(
!std::fs::read_to_string(&file_a)
.expect("read A final")
.contains("{ 4 }")
&& !std::fs::read_to_string(&file_b)
.expect("read B final")
.contains("{ 4 }"),
"unknown edit target must write nothing"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
}
#[tokio::test]
async fn test_status_index_matches_daemon_proxy_after_symforge_serve() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _home_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let _surface_guard = EnvVarGuard::set_str("SYMFORGE_SURFACE", "compact");
let project = project_dir("symforge-status-proxy");
std::fs::write(
project.path().join("src").join("lib.rs"),
"pub fn served_symbol() -> u32 { 42 }\n",
)
.expect("write source");
let handle = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn daemon");
let base_url = format!("http://127.0.0.1:{}", handle.port);
let http = authed_client(&handle);
let opened = http
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "status-proxy".to_string(),
pid: Some(std::process::id()),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let client = DaemonSessionClient::new_for_test_at(
base_url.clone(),
opened.project_id.clone(),
opened.session_id.clone(),
opened.project_name.clone(),
test_control_state(daemon_home.path()),
)
.with_project_root(project.path().to_path_buf());
let server = crate::protocol::SymForgeServer::new_daemon_proxy(client);
let indexed = server
.index_folder(Parameters(IndexFolderInput {
path: project.path().display().to_string(),
idempotency_key: None,
add: None,
allow_protected_root: None,
}))
.await;
assert!(
indexed.starts_with("Indexed "),
"daemon proxy index_folder must succeed, got: {indexed}"
);
let search_input = serde_json::from_value(serde_json::json!({
"query": "served_symbol"
}))
.expect("search_symbols input");
let query = server.search_symbols(Parameters(search_input)).await;
assert!(
query.contains("served_symbol"),
"proxied query must serve the indexed symbol from the warm daemon, got: {query}"
);
let status_result = server
.status_stel_tool(Parameters(crate::stel::StelStatusRequest::default()))
.await
.expect("status dispatch");
let serialized = serde_json::to_value(&status_result).expect("serialize status result");
let status_body = serialized["content"][0]["text"]
.as_str()
.expect("status result text")
.to_string();
assert!(
status_body.contains("index_ready: true"),
"status must report the served daemon index as ready (FR-006), got:\n{status_body}"
);
assert!(
!status_body.contains("index_files: 0"),
"status must report non-zero index_files for the served index (SC-002), got:\n{status_body}"
);
assert!(
status_body.contains("index_files: 1\n"),
"status must report exactly the single indexed file from the daemon, got:\n{status_body}"
);
assert_eq!(
server.index().published_state().file_count,
0,
"front-end self.index must remain empty — status must source from the daemon"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
}
#[tokio::test]
async fn test_symforge_edit_apply_commits_through_daemon_proxy() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _home_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let _surface_guard = EnvVarGuard::set_str("SYMFORGE_SURFACE", "compact");
let project = project_dir("symforge-edit-proxy");
let file_path = project.path().join("src").join("lib.rs");
std::fs::write(&file_path, "pub fn proxy_edit() -> u32 { 1 }\n").expect("write source");
let handle = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn daemon");
let base_url = format!("http://127.0.0.1:{}", handle.port);
let http = authed_client(&handle);
let opened = http
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "edit-proxy".to_string(),
pid: Some(std::process::id()),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let client = DaemonSessionClient::new_for_test_at(
base_url.clone(),
opened.project_id.clone(),
opened.session_id.clone(),
opened.project_name.clone(),
test_control_state(daemon_home.path()),
)
.with_project_root(project.path().to_path_buf());
let server = crate::protocol::SymForgeServer::new_daemon_proxy(client);
let indexed = server
.index_folder(Parameters(IndexFolderInput {
path: project.path().display().to_string(),
idempotency_key: None,
add: None,
allow_protected_root: None,
}))
.await;
assert!(
indexed.starts_with("Indexed "),
"daemon proxy index_folder must succeed, got: {indexed}"
);
assert_eq!(
server.index().published_state().file_count,
0,
"front-end proxy index is intentionally empty"
);
let result = server
.symforge_edit_facade_tool(Parameters(crate::stel::StelEditRequest {
path: "src/lib.rs".to_string(),
symbol: Some("proxy_edit".to_string()),
body: Some("pub fn proxy_edit() -> u32 { 2 }".to_string()),
apply: Some(true),
..Default::default()
}))
.await
.expect("symforge_edit dispatch");
let serialized = serde_json::to_value(&result).expect("serialize symforge_edit result");
let body = serialized["content"][0]["text"]
.as_str()
.expect("symforge_edit result text");
assert!(
!body.starts_with("Index not loaded."),
"daemon-proxy apply must not inspect the empty front-end index:\n{body}"
);
let on_disk = std::fs::read_to_string(&file_path).expect("read edited file");
assert!(
on_disk.contains("{ 2 }"),
"symforge_edit apply must commit through the daemon proxy, got:\n{on_disk}\n\nbody:\n{body}"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
}
#[tokio::test]
async fn test_symforge_edit_apply_routes_into_worktree_through_daemon_proxy() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _home_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project = project_dir("symforge-wt-route-main");
let main_root = project.path().to_path_buf();
let main_file = main_root.join("src").join("lib.rs");
std::fs::write(&main_file, "pub fn wt_edit() -> u32 { 1 }\n").expect("write source");
let git = |args: &[&str]| {
let out = crate::process_util::hidden_command("git")
.current_dir(&main_root)
.args(args)
.output()
.unwrap_or_else(|e| panic!("git {args:?} spawn: {e}"));
assert!(
out.status.success(),
"git {args:?} failed: {}",
String::from_utf8_lossy(&out.stderr)
);
};
git(&["init", "-b", "main"]);
git(&["config", "user.email", "t@t.test"]);
git(&["config", "user.name", "t"]);
git(&["config", "commit.gpgsign", "false"]);
git(&["add", "-A"]);
git(&["commit", "-q", "-m", "init"]);
let wt_parent = TempDir::new().expect("worktree parent");
let worktree_root = wt_parent.path().join("wt_one");
git(&[
"worktree",
"add",
worktree_root.to_str().expect("utf-8 worktree path"),
"-b",
"feature",
]);
let worktree_file = worktree_root.join("src").join("lib.rs");
let handle = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn daemon");
let base_url = format!("http://127.0.0.1:{}", handle.port);
let http = authed_client(&handle);
let opened = http
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: main_root.display().to_string(),
client_name: "wt-route".to_string(),
pid: Some(std::process::id()),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let client = DaemonSessionClient::new_for_test_at(
base_url.clone(),
opened.project_id.clone(),
opened.session_id.clone(),
opened.project_name.clone(),
test_control_state(daemon_home.path()),
)
.with_project_root(main_root.clone());
let server = crate::protocol::SymForgeServer::new_daemon_proxy(client);
let indexed = server
.index_folder(Parameters(IndexFolderInput {
path: main_root.display().to_string(),
idempotency_key: None,
add: None,
allow_protected_root: None,
}))
.await;
assert!(
indexed.starts_with("Indexed "),
"daemon proxy index_folder must succeed, got: {indexed}"
);
assert_eq!(
server.index().published_state().file_count,
0,
"front-end proxy index must be empty — the daemon must serve the edit"
);
let routed = server
.symforge_edit_facade_tool(Parameters(crate::stel::StelEditRequest {
path: "src/lib.rs".to_string(),
symbol: Some("wt_edit".to_string()),
body: Some("pub fn wt_edit() -> u32 { 2 }".to_string()),
apply: Some(true),
working_directory: Some(worktree_root.display().to_string()),
..Default::default()
}))
.await
.expect("symforge_edit dispatch");
let routed_body =
serde_json::to_value(&routed).expect("serialize routed result")["content"][0]["text"]
.as_str()
.expect("routed result text")
.to_string();
assert!(
routed_body.contains("rerouted: true"),
"worktree apply must report rerouted: true through the daemon path, got:\n{routed_body}"
);
let worktree_after = std::fs::read_to_string(&worktree_file).expect("read worktree file");
assert!(
worktree_after.contains("{ 2 }"),
"worktree copy must receive the routed edit, got:\n{worktree_after}\n\nbody:\n{routed_body}"
);
let main_after = std::fs::read_to_string(&main_file).expect("read main file");
assert!(
main_after.contains("{ 1 }") && !main_after.contains("{ 2 }"),
"indexed root must NOT be contaminated by a routed worktree edit, got:\n{main_after}\n\nbody:\n{routed_body}"
);
let stray = TempDir::new().expect("stray dir");
let stray_result = server
.symforge_edit_facade_tool(Parameters(crate::stel::StelEditRequest {
path: "src/lib.rs".to_string(),
symbol: Some("wt_edit".to_string()),
body: Some("pub fn wt_edit() -> u32 { 9 }".to_string()),
apply: Some(true),
working_directory: Some(stray.path().display().to_string()),
..Default::default()
}))
.await
.expect("symforge_edit dispatch");
let stray_body = serde_json::to_value(&stray_result).expect("serialize stray result")
["content"][0]["text"]
.as_str()
.expect("stray result text")
.to_string();
assert!(
stray_body.contains("WorkingDirectoryNotARecognizedWorktree"),
"a non-worktree working_directory must error loudly, got:\n{stray_body}"
);
let main_after_stray = std::fs::read_to_string(&main_file).expect("read main after stray");
assert!(
main_after_stray.contains("{ 1 }") && !main_after_stray.contains("{ 9 }"),
"a rejected non-worktree edit must not write to the indexed root, got:\n{main_after_stray}\n\nbody:\n{stray_body}"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
}
#[tokio::test]
async fn test_daemon_http_edit_within_routes_into_worktree_without_frontend_server() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _home_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project = project_dir("symforge-wt-http-main");
let main_root = project.path().to_path_buf();
let main_file = main_root.join("src").join("lib.rs");
std::fs::write(&main_file, "pub fn wt_edit() -> u32 { 1 }\n").expect("write source");
let git = |args: &[&str]| {
let out = crate::process_util::hidden_command("git")
.current_dir(&main_root)
.args(args)
.output()
.unwrap_or_else(|e| panic!("git {args:?} spawn: {e}"));
assert!(
out.status.success(),
"git {args:?} failed: {}",
String::from_utf8_lossy(&out.stderr)
);
};
git(&["init", "-b", "main"]);
git(&["config", "user.email", "t@t.test"]);
git(&["config", "user.name", "t"]);
git(&["config", "commit.gpgsign", "false"]);
git(&["add", "-A"]);
git(&["commit", "-q", "-m", "init"]);
let wt_parent = TempDir::new().expect("worktree parent");
let worktree_root = wt_parent.path().join("wt_one");
git(&[
"worktree",
"add",
worktree_root.to_str().expect("utf-8 worktree path"),
"-b",
"feature",
]);
let worktree_file = worktree_root.join("src").join("lib.rs");
let handle = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn daemon");
let base_url = format!("http://127.0.0.1:{}", handle.port);
let http = authed_client(&handle);
let opened = http
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: main_root.display().to_string(),
client_name: "wt-http".to_string(),
pid: Some(std::process::id()),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let session_id = opened.session_id;
let call_tool = |tool: &str, params: serde_json::Value| {
let url = format!("{base_url}/v1/sessions/{session_id}/tools/{tool}");
let http = http.clone();
async move {
http.post(url)
.json(¶ms)
.send()
.await
.expect("tool request")
.error_for_status()
.expect("tool status")
.text()
.await
.expect("tool body")
}
};
let indexed = call_tool(
"index_folder",
serde_json::json!({ "path": main_root.display().to_string() }),
)
.await;
assert!(
indexed.starts_with("Indexed "),
"daemon index_folder must succeed, got: {indexed}"
);
let routed = call_tool(
"edit_within_symbol",
serde_json::json!({
"path": "src/lib.rs",
"name": "wt_edit",
"old_text": "{ 1 }",
"new_text": "{ 2 }",
"working_directory": worktree_root.display().to_string(),
}),
)
.await;
assert!(
routed.contains("rerouted: true"),
"daemon must route the worktree edit (rerouted: true), got:\n{routed}"
);
let worktree_after = std::fs::read_to_string(&worktree_file).expect("read worktree file");
assert!(
worktree_after.contains("{ 2 }"),
"worktree copy must receive the routed edit, got:\n{worktree_after}\n\nresp:\n{routed}"
);
let main_after = std::fs::read_to_string(&main_file).expect("read main file");
assert!(
main_after.contains("{ 1 }") && !main_after.contains("{ 2 }"),
"indexed root must NOT be contaminated by a routed worktree edit, got:\n{main_after}\n\nresp:\n{routed}"
);
let stray = TempDir::new().expect("stray dir");
let stray_resp = call_tool(
"edit_within_symbol",
serde_json::json!({
"path": "src/lib.rs",
"name": "wt_edit",
"old_text": "{ 1 }",
"new_text": "{ 9 }",
"working_directory": stray.path().display().to_string(),
}),
)
.await;
assert!(
stray_resp.contains("WorkingDirectoryNotARecognizedWorktree"),
"a non-worktree working_directory must error loudly, got:\n{stray_resp}"
);
let main_after_stray = std::fs::read_to_string(&main_file).expect("read main after stray");
assert!(
main_after_stray.contains("{ 1 }") && !main_after_stray.contains("{ 9 }"),
"a rejected non-worktree edit must not write to the indexed root, got:\n{main_after_stray}\n\nresp:\n{stray_resp}"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
}
#[tokio::test]
async fn test_index_folder_proxy_open_preserves_local_home_fallback() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project_a = project_dir("symforge-proxy-stale-a");
let project_b = project_dir("symforge-proxy-stale-b");
std::fs::write(
project_a.path().join("src").join("old.rs"),
"fn old_fn() {}\n",
)
.expect("write source a");
std::fs::write(
project_b.path().join("src").join("new.rs"),
"fn new_fn() {}\n",
)
.expect("write source b");
let handle = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn daemon");
let base_url = format!("http://127.0.0.1:{}", handle.port);
let http = authed_client(&handle);
let opened = http
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "regression".to_string(),
pid: Some(std::process::id()),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let client = DaemonSessionClient::new_for_test_at(
base_url.clone(),
opened.project_id.clone(),
opened.session_id.clone(),
opened.project_name.clone(),
test_control_state(daemon_home.path()),
)
.with_project_root(project_a.path().to_path_buf());
let server = crate::protocol::SymForgeServer::new_daemon_proxy(client);
server.index.add_file(
"src/old.rs".to_string(),
crate::live_index::store::IndexedFile {
relative_path: "src/old.rs".to_string(),
language: crate::domain::index::LanguageId::Rust,
classification: crate::domain::FileClassification::for_code_path("src/old.rs"),
content: b"fn old_fn() {}".to_vec(),
symbols: vec![],
parse_status: crate::live_index::store::ParseStatus::Parsed,
parse_diagnostic: None,
byte_len: 14,
content_hash: "old-hash".to_string(),
references: vec![],
alias_map: std::collections::HashMap::new(),
mtime_secs: 0,
},
);
assert_eq!(
server.index.published_state().file_count,
1,
"precondition: stale local index holds the OLD project"
);
let result = server
.index_folder(Parameters(IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: None,
allow_protected_root: None,
}))
.await;
assert!(
result.starts_with("Indexed "),
"daemon proxy index_folder should report success, got: {result}"
);
assert_eq!(
server.index.published_state().file_count,
1,
"opening B must not reset the local home-A fallback, got: {result}"
);
assert!(
server.index.read().get_file("src/old.rs").is_some(),
"home-A fallback must remain reachable after opening B"
);
let home_root = server.capture_repo_root().expect("home root after open");
assert_eq!(
home_root,
project_a.path().to_path_buf(),
"repo_root must remain bound to immutable home A"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
}
#[tokio::test]
async fn test_index_folder_proxy_failure_refuses_destructive_local_fallback() {
let project_a = project_dir("symforge-proxy-refusal-a");
let project_b = project_dir("symforge-proxy-refusal-b");
std::fs::write(
project_a.path().join("src").join("home.rs"),
"fn home() {}\n",
)
.expect("write home source");
std::fs::write(
project_b.path().join("src").join("other.rs"),
"fn other() {}\n",
)
.expect("write other source");
let home_root = canonical_project_root(project_a.path()).expect("canonical home A");
let dead_port = {
let listener =
std::net::TcpListener::bind("127.0.0.1:0").expect("bind ephemeral probe port");
listener.local_addr().expect("probe port local addr").port()
};
let daemon_home = TempDir::new().expect("isolated daemon control state");
let client = DaemonSessionClient::new_for_test_at(
format!("http://127.0.0.1:{dead_port}"),
project_key(&home_root),
"unreachable-session".to_string(),
"home-a".to_string(),
test_control_state(daemon_home.path()),
)
.with_project_root(home_root.clone());
let server = crate::protocol::SymForgeServer::new_daemon_proxy(client);
server
.daemon_degraded
.store(true, std::sync::atomic::Ordering::Relaxed);
server
.index
.reload(&home_root)
.expect("seed local home fallback");
let output = server
.index_folder(Parameters(IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: None,
allow_protected_root: None,
}))
.await;
assert!(
output.contains("daemon") && output.contains("refus"),
"daemon-proxy failure must refuse destructive local index_folder: {output}"
);
assert_eq!(
server.capture_repo_root().as_deref(),
Some(home_root.as_path()),
"failed proxy open must keep home root"
);
let guard = server.index.read();
assert!(guard.get_file("src/home.rs").is_some());
assert!(
guard.get_file("src/other.rs").is_none(),
"failed proxy open must not replace home index with B"
);
}
#[tokio::test]
async fn test_index_folder_open_preserves_home_in_status_and_symforge_surfaces() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let _surface_guard = EnvVarGuard::set_str("SYMFORGE_SURFACE", "compact");
let project_a = project_dir("symforge-retarget-root-a");
let project_b = project_dir("symforge-retarget-root-b");
std::fs::write(
project_a.path().join("src").join("lib.rs"),
"pub fn alpha_symbol() -> u32 { 1 }\n",
)
.expect("write source a");
std::fs::write(
project_b.path().join("src").join("lib.rs"),
"pub fn beta_symbol() -> u32 { 2 }\n",
)
.expect("write source b");
let handle = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn daemon");
let base_url = format!("http://127.0.0.1:{}", handle.port);
let http = authed_client(&handle);
let opened = http
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "retarget-root".to_string(),
pid: Some(std::process::id()),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let client = DaemonSessionClient::new_for_test_at(
base_url.clone(),
opened.project_id.clone(),
opened.session_id.clone(),
opened.project_name.clone(),
test_control_state(daemon_home.path()),
)
.with_project_root(project_a.path().to_path_buf());
let server = crate::protocol::SymForgeServer::new_daemon_proxy(client);
let root_a_norm = project_a.path().display().to_string().replace('\\', "/");
let status_before =
server.render_stel_status_body(&crate::stel::StelStatusRequest::default());
assert!(
status_before.contains(&format!("project_root: {root_a_norm}")),
"pre-retarget status must surface project A root, got:\n{status_before}"
);
let indexed = server
.index_folder(Parameters(IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: None,
allow_protected_root: None,
}))
.await;
assert!(
indexed.starts_with("Indexed "),
"daemon proxy open must succeed, got: {indexed}"
);
let bound = server.capture_repo_root().expect("repo root after open");
assert_eq!(
bound,
project_a.path().to_path_buf(),
"repo_root must remain at immutable home A after opening B"
);
let root_b_norm = project_b.path().display().to_string().replace('\\', "/");
let status_after =
server.render_stel_status_body(&crate::stel::StelStatusRequest::default());
assert!(
status_after.contains(&format!("project_root: {root_a_norm}")),
"post-open status must preserve home A root, got:\n{status_after}"
);
assert!(
!status_after.contains(&format!("project_root: {root_b_norm}")),
"opened B must not replace home A in status, got:\n{status_after}"
);
let symforge_input = serde_json::from_value(serde_json::json!({
"query": "find beta_symbol"
}))
.expect("symforge facade input");
let symforge_result = server
.symforge_facade_tool(Parameters(symforge_input))
.await
.expect("symforge facade dispatch");
let serialized = serde_json::to_value(&symforge_result).expect("serialize symforge result");
let symforge_body = serialized["content"][0]["text"]
.as_str()
.expect("symforge result text")
.to_string();
assert!(
symforge_body.contains(&format!("project_root: {root_a_norm}")),
"symforge envelope must preserve home project A, got:\n{symforge_body}"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
}
#[tokio::test]
async fn test_index_folder_idempotency_replays_same_key_same_request_in_daemon_route() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project_a = project_dir("symforge-daemon-idempotency-a");
let project_b = project_dir("symforge-daemon-idempotency-b");
std::fs::write(
project_a.path().join("src").join("old.rs"),
"fn old_fn() {}\n",
)
.expect("write source a");
std::fs::write(
project_b.path().join("src").join("new.rs"),
"fn new_fn() {}\n",
)
.expect("write source b");
let handle = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn daemon");
let client = authed_client(&handle);
let base_url = format!("http://127.0.0.1:{}", handle.port);
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "codex".to_string(),
pid: Some(56),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
let tool_url = format!(
"{base_url}/v1/sessions/{}/tools/index_folder",
opened.session_id
);
let first = client
.post(&tool_url)
.json(&IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: Some("daemon-replay-key".to_string()),
add: None,
allow_protected_root: None,
})
.send()
.await
.expect("first index request")
.error_for_status()
.expect("first index status")
.text()
.await
.expect("first index body");
assert!(
first.starts_with("Indexed 1 files"),
"first daemon idempotent index_folder should index once, got: {first}"
);
std::fs::write(
project_b.path().join("src").join("second.rs"),
"fn second_fn() {}\n",
)
.expect("write second source b");
let replay = client
.post(&tool_url)
.json(&IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: Some("daemon-replay-key".to_string()),
add: None,
allow_protected_root: None,
})
.send()
.await
.expect("replay index request")
.error_for_status()
.expect("replay index status")
.text()
.await
.expect("replay index body");
assert_eq!(
replay, first,
"daemon special route must replay stored output for same key and canonical request"
);
let conflict = client
.post(&tool_url)
.json(&IndexFolderInput {
path: project_a.path().display().to_string(),
idempotency_key: Some("daemon-replay-key".to_string()),
add: None,
allow_protected_root: None,
})
.send()
.await
.expect("conflict index request")
.error_for_status()
.expect("conflict index status")
.text()
.await
.expect("conflict index body");
assert!(
conflict.contains("Idempotency conflict"),
"daemon special route must reject same key with different request, got: {conflict}"
);
assert!(
!conflict.starts_with("Indexed "),
"daemon conflict must not report synthetic indexing success: {conflict}"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
}
#[test]
fn test_index_folder_additive_replays_and_conflicts() {
let control_state_home = TempDir::new().expect("isolated idempotency control state");
let project_a = project_dir("symforge-idempotency-home-a");
let project_b = project_dir("symforge-idempotency-open-b");
let project_c = project_dir("symforge-idempotency-conflict-c");
std::fs::write(project_b.path().join("src").join("b.rs"), "fn b() {}\n")
.expect("write source b");
std::fs::write(project_c.path().join("src").join("c.rs"), "fn c() {}\n")
.expect("write source c");
let state = test_daemon_state(control_state_home.path());
let opened = state
.open_project_session(OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "idempotency".to_string(),
pid: None,
})
.expect("open home A");
let first = state
.index_folder_for_session(
&opened.session_id,
IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: Some("shared-open-key".to_string()),
add: None,
allow_protected_root: None,
},
)
.expect("default open B");
assert!(first.contains("project_id="), "identity receipt: {first}");
assert!(
first.contains("checkpoint=written"),
"checkpoint receipt: {first}"
);
std::fs::write(
project_b.path().join("src").join("second.rs"),
"fn second() {}\n",
)
.expect("write second source b");
let replay = state
.index_folder_for_session(
&opened.session_id,
IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: Some("shared-open-key".to_string()),
add: Some(true),
allow_protected_root: None,
},
)
.expect("compatibility add=true replay B");
assert_eq!(
replay, first,
"default and add=true must share one canonical replay contract"
);
let conflict = state
.index_folder_for_session(
&opened.session_id,
IndexFolderInput {
path: project_c.path().display().to_string(),
idempotency_key: Some("shared-open-key".to_string()),
add: Some(true),
allow_protected_root: None,
},
)
.expect("conflicting open C");
assert!(
conflict.contains("Idempotency conflict"),
"same key with another target must fail deterministically: {conflict}"
);
assert!(
!state.projects.read().contains_key(&project_key(
&canonical_project_root(project_c.path()).expect("canonical C")
)),
"conflict must be rejected before project C is loaded"
);
}
#[test]
fn test_index_folder_open_persists_snapshot_for_restore() {
let project_a = project_dir("symforge-snapshot-home-a");
let project_b = project_dir("symforge-snapshot-open-b");
std::fs::write(
project_b.path().join("src").join("restored.rs"),
"fn restored() {}\n",
)
.expect("write source b");
let state = DaemonState::new();
let opened = state
.open_project_session(OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "snapshot".to_string(),
pid: None,
})
.expect("open home A");
let receipt = state
.index_folder_for_session(
&opened.session_id,
IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: None,
allow_protected_root: None,
},
)
.expect("open B");
assert!(
receipt.contains("checkpoint=written"),
"successful open must expose durable checkpoint outcome: {receipt}"
);
assert!(
project_b
.path()
.join(".symforge")
.join("index.bin")
.is_file(),
"successful daemon reload must atomically persist B"
);
drop(state);
let canonical_b = canonical_project_root(project_b.path()).expect("canonical B");
let RootResolution::Bound(binding_b) = crate::discovery::resolve_root_candidate(
&canonical_b,
RootCandidateSource::LaunchCwd,
RootRequestMode::Automatic,
) else {
panic!("B must remain a valid automatic project root");
};
let placement_b = crate::discovery::resolve_state_placement(&binding_b);
let restored =
bootstrap_project_index(&canonical_b, &placement_b).expect("restore B from snapshot");
let guard = restored.read();
assert_eq!(
guard.load_source(),
crate::live_index::store::IndexLoadSource::SnapshotRestore
);
assert_eq!(guard.file_count(), 1);
assert!(guard.get_file("src/restored.rs").is_some());
}
#[tokio::test]
async fn test_index_folder_open_falls_back_to_user_local_when_project_state_unavailable() {
let _env_lock = env_lock().await;
let state_home = TempDir::new().expect("private user-local state base");
let _home = EnvVarGuard::set("SYMFORGE_HOME", state_home.path());
let project_a = project_dir("symforge-degraded-home-a");
let project_b = project_dir("symforge-degraded-open-b");
std::fs::write(project_b.path().join("src").join("b.rs"), "fn b() {}\n")
.expect("write source b");
std::fs::write(project_b.path().join(".symforge"), "not a directory")
.expect("write .symforge blocker");
let state = DaemonState::new();
let opened = state
.open_project_session(OpenProjectRequest {
project_root: project_a.path().display().to_string(),
client_name: "state-fallback".to_string(),
pid: None,
})
.expect("open home A");
let receipt = state
.index_folder_for_session(
&opened.session_id,
IndexFolderInput {
path: project_b.path().display().to_string(),
idempotency_key: None,
add: None,
allow_protected_root: None,
},
)
.expect("open B must succeed through user-local fallback");
assert!(
receipt.starts_with("Indexed "),
"open itself must succeed: {receipt}"
);
assert!(
receipt.contains("state=user-local"),
"project-local failure must select user-local state: {receipt}"
);
assert!(
receipt.contains("checkpoint=written"),
"user-local placement must checkpoint through its resolved state directory: {receipt}"
);
let project_b_id =
project_key(&canonical_project_root(project_b.path()).expect("canonical b"));
let sessions = state.sessions.read();
let session = sessions.get(&opened.session_id).expect("session");
assert_eq!(session.active_project_id, opened.project_id, "home stays A");
assert!(
session.working_set.read().get(&project_b_id).is_some(),
"B must be attached despite project-local state being unavailable"
);
assert!(
state_home
.path()
.join("projects")
.join(&project_b_id)
.is_dir(),
"fallback state must be prepared under the private user-local project directory"
);
assert!(
state_home
.path()
.join("projects")
.join(&project_b_id)
.join("index.bin")
.is_file(),
"user-local checkpoint must be written under the resolved project state directory"
);
assert!(
project_b.path().join(".symforge").is_file(),
"the blocking file must remain in place (no destructive recovery)"
);
}
#[tokio::test]
async fn test_analyze_file_impact_uses_session_project_root_not_process_cwd() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let project = project_dir("symforge-daemon-impact-root");
let outside = TempDir::new().expect("outside cwd");
let source_path = project.path().join("src").join("lib.rs");
std::fs::write(&source_path, "pub fn old_name() {}\n").expect("write initial source");
let handle = spawn_test_daemon("127.0.0.1", daemon_home.path())
.await
.expect("spawn daemon");
let client = authed_client(&handle);
let base_url = format!("http://127.0.0.1:{}", handle.port);
let opened = client
.post(format!("{base_url}/v1/sessions/open"))
.json(&OpenProjectRequest {
project_root: project.path().display().to_string(),
client_name: "codex".to_string(),
pid: Some(4242),
})
.send()
.await
.expect("open request")
.error_for_status()
.expect("open status")
.json::<OpenProjectResponse>()
.await
.expect("open body");
std::fs::write(&source_path, "pub fn new_name() {}\n").expect("write updated source");
let _cwd_guard = CwdGuard::set(outside.path());
let impact = client
.post(format!(
"{base_url}/v1/sessions/{}/tools/analyze_file_impact",
opened.session_id
))
.json(&serde_json::json!({
"path": "src/lib.rs"
}))
.send()
.await
.expect("impact request")
.error_for_status()
.expect("impact status")
.text()
.await
.expect("impact body");
assert!(
impact.contains("new_name"),
"impact analysis should read from the session project root, got: {impact}"
);
let _ = handle.shutdown_tx.send(());
wait_for_path_absent(&test_daemon_path(
daemon_home.path(),
LEGACY_DAEMON_PORT_FILE,
))
.await;
}
#[test]
fn test_concurrent_open_same_project_no_panic() {
use std::sync::{Arc, Barrier};
let project = project_dir("symforge-conc-same");
std::fs::write(project.path().join("src").join("main.rs"), "fn main() {}\n")
.expect("write source");
let project_root = project.path().display().to_string();
let state = Arc::new(DaemonState::new());
let barrier = Arc::new(Barrier::new(2));
let handles: Vec<_> = (0..2)
.map(|i| {
let state = Arc::clone(&state);
let barrier = Arc::clone(&barrier);
let root = project_root.clone();
std::thread::spawn(move || {
barrier.wait();
state.open_project_session(OpenProjectRequest {
project_root: root,
client_name: format!("client-{i}"),
pid: None,
})
})
})
.collect();
for handle in handles {
handle
.join()
.expect("thread panicked")
.expect("open_project_session failed");
}
let projects = state.list_projects();
assert_eq!(projects.len(), 1, "exactly 1 project instance expected");
assert_eq!(
state.health().session_count,
2,
"exactly 2 sessions expected"
);
let project_id = &projects[0].project_id;
let projects_lock = state.projects.read();
let slot = projects_lock.get(project_id).expect("project must exist");
let instance = slot.metadata.read();
assert_eq!(
instance.activation_state,
ActivationState::Active,
"project must be Active after concurrent opens"
);
}
#[test]
fn test_concurrent_open_different_projects() {
use std::sync::{Arc, Barrier};
let project_a = project_dir("symforge-conc-diff-a");
std::fs::write(
project_a.path().join("src").join("main.rs"),
"fn main() {}\n",
)
.expect("write source a");
let project_b = project_dir("symforge-conc-diff-b");
std::fs::write(
project_b.path().join("src").join("main.rs"),
"fn main() {}\n",
)
.expect("write source b");
let root_a = project_a.path().display().to_string();
let root_b = project_b.path().display().to_string();
let state = Arc::new(DaemonState::new());
let barrier = Arc::new(Barrier::new(2));
let roots = [root_a, root_b];
let handles: Vec<_> = roots
.iter()
.enumerate()
.map(|(i, root)| {
let state = Arc::clone(&state);
let barrier = Arc::clone(&barrier);
let root = root.clone();
std::thread::spawn(move || {
barrier.wait();
state.open_project_session(OpenProjectRequest {
project_root: root,
client_name: format!("client-{i}"),
pid: None,
})
})
})
.collect();
let responses: Vec<_> = handles
.into_iter()
.map(|h| h.join().expect("thread panicked").expect("open failed"))
.collect();
assert_ne!(
responses[0].project_id, responses[1].project_id,
"two distinct projects expected"
);
assert_eq!(
state.list_projects().len(),
2,
"exactly 2 project instances expected"
);
}
#[test]
fn test_open_close_race_no_panic() {
use std::sync::{Arc, Barrier};
let project = project_dir("symforge-conc-race");
std::fs::write(project.path().join("src").join("main.rs"), "fn main() {}\n")
.expect("write source");
let project_root = project.path().display().to_string();
let state = Arc::new(DaemonState::new());
let first = state
.open_project_session(OpenProjectRequest {
project_root: project_root.clone(),
client_name: "racer-first".to_string(),
pid: None,
})
.expect("first session");
let first_session_id = first.session_id.clone();
let barrier = Arc::new(Barrier::new(2));
let state_a = Arc::clone(&state);
let barrier_a = Arc::clone(&barrier);
let root_a = project_root.clone();
let open_handle = std::thread::spawn(move || {
barrier_a.wait();
state_a.open_project_session(OpenProjectRequest {
project_root: root_a,
client_name: "racer-open".to_string(),
pid: None,
})
});
let state_b = Arc::clone(&state);
let barrier_b = Arc::clone(&barrier);
let close_handle = std::thread::spawn(move || {
barrier_b.wait();
state_b.close_session(&first_session_id)
});
open_handle
.join()
.expect("open thread panicked")
.expect("open failed");
close_handle.join().expect("close thread panicked");
}
#[test]
fn test_discarded_instance_no_leaked_tasks() {
use std::sync::{Arc, Barrier};
let project = project_dir("symforge-conc-3way");
std::fs::write(project.path().join("src").join("main.rs"), "fn main() {}\n")
.expect("write source");
let project_root = project.path().display().to_string();
let state = Arc::new(DaemonState::new());
let barrier = Arc::new(Barrier::new(3));
let handles: Vec<_> = (0..3)
.map(|i| {
let state = Arc::clone(&state);
let barrier = Arc::clone(&barrier);
let root = project_root.clone();
std::thread::spawn(move || {
barrier.wait();
state.open_project_session(OpenProjectRequest {
project_root: root,
client_name: format!("racer-{i}"),
pid: None,
})
})
})
.collect();
for handle in handles {
handle
.join()
.expect("thread panicked")
.expect("open_project_session failed");
}
let projects = state.list_projects();
assert_eq!(projects.len(), 1, "exactly 1 project instance expected");
assert_eq!(
state.health().session_count,
3,
"exactly 3 sessions expected"
);
let project_id = &projects[0].project_id;
let projects_lock = state.projects.read();
let slot = projects_lock.get(project_id).expect("project must exist");
let instance = slot.metadata.read();
assert_eq!(
instance.activation_state,
ActivationState::Active,
"project must be Active"
);
}
#[tokio::test]
async fn test_stale_start_lock_is_removed() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let lock_path = test_daemon_path(daemon_home.path(), daemon_start_lock_file_name());
let file = std::fs::File::create(&lock_path).expect("create lock");
let old_time = std::time::SystemTime::now() - std::time::Duration::from_secs(60);
let times = std::fs::FileTimes::new().set_modified(old_time);
file.set_times(times).expect("set file times");
drop(file);
let result = try_acquire_start_lock_at(&test_control_state(daemon_home.path()))
.expect("should not error");
assert!(
result.is_some(),
"stale lock (>30s old) should be removed and lock acquired"
);
drop(result);
}
#[tokio::test]
async fn test_fresh_start_lock_blocks_acquisition() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let lock_path = test_daemon_path(daemon_home.path(), daemon_start_lock_file_name());
std::fs::write(&lock_path, "").expect("create lock");
let result = try_acquire_start_lock_at(&test_control_state(daemon_home.path()))
.expect("should not error");
assert!(
result.is_none(),
"fresh lock (<30s old) should block acquisition"
);
let _ = std::fs::remove_file(&lock_path);
}
#[tokio::test]
async fn test_cleanup_daemon_files_removes_start_lock() {
let _env_lock = env_lock().await;
let dir = TempDir::new().expect("temp dir");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", dir.path());
let port_file = test_daemon_path(dir.path(), LEGACY_DAEMON_PORT_FILE);
let pid_file = test_daemon_path(dir.path(), LEGACY_DAEMON_PID_FILE);
let lock_file = test_daemon_path(dir.path(), LEGACY_DAEMON_START_LOCK_FILE);
std::fs::write(&port_file, "12345").expect("write port");
std::fs::write(&pid_file, "99999").expect("write pid");
std::fs::write(&lock_file, "").expect("write lock");
cleanup_daemon_files_at(&test_control_state(dir.path()));
assert!(!port_file.exists(), "cleanup removes port file");
assert!(!pid_file.exists(), "cleanup removes pid file");
assert!(!lock_file.exists(), "cleanup removes start lock file");
}
#[tokio::test]
async fn test_runtime_cleanup_preserves_start_lock() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
let port_file = test_daemon_path(daemon_home.path(), LEGACY_DAEMON_PORT_FILE);
let pid_file = test_daemon_path(daemon_home.path(), LEGACY_DAEMON_PID_FILE);
let lock_file = test_daemon_path(daemon_home.path(), LEGACY_DAEMON_START_LOCK_FILE);
std::fs::write(&port_file, "12345").expect("write port");
std::fs::write(&pid_file, "99999").expect("write pid");
std::fs::write(&lock_file, "").expect("write lock");
cleanup_daemon_runtime_files_at(&test_control_state(daemon_home.path()));
assert!(!port_file.exists(), "runtime cleanup removes port file");
assert!(!pid_file.exists(), "runtime cleanup removes pid file");
assert!(
lock_file.exists(),
"runtime cleanup must not release another process' start lock"
);
}
#[tokio::test]
async fn test_corrupt_port_file_does_not_block_daemon_selection() {
let _env_lock = env_lock().await;
let daemon_home = TempDir::new().expect("daemon home");
let _env_guard = EnvVarGuard::set("SYMFORGE_HOME", daemon_home.path());
std::fs::write(
test_daemon_path(daemon_home.path(), LEGACY_DAEMON_PORT_FILE),
"not-a-port",
)
.expect("write corrupt port");
let identity = current_daemon_identity();
let selected =
daemon_port_if_compatible_at(&test_control_state(daemon_home.path()), &identity)
.await
.expect("corrupt port should be ignored, not fatal");
assert_eq!(selected, None);
}
}