LSP Phase 7: CLI + config plumbing through build_channels

src/config/mod.rs
- LspConfig: untagged enum, accepts `true`/`false` OR a map of
  per-server overrides.
- LspServerConfig: all-optional fields (command, extensions, env,
  initialization, disabled). Missing fields fall back to built-in.
- Config gains an optional `lsp` field; default-None (which the CLI
  resolver treats as enabled-with-built-ins).
- 4 config-parse tests: bool form, per-server map form, absent-is-None,
  mixed command/disabled entries.

src/cli.rs
- `--no-lsp` flag.
- `resolve_lsp_enabled(cli, cfg)` resolver: no-tools or no-lsp turns it
  off; otherwise the config bool (default true) decides.

src/lsp/spawn.rs
- ProcessSpawner::default_commands(): the 4 built-in commands for v1
  servers (rust-analyzer, typescript-language-server --stdio,
  pyright-langserver --stdio, clojure-lsp). User config overrides are
  merged in main::compile_lsp_commands.

src/main.rs
- build_channels grows a 10th return slot: Option<Arc<LspManager>>.
  Constructed when lsp_enabled, via ProcessSpawner with merged defaults
  + user overrides.
- compile_lsp_commands: starts from defaults, applies per-server
  overrides (disabled removes, command replaces, env/init merge).
- Threaded through all 3 `build_agent` call sites + run_interactive.

src/provider.rs + src/agent/builder.rs
- New `lsp_manager: Option<Arc<LspManager>>` arg on build_agent /
  build_agent_inner. Threaded down to the WriteTool / EditTool /
  ReadTool constructors (which Phase 6 prepared the field for) AND to
  the LspTool registration (Phase 5's tool now actually gets attached
  to the agent when lsp_manager is present).

src/ui/mod.rs + src/ui/slash.rs + src/extras/acp/mod.rs
- run_interactive accepts and forwards lsp_manager.
- Plan-switch rebuild passes the live lsp_manager.clone() (so the
  rebuilt agent still has LSP tools — same pattern as the bg-store
  fix from Phase 5).
- 7 slash.rs sub-rebuild sites + 2 ui/mod.rs prompt-switch sites pass
  `None` for lsp_manager (intentional — these rebuild for /model,
  /context-reset etc., which don't need to re-attach LSP).
- ACP path passes `None`.

src/agent/tools/lsp.rs
- Drops the Phase-5 `#![allow(dead_code)]` now that builder.rs wires it.

Phase 6: 116, Phase 7: +4 config tests -> 120 LSP tests.
Suite: 422 -> 426.

Author: Yogthos

src/agent/builder.rs

@@ -37,6 +37,7 @@ pub async fn build_agent_inner<M: CompletionModel + 'static>(
     question_tx: Option<QuestionSender>,
     plan_tx: Option<PlanSwitchSender>,
     bg_store: Option<BackgroundStore>,
+    lsp_manager: Option<std::sync::Arc<crate::lsp::manager::LspManager>>,
     sandbox: Sandbox,
     parent_model: Option<AnyModel>,
     #[cfg(feature = "mcp")] mcp_manager: Option<&McpClientManager>,
@@ -140,22 +141,21 @@ pub async fn build_agent_inner<M: CompletionModel + 'static>(
                 permission.clone(),
                 ask_tx.clone(),
                 cache.clone(),
-                // Phase 7 will populate this from build_channels.
-                None,
+                lsp_manager.clone(),
             )),
             Box::new(tools::WriteTool::with_cache(
                 permission.clone(),
                 ask_tx.clone(),
                 plan_file.clone(),
                 cache.clone(),
-                None,
+                lsp_manager.clone(),
             )),
             Box::new(tools::EditTool::with_cache(
                 permission.clone(),
                 ask_tx.clone(),
                 plan_file.clone(),
                 cache.clone(),
-                None,
+                lsp_manager.clone(),
             )),
             Box::new(tools::BashTool::with_cache(
                 permission.clone(),
@@ -262,6 +262,17 @@ pub async fn build_agent_inner<M: CompletionModel + 'static>(
             builder = builder.tools(vec![task_tool, status_tool]);
         }
 
+        if let Some(manager) = &lsp_manager {
+            let cwd = std::env::current_dir().unwrap_or_else(|_| ".".into());
+            let lsp_tool = Box::new(tools::LspTool::new(
+                permission.clone(),
+                ask_tx.clone(),
+                manager.clone(),
+                cwd,
+            )) as Box<dyn rig::tool::ToolDyn>;
+            builder = builder.tools(vec![lsp_tool]);
+        }
+
         #[cfg(feature = "mcp")]
         if let Some(manager) = &mcp_manager {
             let mcp_tools = manager

src/agent/tools/lsp.rs

@@ -4,14 +4,6 @@
 //! tool, one `operation` parameter; the agent picks which LSP capability to
 //! invoke. Mirrors opencode's `tool/lsp.ts` surface so the agent's mental
 //! model carries between the two.
-//!
-//! Phase 5 lands the tool + its tests. The builder.rs wiring that actually
-//! attaches it to a running agent comes in Phase 7 (config + CLI plumbing).
-//! Until then the symbols here are unused outside the test module — the
-//! crate-wide `#[allow(dead_code)]` in `lsp/mod.rs` doesn't extend here, so
-//! the tool's items carry their own `#[allow(dead_code)]` to keep the
-//! warning surface clean.
-#![allow(dead_code)]
 
 use std::path::{Path, PathBuf};
 use std::sync::Arc;

src/agent/tools/mod.rs

@@ -30,8 +30,6 @@ pub use find_files::FindFilesTool;
 pub use glob::GlobTool;
 pub use grep::GrepTool;
 pub use list_dir::ListDirTool;
-// Phase 5 lands the tool; builder.rs wiring is Phase 7.
-#[allow(unused_imports)]
 pub use lsp::LspTool;
 pub use memory::MemoryTool;
 pub use plan::{PlanEnterTool, PlanExitTool};

src/cli.rs

@@ -48,6 +48,12 @@ pub struct Cli {
     #[arg(long = "no-tools", help = "Disable all tools")]
     pub no_tools: bool,
 
+    #[arg(
+        long = "no-lsp",
+        help = "Disable LSP integration (no diagnostics on edit/write, no `lsp` agent tool)"
+    )]
+    pub no_lsp: bool,
+
     #[arg(long = "no-color", help = "Disable colored TUI output")]
     pub no_color: bool,
 
@@ -161,6 +167,16 @@ impl Cli {
         self.no_tools || cfg.no_tools.unwrap_or(false)
     }
 
+    pub fn resolve_lsp_enabled(&self, cfg: &config::Config) -> bool {
+        if self.no_lsp || self.no_tools {
+            return false;
+        }
+        match &cfg.lsp {
+            Some(c) => c.is_enabled(),
+            None => true, // default-on
+        }
+    }
+
     pub fn resolve_sandbox(&self, cfg: &config::Config) -> bool {
         self.sandbox || cfg.sandbox.unwrap_or(false)
     }

src/config/mod.rs

@@ -25,6 +25,57 @@ pub struct ToolsConfig {
     pub webfetch: Option<bool>,
 }
 
+/// Per-server LSP configuration. All fields optional — unspecified fields
+/// fall back to the built-in defaults for the given `server_id`.
+///
+/// Two forms are accepted:
+/// - `{ "disabled": true }` to turn off a built-in server entirely.
+/// - any subset of `{ command, extensions, env, initialization, disabled }`
+///   to override pieces of the default.
+#[derive(Debug, Default, Clone, Deserialize)]
+#[serde(default)]
+pub struct LspServerConfig {
+    pub command: Option<Vec<String>>,
+    pub extensions: Option<Vec<String>>,
+    pub env: Option<HashMap<String, String>>,
+    pub initialization: Option<serde_json::Value>,
+    pub disabled: Option<bool>,
+}
+
+/// `lsp = true`  → enable built-in servers with default commands.
+/// `lsp = false` → disable LSP entirely.
+/// `lsp = { server-id = { … } }` → enable defaults, overriding the named
+///   servers with the provided config.
+#[derive(Debug, Clone, Deserialize)]
+#[serde(untagged)]
+pub enum LspConfig {
+    Enabled(bool),
+    Servers(HashMap<String, LspServerConfig>),
+}
+
+impl LspConfig {
+    /// `true` when LSP should be on. Defaults to enabled.
+    pub fn is_enabled(&self) -> bool {
+        match self {
+            LspConfig::Enabled(b) => *b,
+            LspConfig::Servers(_) => true,
+        }
+    }
+
+    /// Per-server overrides keyed by server id. Empty when LSP is a bool.
+    pub fn server_overrides(&self) -> &HashMap<String, LspServerConfig> {
+        match self {
+            LspConfig::Enabled(_) => {
+                // Empty borrow without allocating per-call.
+                static EMPTY: std::sync::OnceLock<HashMap<String, LspServerConfig>> =
+                    std::sync::OnceLock::new();
+                EMPTY.get_or_init(HashMap::new)
+            }
+            LspConfig::Servers(map) => map,
+        }
+    }
+}
+
 #[derive(Debug, Default, Deserialize)]
 #[serde(default)]
 pub struct Config {
@@ -51,6 +102,7 @@ pub struct Config {
     pub tool_result_max_chars: Option<usize>,
     pub default_prompt: Option<String>,
     pub tools: Option<ToolsConfig>,
+    pub lsp: Option<LspConfig>,
     #[cfg(feature = "mcp")]
     pub mcp_servers: Option<HashMap<String, McpServerConfig>>,
 
@@ -141,3 +193,69 @@ pub fn load() -> Config {
 
     cfg
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn lsp_config_parses_as_bool() {
+        let cfg: Config = serde_json::from_str(r#"{"lsp": true}"#).unwrap();
+        assert!(cfg.lsp.unwrap().is_enabled());
+
+        let cfg: Config = serde_json::from_str(r#"{"lsp": false}"#).unwrap();
+        assert!(!cfg.lsp.unwrap().is_enabled());
+    }
+
+    #[test]
+    fn lsp_config_parses_as_per_server_map() {
+        let raw = r#"{
+            "lsp": {
+                "rust": { "command": ["my-rust-analyzer", "--my-arg"] },
+                "typescript": { "disabled": true }
+            }
+        }"#;
+        let cfg: Config = serde_json::from_str(raw).unwrap();
+        let overrides = cfg.lsp.as_ref().unwrap().server_overrides();
+        assert_eq!(overrides.len(), 2);
+        assert_eq!(
+            overrides["rust"].command.as_ref().unwrap(),
+            &vec!["my-rust-analyzer".to_string(), "--my-arg".to_string()]
+        );
+        assert_eq!(overrides["typescript"].disabled, Some(true));
+    }
+
+    // Regression: when lsp is omitted entirely, default is "enabled with
+    // built-in commands" — the CLI's resolve_lsp_enabled handles that.
+    // Config-side, an absent value parses to `None`.
+    #[test]
+    fn absent_lsp_config_is_none() {
+        let cfg: Config = serde_json::from_str(r#"{"model": "foo"}"#).unwrap();
+        assert!(cfg.lsp.is_none());
+    }
+
+    // Regression: a config that mixes overrides for valid server ids
+    // (rust) with disabled-only entries (typescript) must parse cleanly.
+    #[test]
+    fn lsp_config_mixes_command_and_disabled_entries() {
+        let raw = r#"{
+            "lsp": {
+                "rust": { "command": ["rust-analyzer"], "env": {"RUST_LOG": "info"} },
+                "typescript": { "disabled": true }
+            }
+        }"#;
+        let cfg: Config = serde_json::from_str(raw).unwrap();
+        let overrides = cfg.lsp.as_ref().unwrap().server_overrides();
+        assert!(overrides["rust"].command.is_some());
+        assert_eq!(
+            overrides["rust"]
+                .env
+                .as_ref()
+                .unwrap()
+                .get("RUST_LOG")
+                .unwrap(),
+            "info"
+        );
+        assert_eq!(overrides["typescript"].disabled, Some(true));
+    }
+}

src/extras/acp/mod.rs

@@ -170,6 +170,7 @@ async fn run_prompt(
         None,
         None,
         None,
+        None,
         sandbox,
         #[cfg(feature = "mcp")]
         None::<&crate::extras::mcp::McpClientManager>,

src/lsp/spawn.rs

@@ -62,6 +62,50 @@ impl ProcessSpawner {
     pub fn new(commands: std::collections::HashMap<String, ProcessCommand>) -> Self {
         Self { commands }
     }
+
+    /// Built-in command defaults for the v1 server set. Each entry is the
+    /// program name + argv to launch. The actual `tokio::process::Command`
+    /// resolves `program` via PATH at spawn time.
+    pub fn default_commands() -> std::collections::HashMap<String, ProcessCommand> {
+        let mut m = std::collections::HashMap::new();
+        m.insert(
+            "rust".to_string(),
+            ProcessCommand {
+                program: PathBuf::from("rust-analyzer"),
+                args: vec![],
+                env: vec![],
+                init_options: Value::Null,
+            },
+        );
+        m.insert(
+            "typescript".to_string(),
+            ProcessCommand {
+                program: PathBuf::from("typescript-language-server"),
+                args: vec!["--stdio".to_string()],
+                env: vec![],
+                init_options: Value::Null,
+            },
+        );
+        m.insert(
+            "pyright".to_string(),
+            ProcessCommand {
+                program: PathBuf::from("pyright-langserver"),
+                args: vec!["--stdio".to_string()],
+                env: vec![],
+                init_options: Value::Null,
+            },
+        );
+        m.insert(
+            "clojure-lsp".to_string(),
+            ProcessCommand {
+                program: PathBuf::from("clojure-lsp"),
+                args: vec![],
+                env: vec![],
+                init_options: Value::Null,
+            },
+        );
+        m
+    }
 }
 
 impl Spawner for ProcessSpawner {