lean-ctx 3.8.1

Context Runtime for AI Agents with CCP. 71 MCP tools, 10 read modes, 95+ compression patterns, cross-session memory (CCP), persistent AI knowledge with temporal facts + contradiction detection, multi-agent context sharing, LITM-aware positioning, AAAK compact format, adaptive compression with Thompson Sampling bandits. Supports 24+ AI tools. Reduces LLM token consumption by up to 99%.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

//! Doctor check for the deprecation register (GL #394).
//!
//! `DEPRECATIONS.toml` (repo root) is compiled into the binary, so the check
//! reports exactly the deprecations that apply to the installed build — per
//! CONTRACTS.md every surface is announced at least 2 minor releases before
//! removal, and `lean-ctx doctor` is the user-facing warning channel.

use super::{Outcome, BOLD, DIM, GREEN, RST, YELLOW};

const REGISTER: &str = include_str!("../../data/DEPRECATIONS.toml");

#[derive(Debug, serde::Deserialize)]
struct Register {
    #[serde(default)]
    deprecation: Vec<Deprecation>,
}

#[derive(Debug, serde::Deserialize)]
struct Deprecation {
    id: String,
    surface: String,
    subject: String,
    announced_in: String,
    earliest_removal: String,
    #[serde(default)]
    replacement: String,
    #[serde(default)]
    #[allow(dead_code)]
    note: String,
}

fn parse_register() -> Result<Register, toml::de::Error> {
    toml::from_str(REGISTER)
}

/// One scored doctor line: green when the shipping build deprecates nothing,
/// yellow with the full list otherwise (each entry names its replacement).
pub(super) fn deprecations_outcome() -> Outcome {
    match parse_register() {
        Ok(reg) if reg.deprecation.is_empty() => Outcome {
            ok: true,
            line: format!(
                "{BOLD}Deprecations{RST}  {GREEN}none active{RST}  {DIM}(register: DEPRECATIONS.toml, policy: CONTRACTS.md){RST}"
            ),
        },
        Ok(reg) => {
            let mut line = format!(
                "{BOLD}Deprecations{RST}  {YELLOW}{} active in this build{RST}",
                reg.deprecation.len()
            );
            for d in &reg.deprecation {
                let replacement = if d.replacement.is_empty() {
                    String::from("no replacement")
                } else {
                    format!("use {}", d.replacement)
                };
                line.push_str(&format!(
                    "\n      {YELLOW}•{RST} [{}] {} {DIM}({}){RST} — announced {}, removal ≥ {} — {DIM}{replacement}{RST}",
                    d.surface, d.subject, d.id, d.announced_in, d.earliest_removal
                ));
            }
            Outcome { ok: false, line }
        }
        Err(e) => Outcome {
            ok: false,
            line: format!("{BOLD}Deprecations{RST}  {YELLOW}register unreadable: {e}{RST}"),
        },
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn embedded_register_parses() {
        let reg = parse_register().expect("DEPRECATIONS.toml must stay parseable");
        // Policy invariant: each entry announces a removal at least 2 minor
        // releases ahead and carries a stable id.
        for d in &reg.deprecation {
            assert!(!d.id.is_empty());
            assert!(!d.subject.is_empty());
            let minor = |v: &str| -> Option<(u64, u64)> {
                let mut parts = v.split('.');
                Some((parts.next()?.parse().ok()?, parts.next()?.parse().ok()?))
            };
            let (a_major, a_minor) = minor(&d.announced_in).expect("announced_in is semver");
            let (r_major, r_minor) = minor(&d.earliest_removal).expect("earliest_removal semver");
            assert!(
                r_major > a_major || (r_major == a_major && r_minor >= a_minor + 2),
                "{}: earliest_removal must be >= 2 minor releases after announced_in",
                d.id
            );
        }
    }

    #[test]
    fn outcome_is_green_without_active_deprecations() {
        let reg = parse_register().expect("parseable");
        let outcome = deprecations_outcome();
        assert_eq!(outcome.ok, reg.deprecation.is_empty());
    }
}