1use std::path::PathBuf;
2use std::sync::atomic::{AtomicUsize, Ordering};
3use std::sync::Arc;
4use std::time::Instant;
5use tokio::sync::RwLock;
6
7use crate::core::cache::SessionCache;
8use crate::core::session::SessionState;
9
10pub mod autonomy;
11pub mod ctx_agent;
12pub mod ctx_analyze;
13pub mod ctx_architecture;
14pub mod ctx_benchmark;
15pub mod ctx_callees;
16pub mod ctx_callers;
17pub mod ctx_compress;
18pub mod ctx_compress_memory;
19pub mod ctx_context;
20pub mod ctx_cost;
21pub mod ctx_dedup;
22pub mod ctx_delta;
23pub mod ctx_discover;
24pub mod ctx_edit;
25pub mod ctx_execute;
26pub mod ctx_feedback;
27pub mod ctx_fill;
28pub mod ctx_gain;
29pub mod ctx_graph;
30pub mod ctx_graph_diagram;
31pub mod ctx_handoff;
32pub mod ctx_heatmap;
33pub mod ctx_impact;
34pub mod ctx_intent;
35pub mod ctx_knowledge;
36pub mod ctx_metrics;
37pub mod ctx_multi_read;
38pub mod ctx_outline;
39pub mod ctx_overview;
40pub mod ctx_prefetch;
41pub mod ctx_preload;
42pub mod ctx_read;
43pub mod ctx_response;
44pub mod ctx_routes;
45pub mod ctx_search;
46pub mod ctx_semantic_search;
47pub mod ctx_session;
48pub mod ctx_share;
49pub mod ctx_shell;
50pub mod ctx_smart_read;
51pub mod ctx_symbol;
52pub mod ctx_task;
53pub mod ctx_tree;
54pub mod ctx_workflow;
55pub mod ctx_wrapped;
56
57const DEFAULT_CACHE_TTL_SECS: u64 = 300;
58
59struct CepComputedStats {
60 cep_score: u32,
61 cache_util: u32,
62 mode_diversity: u32,
63 compression_rate: u32,
64 total_original: u64,
65 total_compressed: u64,
66 total_saved: u64,
67 mode_counts: std::collections::HashMap<String, u64>,
68 complexity: String,
69 cache_hits: u64,
70 total_reads: u64,
71 tool_call_count: u64,
72}
73
74#[derive(Clone, Copy, Debug, PartialEq, Eq)]
75pub enum CrpMode {
76 Off,
77 Compact,
78 Tdd,
79}
80
81impl CrpMode {
82 pub fn from_env() -> Self {
83 match std::env::var("LEAN_CTX_CRP_MODE")
84 .unwrap_or_default()
85 .to_lowercase()
86 .as_str()
87 {
88 "off" => Self::Off,
89 "compact" => Self::Compact,
90 _ => Self::Tdd,
91 }
92 }
93
94 pub fn is_tdd(&self) -> bool {
95 *self == Self::Tdd
96 }
97}
98
99pub type SharedCache = Arc<RwLock<SessionCache>>;
100
101#[derive(Clone)]
102pub struct LeanCtxServer {
103 pub cache: SharedCache,
104 pub session: Arc<RwLock<SessionState>>,
105 pub tool_calls: Arc<RwLock<Vec<ToolCallRecord>>>,
106 pub call_count: Arc<AtomicUsize>,
107 pub checkpoint_interval: usize,
108 pub cache_ttl_secs: u64,
109 pub last_call: Arc<RwLock<Instant>>,
110 pub crp_mode: CrpMode,
111 pub agent_id: Arc<RwLock<Option<String>>>,
112 pub client_name: Arc<RwLock<String>>,
113 pub autonomy: Arc<autonomy::AutonomyState>,
114 pub loop_detector: Arc<RwLock<crate::core::loop_detection::LoopDetector>>,
115 pub workflow: Arc<RwLock<Option<crate::core::workflow::WorkflowRun>>>,
116 pub ledger: Arc<RwLock<crate::core::context_ledger::ContextLedger>>,
117 pub pipeline_stats: Arc<RwLock<crate::core::pipeline::PipelineStats>>,
118 startup_project_root: Option<String>,
119 startup_shell_cwd: Option<String>,
120}
121
122#[derive(Clone, Debug)]
123pub struct ToolCallRecord {
124 pub tool: String,
125 pub original_tokens: usize,
126 pub saved_tokens: usize,
127 pub mode: Option<String>,
128 pub duration_ms: u64,
129 pub timestamp: String,
130}
131
132impl Default for LeanCtxServer {
133 fn default() -> Self {
134 Self::new()
135 }
136}
137
138impl LeanCtxServer {
139 pub fn new() -> Self {
140 Self::new_with_project_root(None)
141 }
142
143 pub fn new_with_project_root(project_root: Option<String>) -> Self {
144 Self::new_with_startup(project_root, std::env::current_dir().ok())
145 }
146
147 fn new_with_startup(project_root: Option<String>, startup_cwd: Option<PathBuf>) -> Self {
148 let config = crate::core::config::Config::load();
149
150 let interval = std::env::var("LEAN_CTX_CHECKPOINT_INTERVAL")
151 .ok()
152 .and_then(|v| v.parse().ok())
153 .unwrap_or(config.checkpoint_interval as usize);
154
155 let ttl = std::env::var("LEAN_CTX_CACHE_TTL")
156 .ok()
157 .and_then(|v| v.parse().ok())
158 .unwrap_or(DEFAULT_CACHE_TTL_SECS);
159
160 let crp_mode = CrpMode::from_env();
161
162 let startup = detect_startup_context(project_root.as_deref(), startup_cwd.as_deref());
163 let mut session = if let Some(ref root) = startup.project_root {
164 SessionState::load_latest_for_project_root(root).unwrap_or_default()
165 } else {
166 SessionState::load_latest().unwrap_or_default()
167 };
168
169 if let Some(ref root) = startup.project_root {
170 session.project_root = Some(root.clone());
171 }
172 if let Some(ref cwd) = startup.shell_cwd {
173 session.shell_cwd = Some(cwd.clone());
174 }
175
176 Self {
177 cache: Arc::new(RwLock::new(SessionCache::new())),
178 session: Arc::new(RwLock::new(session)),
179 tool_calls: Arc::new(RwLock::new(Vec::new())),
180 call_count: Arc::new(AtomicUsize::new(0)),
181 checkpoint_interval: interval,
182 cache_ttl_secs: ttl,
183 last_call: Arc::new(RwLock::new(Instant::now())),
184 crp_mode,
185 agent_id: Arc::new(RwLock::new(None)),
186 client_name: Arc::new(RwLock::new(String::new())),
187 autonomy: Arc::new(autonomy::AutonomyState::new()),
188 loop_detector: Arc::new(RwLock::new(
189 crate::core::loop_detection::LoopDetector::with_config(
190 &crate::core::config::Config::load().loop_detection,
191 ),
192 )),
193 workflow: Arc::new(RwLock::new(
194 crate::core::workflow::load_active().ok().flatten(),
195 )),
196 ledger: Arc::new(RwLock::new(
197 crate::core::context_ledger::ContextLedger::new(),
198 )),
199 pipeline_stats: Arc::new(RwLock::new(crate::core::pipeline::PipelineStats::new())),
200 startup_project_root: startup.project_root,
201 startup_shell_cwd: startup.shell_cwd,
202 }
203 }
204
205 pub async fn resolve_path(&self, path: &str) -> Result<String, String> {
209 let normalized = crate::hooks::normalize_tool_path(path);
210 if normalized.is_empty() || normalized == "." {
211 return Ok(normalized);
212 }
213 let p = std::path::Path::new(&normalized);
214
215 let (resolved, jail_root) = {
216 let session = self.session.read().await;
217 let jail_root = session
218 .project_root
219 .as_deref()
220 .or(session.shell_cwd.as_deref())
221 .unwrap_or(".")
222 .to_string();
223
224 let resolved = if p.is_absolute() || p.exists() {
225 std::path::PathBuf::from(&normalized)
226 } else if let Some(ref root) = session.project_root {
227 let joined = std::path::Path::new(root).join(&normalized);
228 if joined.exists() {
229 joined
230 } else if let Some(ref cwd) = session.shell_cwd {
231 std::path::Path::new(cwd).join(&normalized)
232 } else {
233 std::path::Path::new(&jail_root).join(&normalized)
234 }
235 } else if let Some(ref cwd) = session.shell_cwd {
236 std::path::Path::new(cwd).join(&normalized)
237 } else {
238 std::path::Path::new(&jail_root).join(&normalized)
239 };
240
241 (resolved, jail_root)
242 };
243
244 let jail_root_path = std::path::Path::new(&jail_root);
245 let jailed = match crate::core::pathjail::jail_path(&resolved, jail_root_path) {
246 Ok(p) => p,
247 Err(e) => {
248 if p.is_absolute() {
249 if let Some(new_root) = maybe_derive_project_root_from_absolute(&resolved) {
250 let candidate_under_jail = resolved.starts_with(jail_root_path);
251 let allow_reroot = if !candidate_under_jail {
252 if let Some(ref trusted_root) = self.startup_project_root {
253 std::path::Path::new(trusted_root) == new_root.as_path()
254 } else {
255 !has_project_marker(jail_root_path)
256 || is_suspicious_root(jail_root_path)
257 }
258 } else {
259 false
260 };
261
262 if allow_reroot {
263 let mut session = self.session.write().await;
264 let new_root_str = new_root.to_string_lossy().to_string();
265 session.project_root = Some(new_root_str.clone());
266 session.shell_cwd = self
267 .startup_shell_cwd
268 .as_ref()
269 .filter(|cwd| std::path::Path::new(cwd).starts_with(&new_root))
270 .cloned()
271 .or_else(|| Some(new_root_str.clone()));
272 let _ = session.save();
273
274 crate::core::pathjail::jail_path(&resolved, &new_root)?
275 } else {
276 return Err(e);
277 }
278 } else {
279 return Err(e);
280 }
281 } else {
282 return Err(e);
283 }
284 }
285 };
286
287 Ok(crate::hooks::normalize_tool_path(
288 &jailed.to_string_lossy().replace('\\', "/"),
289 ))
290 }
291
292 pub async fn resolve_path_or_passthrough(&self, path: &str) -> String {
293 self.resolve_path(path)
294 .await
295 .unwrap_or_else(|_| path.to_string())
296 }
297
298 pub async fn check_idle_expiry(&self) {
299 if self.cache_ttl_secs == 0 {
300 return;
301 }
302 let last = *self.last_call.read().await;
303 if last.elapsed().as_secs() >= self.cache_ttl_secs {
304 {
305 let mut session = self.session.write().await;
306 let _ = session.save();
307 }
308 let mut cache = self.cache.write().await;
309 let count = cache.clear();
310 if count > 0 {
311 tracing::info!(
312 "Cache auto-cleared after {}s idle ({count} file(s))",
313 self.cache_ttl_secs
314 );
315 }
316 }
317 *self.last_call.write().await = Instant::now();
318 }
319
320 pub async fn record_call(
321 &self,
322 tool: &str,
323 original: usize,
324 saved: usize,
325 mode: Option<String>,
326 ) {
327 self.record_call_with_timing(tool, original, saved, mode, 0)
328 .await;
329 }
330
331 pub async fn record_call_with_timing(
332 &self,
333 tool: &str,
334 original: usize,
335 saved: usize,
336 mode: Option<String>,
337 duration_ms: u64,
338 ) {
339 let ts = chrono::Local::now().format("%Y-%m-%d %H:%M:%S").to_string();
340 let mut calls = self.tool_calls.write().await;
341 calls.push(ToolCallRecord {
342 tool: tool.to_string(),
343 original_tokens: original,
344 saved_tokens: saved,
345 mode: mode.clone(),
346 duration_ms,
347 timestamp: ts.clone(),
348 });
349
350 if duration_ms > 0 {
351 Self::append_tool_call_log(tool, duration_ms, original, saved, mode.as_deref(), &ts);
352 }
353
354 crate::core::events::emit_tool_call(
355 tool,
356 original as u64,
357 saved as u64,
358 mode.clone(),
359 duration_ms,
360 None,
361 );
362
363 let output_tokens = original.saturating_sub(saved);
364 crate::core::stats::record(tool, original, output_tokens);
365
366 let mut session = self.session.write().await;
367 session.record_tool_call(saved as u64, original as u64);
368 if tool == "ctx_shell" {
369 session.record_command();
370 }
371 if session.should_save() {
372 let _ = session.save();
373 }
374 drop(calls);
375 drop(session);
376
377 self.write_mcp_live_stats().await;
378 }
379
380 pub async fn is_prompt_cache_stale(&self) -> bool {
381 let last = *self.last_call.read().await;
382 last.elapsed().as_secs() > 3600
383 }
384
385 pub fn upgrade_mode_if_stale(mode: &str, stale: bool) -> &str {
386 if !stale {
387 return mode;
388 }
389 match mode {
390 "full" => "full",
391 "map" => "signatures",
392 m => m,
393 }
394 }
395
396 pub fn increment_and_check(&self) -> bool {
397 let count = self.call_count.fetch_add(1, Ordering::Relaxed) + 1;
398 self.checkpoint_interval > 0 && count.is_multiple_of(self.checkpoint_interval)
399 }
400
401 pub async fn auto_checkpoint(&self) -> Option<String> {
402 let cache = self.cache.read().await;
403 if cache.get_all_entries().is_empty() {
404 return None;
405 }
406 let complexity = crate::core::adaptive::classify_from_context(&cache);
407 let checkpoint = ctx_compress::handle(&cache, true, self.crp_mode);
408 drop(cache);
409
410 let mut session = self.session.write().await;
411 let _ = session.save();
412 let session_summary = session.format_compact();
413 let has_insights = !session.findings.is_empty() || !session.decisions.is_empty();
414 let project_root = session.project_root.clone();
415 drop(session);
416
417 if has_insights {
418 if let Some(ref root) = project_root {
419 let root = root.clone();
420 std::thread::spawn(move || {
421 auto_consolidate_knowledge(&root);
422 });
423 }
424 }
425
426 let multi_agent_block = self.auto_multi_agent_checkpoint(&project_root).await;
427
428 self.record_call("ctx_compress", 0, 0, Some("auto".to_string()))
429 .await;
430
431 self.record_cep_snapshot().await;
432
433 Some(format!(
434 "{checkpoint}\n\n--- SESSION STATE ---\n{session_summary}\n\n{}{multi_agent_block}",
435 complexity.instruction_suffix()
436 ))
437 }
438
439 async fn auto_multi_agent_checkpoint(&self, project_root: &Option<String>) -> String {
440 let root = match project_root {
441 Some(r) => r,
442 None => return String::new(),
443 };
444
445 let registry = crate::core::agents::AgentRegistry::load_or_create();
446 let active = registry.list_active(Some(root));
447 if active.len() <= 1 {
448 return String::new();
449 }
450
451 let agent_id = self.agent_id.read().await;
452 let my_id = match agent_id.as_deref() {
453 Some(id) => id.to_string(),
454 None => return String::new(),
455 };
456 drop(agent_id);
457
458 let cache = self.cache.read().await;
459 let entries = cache.get_all_entries();
460 if !entries.is_empty() {
461 let mut by_access: Vec<_> = entries.iter().collect();
462 by_access.sort_by_key(|x| std::cmp::Reverse(x.1.read_count));
463 let top_paths: Vec<&str> = by_access
464 .iter()
465 .take(5)
466 .map(|(key, _)| key.as_str())
467 .collect();
468 let paths_csv = top_paths.join(",");
469
470 let _ = ctx_share::handle("push", Some(&my_id), None, Some(&paths_csv), None, &cache);
471 }
472 drop(cache);
473
474 let pending_count = registry
475 .scratchpad
476 .iter()
477 .filter(|e| !e.read_by.contains(&my_id) && e.from_agent != my_id)
478 .count();
479
480 let shared_dir = crate::core::data_dir::lean_ctx_data_dir()
481 .unwrap_or_default()
482 .join("agents")
483 .join("shared");
484 let shared_count = if shared_dir.exists() {
485 std::fs::read_dir(&shared_dir)
486 .map(|rd| rd.count())
487 .unwrap_or(0)
488 } else {
489 0
490 };
491
492 let agent_names: Vec<String> = active
493 .iter()
494 .map(|a| {
495 let role = a.role.as_deref().unwrap_or(&a.agent_type);
496 format!("{role}({})", &a.agent_id[..8.min(a.agent_id.len())])
497 })
498 .collect();
499
500 format!(
501 "\n\n--- MULTI-AGENT SYNC ---\nAgents: {} | Pending msgs: {} | Shared contexts: {}\nAuto-shared top-5 cached files.\n--- END SYNC ---",
502 agent_names.join(", "),
503 pending_count,
504 shared_count,
505 )
506 }
507
508 pub fn append_tool_call_log(
509 tool: &str,
510 duration_ms: u64,
511 original: usize,
512 saved: usize,
513 mode: Option<&str>,
514 timestamp: &str,
515 ) {
516 const MAX_LOG_LINES: usize = 50;
517 if let Ok(dir) = crate::core::data_dir::lean_ctx_data_dir() {
518 let log_path = dir.join("tool-calls.log");
519 let mode_str = mode.unwrap_or("-");
520 let slow = if duration_ms > 5000 { " **SLOW**" } else { "" };
521 let line = format!(
522 "{timestamp}\t{tool}\t{duration_ms}ms\torig={original}\tsaved={saved}\tmode={mode_str}{slow}\n"
523 );
524
525 let mut lines: Vec<String> = std::fs::read_to_string(&log_path)
526 .unwrap_or_default()
527 .lines()
528 .map(|l| l.to_string())
529 .collect();
530
531 lines.push(line.trim_end().to_string());
532 if lines.len() > MAX_LOG_LINES {
533 lines.drain(0..lines.len() - MAX_LOG_LINES);
534 }
535
536 let _ = std::fs::write(&log_path, lines.join("\n") + "\n");
537 }
538 }
539
540 fn compute_cep_stats(
541 calls: &[ToolCallRecord],
542 stats: &crate::core::cache::CacheStats,
543 complexity: &crate::core::adaptive::TaskComplexity,
544 ) -> CepComputedStats {
545 let total_original: u64 = calls.iter().map(|c| c.original_tokens as u64).sum();
546 let total_saved: u64 = calls.iter().map(|c| c.saved_tokens as u64).sum();
547 let total_compressed = total_original.saturating_sub(total_saved);
548 let compression_rate = if total_original > 0 {
549 total_saved as f64 / total_original as f64
550 } else {
551 0.0
552 };
553
554 let modes_used: std::collections::HashSet<&str> =
555 calls.iter().filter_map(|c| c.mode.as_deref()).collect();
556 let mode_diversity = (modes_used.len() as f64 / 10.0).min(1.0);
557 let cache_util = stats.hit_rate() / 100.0;
558 let cep_score = cache_util * 0.3 + mode_diversity * 0.2 + compression_rate * 0.5;
559
560 let mut mode_counts: std::collections::HashMap<String, u64> =
561 std::collections::HashMap::new();
562 for call in calls {
563 if let Some(ref mode) = call.mode {
564 *mode_counts.entry(mode.clone()).or_insert(0) += 1;
565 }
566 }
567
568 CepComputedStats {
569 cep_score: (cep_score * 100.0).round() as u32,
570 cache_util: (cache_util * 100.0).round() as u32,
571 mode_diversity: (mode_diversity * 100.0).round() as u32,
572 compression_rate: (compression_rate * 100.0).round() as u32,
573 total_original,
574 total_compressed,
575 total_saved,
576 mode_counts,
577 complexity: format!("{:?}", complexity),
578 cache_hits: stats.cache_hits,
579 total_reads: stats.total_reads,
580 tool_call_count: calls.len() as u64,
581 }
582 }
583
584 async fn write_mcp_live_stats(&self) {
585 let cache = self.cache.read().await;
586 let calls = self.tool_calls.read().await;
587 let stats = cache.get_stats();
588 let complexity = crate::core::adaptive::classify_from_context(&cache);
589
590 let cs = Self::compute_cep_stats(&calls, stats, &complexity);
591 let started_at = calls
592 .first()
593 .map(|c| c.timestamp.clone())
594 .unwrap_or_default();
595
596 drop(cache);
597 drop(calls);
598 let live = serde_json::json!({
599 "cep_score": cs.cep_score,
600 "cache_utilization": cs.cache_util,
601 "mode_diversity": cs.mode_diversity,
602 "compression_rate": cs.compression_rate,
603 "task_complexity": cs.complexity,
604 "files_cached": cs.total_reads,
605 "total_reads": cs.total_reads,
606 "cache_hits": cs.cache_hits,
607 "tokens_saved": cs.total_saved,
608 "tokens_original": cs.total_original,
609 "tool_calls": cs.tool_call_count,
610 "started_at": started_at,
611 "updated_at": chrono::Local::now().to_rfc3339(),
612 });
613
614 if let Ok(dir) = crate::core::data_dir::lean_ctx_data_dir() {
615 let _ = std::fs::write(dir.join("mcp-live.json"), live.to_string());
616 }
617 }
618
619 pub async fn record_cep_snapshot(&self) {
620 let cache = self.cache.read().await;
621 let calls = self.tool_calls.read().await;
622 let stats = cache.get_stats();
623 let complexity = crate::core::adaptive::classify_from_context(&cache);
624
625 let cs = Self::compute_cep_stats(&calls, stats, &complexity);
626
627 drop(cache);
628 drop(calls);
629
630 crate::core::stats::record_cep_session(
631 cs.cep_score,
632 cs.cache_hits,
633 cs.total_reads,
634 cs.total_original,
635 cs.total_compressed,
636 &cs.mode_counts,
637 cs.tool_call_count,
638 &cs.complexity,
639 );
640 }
641}
642
643#[derive(Clone, Debug, Default)]
644struct StartupContext {
645 project_root: Option<String>,
646 shell_cwd: Option<String>,
647}
648
649pub fn create_server() -> LeanCtxServer {
650 LeanCtxServer::new()
651}
652
653const PROJECT_ROOT_MARKERS: &[&str] = &[
654 ".git",
655 ".lean-ctx.toml",
656 "Cargo.toml",
657 "package.json",
658 "go.mod",
659 "pyproject.toml",
660 "pom.xml",
661 "build.gradle",
662 "Makefile",
663 ".planning",
664];
665
666fn has_project_marker(dir: &std::path::Path) -> bool {
667 PROJECT_ROOT_MARKERS.iter().any(|m| dir.join(m).exists())
668}
669
670fn is_suspicious_root(dir: &std::path::Path) -> bool {
671 let s = dir.to_string_lossy();
672 s.contains("/.claude")
673 || s.contains("/.codex")
674 || s.contains("\\.claude")
675 || s.contains("\\.codex")
676}
677
678fn canonicalize_path(path: &std::path::Path) -> String {
679 crate::core::pathutil::safe_canonicalize_or_self(path)
680 .to_string_lossy()
681 .to_string()
682}
683
684fn detect_startup_context(
685 explicit_project_root: Option<&str>,
686 startup_cwd: Option<&std::path::Path>,
687) -> StartupContext {
688 let shell_cwd = startup_cwd.map(canonicalize_path);
689 let project_root = explicit_project_root
690 .map(|root| canonicalize_path(std::path::Path::new(root)))
691 .or_else(|| {
692 startup_cwd
693 .and_then(maybe_derive_project_root_from_absolute)
694 .map(|p| canonicalize_path(&p))
695 });
696
697 let shell_cwd = match (shell_cwd, project_root.as_ref()) {
698 (Some(cwd), Some(root))
699 if std::path::Path::new(&cwd).starts_with(std::path::Path::new(root)) =>
700 {
701 Some(cwd)
702 }
703 (Some(_), Some(root)) => Some(root.clone()),
704 (Some(cwd), None) => Some(cwd),
705 (None, Some(root)) => Some(root.clone()),
706 (None, None) => None,
707 };
708
709 StartupContext {
710 project_root,
711 shell_cwd,
712 }
713}
714
715fn maybe_derive_project_root_from_absolute(abs: &std::path::Path) -> Option<std::path::PathBuf> {
716 let mut cur = if abs.is_dir() {
717 abs.to_path_buf()
718 } else {
719 abs.parent()?.to_path_buf()
720 };
721 loop {
722 if has_project_marker(&cur) {
723 return Some(crate::core::pathutil::safe_canonicalize_or_self(&cur));
724 }
725 if !cur.pop() {
726 break;
727 }
728 }
729 None
730}
731
732fn auto_consolidate_knowledge(project_root: &str) {
733 use crate::core::knowledge::ProjectKnowledge;
734 use crate::core::session::SessionState;
735
736 let session = match SessionState::load_latest() {
737 Some(s) => s,
738 None => return,
739 };
740
741 if session.findings.is_empty() && session.decisions.is_empty() {
742 return;
743 }
744
745 let mut knowledge = ProjectKnowledge::load_or_create(project_root);
746
747 for finding in &session.findings {
748 let key = if let Some(ref file) = finding.file {
749 if let Some(line) = finding.line {
750 format!("{file}:{line}")
751 } else {
752 file.clone()
753 }
754 } else {
755 "finding-auto".to_string()
756 };
757 knowledge.remember("finding", &key, &finding.summary, &session.id, 0.7);
758 }
759
760 for decision in &session.decisions {
761 let key = decision
762 .summary
763 .chars()
764 .take(50)
765 .collect::<String>()
766 .replace(' ', "-")
767 .to_lowercase();
768 knowledge.remember("decision", &key, &decision.summary, &session.id, 0.85);
769 }
770
771 let task_desc = session
772 .task
773 .as_ref()
774 .map(|t| t.description.clone())
775 .unwrap_or_default();
776
777 let summary = format!(
778 "Auto-consolidate session {}: {} — {} findings, {} decisions",
779 session.id,
780 task_desc,
781 session.findings.len(),
782 session.decisions.len()
783 );
784 knowledge.consolidate(&summary, vec![session.id.clone()]);
785 let _ = knowledge.save();
786}
787
788#[cfg(test)]
789mod resolve_path_tests {
790 use super::*;
791
792 fn create_git_root(path: &std::path::Path) -> String {
793 std::fs::create_dir_all(path.join(".git")).unwrap();
794 canonicalize_path(path)
795 }
796
797 #[tokio::test]
798 async fn resolve_path_can_reroot_to_trusted_startup_root_when_session_root_is_stale() {
799 let tmp = tempfile::tempdir().unwrap();
800 let stale = tmp.path().join("stale");
801 let real = tmp.path().join("real");
802 std::fs::create_dir_all(&stale).unwrap();
803 let real_root = create_git_root(&real);
804 std::fs::write(real.join("a.txt"), "ok").unwrap();
805
806 let server = LeanCtxServer::new_with_startup(None, Some(real.clone()));
807 {
808 let mut session = server.session.write().await;
809 session.project_root = Some(stale.to_string_lossy().to_string());
810 session.shell_cwd = Some(stale.to_string_lossy().to_string());
811 }
812
813 let out = server
814 .resolve_path(&real.join("a.txt").to_string_lossy())
815 .await
816 .unwrap();
817
818 assert!(out.ends_with("/a.txt"));
819
820 let session = server.session.read().await;
821 assert_eq!(session.project_root.as_deref(), Some(real_root.as_str()));
822 assert_eq!(session.shell_cwd.as_deref(), Some(real_root.as_str()));
823 }
824
825 #[tokio::test]
826 async fn resolve_path_rejects_absolute_path_outside_trusted_startup_root() {
827 let tmp = tempfile::tempdir().unwrap();
828 let stale = tmp.path().join("stale");
829 let root = tmp.path().join("root");
830 let other = tmp.path().join("other");
831 std::fs::create_dir_all(&stale).unwrap();
832 create_git_root(&root);
833 let _other_value = create_git_root(&other);
834 std::fs::write(other.join("b.txt"), "no").unwrap();
835
836 let server = LeanCtxServer::new_with_startup(None, Some(root.clone()));
837 {
838 let mut session = server.session.write().await;
839 session.project_root = Some(stale.to_string_lossy().to_string());
840 session.shell_cwd = Some(stale.to_string_lossy().to_string());
841 }
842
843 let err = server
844 .resolve_path(&other.join("b.txt").to_string_lossy())
845 .await
846 .unwrap_err();
847 assert!(err.contains("path escapes project root"));
848
849 let session = server.session.read().await;
850 assert_eq!(
851 session.project_root.as_deref(),
852 Some(stale.to_string_lossy().as_ref())
853 );
854 }
855
856 #[tokio::test]
857 async fn startup_prefers_workspace_scoped_session_over_global_latest() {
858 let _data = tempfile::tempdir().unwrap();
859 let _tmp = tempfile::tempdir().unwrap();
860
861 let (server, root_b) = {
862 let _lock = crate::core::data_dir::test_env_lock();
863 std::env::set_var("LEAN_CTX_DATA_DIR", _data.path());
864
865 let repo_a = _tmp.path().join("repo-a");
866 let repo_b = _tmp.path().join("repo-b");
867 let root_a = create_git_root(&repo_a);
868 let root_b = create_git_root(&repo_b);
869
870 let mut session_b = SessionState::new();
871 session_b.project_root = Some(root_b.clone());
872 session_b.shell_cwd = Some(root_b.clone());
873 session_b.set_task("repo-b task", None);
874 session_b.save().unwrap();
875
876 let mut session_a = SessionState::new();
877 session_a.project_root = Some(root_a.clone());
878 session_a.shell_cwd = Some(root_a.clone());
879 session_a.set_task("repo-a latest task", None);
880 session_a.save().unwrap();
881
882 let server = LeanCtxServer::new_with_startup(None, Some(repo_b.clone()));
883 std::env::remove_var("LEAN_CTX_DATA_DIR");
884 (server, root_b)
885 };
886
887 let session = server.session.read().await;
888 assert_eq!(session.project_root.as_deref(), Some(root_b.as_str()));
889 assert_eq!(session.shell_cwd.as_deref(), Some(root_b.as_str()));
890 assert_eq!(
891 session.task.as_ref().map(|t| t.description.as_str()),
892 Some("repo-b task")
893 );
894 }
895
896 #[tokio::test]
897 async fn startup_creates_fresh_session_for_new_workspace_and_preserves_subdir_cwd() {
898 let _data = tempfile::tempdir().unwrap();
899 let _tmp = tempfile::tempdir().unwrap();
900
901 let (server, root_b, repo_b_src_value, old_id) = {
902 let _lock = crate::core::data_dir::test_env_lock();
903 std::env::set_var("LEAN_CTX_DATA_DIR", _data.path());
904
905 let repo_a = _tmp.path().join("repo-a");
906 let repo_b = _tmp.path().join("repo-b");
907 let repo_b_src = repo_b.join("src");
908 let root_a = create_git_root(&repo_a);
909 let root_b = create_git_root(&repo_b);
910 std::fs::create_dir_all(&repo_b_src).unwrap();
911 let repo_b_src_value = canonicalize_path(&repo_b_src);
912
913 let mut session_a = SessionState::new();
914 session_a.project_root = Some(root_a.clone());
915 session_a.shell_cwd = Some(root_a.clone());
916 session_a.set_task("repo-a latest task", None);
917 let old_id = session_a.id.clone();
918 session_a.save().unwrap();
919
920 let server = LeanCtxServer::new_with_startup(None, Some(repo_b_src.clone()));
921 std::env::remove_var("LEAN_CTX_DATA_DIR");
922 (server, root_b, repo_b_src_value, old_id)
923 };
924
925 let session = server.session.read().await;
926 assert_eq!(session.project_root.as_deref(), Some(root_b.as_str()));
927 assert_eq!(
928 session.shell_cwd.as_deref(),
929 Some(repo_b_src_value.as_str())
930 );
931 assert!(session.task.is_none());
932 assert_ne!(session.id, old_id);
933 }
934
935 #[tokio::test]
936 async fn resolve_path_does_not_auto_update_when_current_root_is_real_project() {
937 let tmp = tempfile::tempdir().unwrap();
938 let root = tmp.path().join("root");
939 let other = tmp.path().join("other");
940 let root_value = create_git_root(&root);
941 create_git_root(&other);
942 std::fs::write(other.join("b.txt"), "no").unwrap();
943
944 let server = LeanCtxServer::new_with_project_root(Some(root.to_string_lossy().to_string()));
945
946 let err = server
947 .resolve_path(&other.join("b.txt").to_string_lossy())
948 .await
949 .unwrap_err();
950 assert!(err.contains("path escapes project root"));
951
952 let session = server.session.read().await;
953 assert_eq!(session.project_root.as_deref(), Some(root_value.as_str()));
954 }
955}