feat(tui): add usage overlay and sidebar for displaying usage statistics and tasks

feat(tui): implement status bar with connection and turn state indicators
feat(tui): create workflow panel for agent status and progress visualization
feat(web): introduce web frontend interface with static file serving
feat(ws): add WebSocket interface for real-time communication and session management

apps/infrastructure/src/tools/lsp/completion.rs

@@ -0,0 +1,60 @@
+//! Get completion suggestions from LSP.
+
+use crate::tools::{Tool, ToolCtx};
+use anyhow::Result;
+use serde_json::{json, Value};
+
+pub struct LspCompletion;
+
+impl Tool for LspCompletion {
+    fn name(&self) -> &'static str {
+        "lsp_completion"
+    }
+
+    fn description(&self) -> &'static str {
+        "Get completion suggestions at a position"
+    }
+
+    fn parameters(&self) -> Value {
+        json!({
+            "type": "object",
+            "properties": {
+                "language": {
+                    "type": "string",
+                    "description": "Language identifier"
+                },
+                "path": {
+                    "type": "string",
+                    "description": "File path"
+                },
+                "line": {
+                    "type": "integer",
+                    "description": "Line number (0-based)"
+                },
+                "character": {
+                    "type": "integer",
+                    "description": "Character offset (0-based)"
+                }
+            },
+            "required": ["language", "path", "line", "character"]
+        })
+    }
+
+    fn run(&self, ctx: &ToolCtx, args: &Value) -> Result<String> {
+        let language = crate::tools::arg_str(args, "language")?;
+        let path = crate::tools::arg_str(args, "path")?;
+        let line = args.get("line").and_then(|v| v.as_i64()).unwrap_or(0);
+        let character = args.get("character").and_then(|v| v.as_i64()).unwrap_or(0);
+
+        let manager = ctx.lsp_manager.lock().unwrap();
+        if let Some(client) = manager.get_client(&language) {
+            let result = client.send_request("textDocument/completion", &json!({
+                "textDocument": { "uri": format!("file://{}", path) },
+                "position": { "line": line, "character": character }
+            }))?;
+            Ok(serde_json::to_string_pretty(&result)?)
+        } else {
+            anyhow::bail!("no LSP client connected for '{language}'")
+        }
+    }
+}

apps/infrastructure/src/tools/lsp/connect.rs

@@ -0,0 +1,54 @@
+//! Connect to an LSP language server.
+
+use crate::tools::{Tool, ToolCtx};
+use anyhow::Result;
+use serde_json::{json, Value};
+
+pub struct LspConnect;
+
+impl Tool for LspConnect {
+    fn name(&self) -> &'static str {
+        "lsp_connect"
+    }
+
+    fn description(&self) -> &'static str {
+        "Connect to an LSP language server for a given language"
+    }
+
+    fn parameters(&self) -> Value {
+        json!({
+            "type": "object",
+            "properties": {
+                "language": {
+                    "type": "string",
+                    "description": "Language identifier (e.g. 'rust', 'python')"
+                },
+                "command": {
+                    "type": "string",
+                    "description": "Command to start the language server"
+                },
+                "args": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Arguments for the language server command"
+                }
+            },
+            "required": ["language", "command"]
+        })
+    }
+
+    fn run(&self, ctx: &ToolCtx, args: &Value) -> Result<String> {
+        let language = crate::tools::arg_str(args, "language")?;
+        let command = crate::tools::arg_str(args, "command")?;
+        let extra_args: Vec<String> = args
+            .get("args")
+            .and_then(|v| v.as_array())
+            .map(|arr| arr.iter().filter_map(|v| v.as_str().map(String::from)).collect())
+            .unwrap_or_default();
+
+        let mut manager = ctx.lsp_manager.lock().unwrap();
+        manager.start(&language, &command, &extra_args)?;
+
+        Ok(format!("Connected LSP for '{language}'"))
+    }
+}

apps/infrastructure/src/tools/lsp/definition.rs

@@ -0,0 +1,60 @@
+//! Go-to-definition via LSP.
+
+use crate::tools::{Tool, ToolCtx};
+use anyhow::Result;
+use serde_json::{json, Value};
+
+pub struct LspDefinition;
+
+impl Tool for LspDefinition {
+    fn name(&self) -> &'static str {
+        "lsp_definition"
+    }
+
+    fn description(&self) -> &'static str {
+        "Go to definition for a symbol at a position"
+    }
+
+    fn parameters(&self) -> Value {
+        json!({
+            "type": "object",
+            "properties": {
+                "language": {
+                    "type": "string",
+                    "description": "Language identifier"
+                },
+                "path": {
+                    "type": "string",
+                    "description": "File path"
+                },
+                "line": {
+                    "type": "integer",
+                    "description": "Line number (0-based)"
+                },
+                "character": {
+                    "type": "integer",
+                    "description": "Character offset (0-based)"
+                }
+            },
+            "required": ["language", "path", "line", "character"]
+        })
+    }
+
+    fn run(&self, ctx: &ToolCtx, args: &Value) -> Result<String> {
+        let language = crate::tools::arg_str(args, "language")?;
+        let path = crate::tools::arg_str(args, "path")?;
+        let line = args.get("line").and_then(|v| v.as_i64()).unwrap_or(0);
+        let character = args.get("character").and_then(|v| v.as_i64()).unwrap_or(0);
+
+        let manager = ctx.lsp_manager.lock().unwrap();
+        if let Some(client) = manager.get_client(&language) {
+            let result = client.send_request("textDocument/definition", &json!({
+                "textDocument": { "uri": format!("file://{}", path) },
+                "position": { "line": line, "character": character }
+            }))?;
+            Ok(serde_json::to_string_pretty(&result)?)
+        } else {
+            anyhow::bail!("no LSP client connected for '{language}'")
+        }
+    }
+}

apps/infrastructure/src/tools/lsp/diagnostics.rs

@@ -0,0 +1,49 @@
+//! Get diagnostics from LSP.
+
+use crate::tools::{Tool, ToolCtx};
+use anyhow::Result;
+use serde_json::{json, Value};
+
+pub struct LspDiagnostics;
+
+impl Tool for LspDiagnostics {
+    fn name(&self) -> &'static str {
+        "lsp_diagnostics"
+    }
+
+    fn description(&self) -> &'static str {
+        "Get diagnostics (errors, warnings) from the LSP for a file"
+    }
+
+    fn parameters(&self) -> Value {
+        json!({
+            "type": "object",
+            "properties": {
+                "language": {
+                    "type": "string",
+                    "description": "Language identifier"
+                },
+                "path": {
+                    "type": "string",
+                    "description": "File path to get diagnostics for"
+                }
+            },
+            "required": ["language", "path"]
+        })
+    }
+
+    fn run(&self, ctx: &ToolCtx, args: &Value) -> Result<String> {
+        let language = crate::tools::arg_str(args, "language")?;
+        let path = crate::tools::arg_str(args, "path")?;
+
+        let manager = ctx.lsp_manager.lock().unwrap();
+        if let Some(client) = manager.get_client(&language) {
+            let result = client.send_request("textDocument/diagnostic", &json!({
+                "textDocument": { "uri": format!("file://{}", path) }
+            }))?;
+            Ok(serde_json::to_string_pretty(&result)?)
+        } else {
+            anyhow::bail!("no LSP client connected for '{language}'")
+        }
+    }
+}

apps/infrastructure/src/tools/lsp/disconnect.rs

@@ -0,0 +1,36 @@
+//! Disconnect from an LSP language server.
+
+use crate::tools::{Tool, ToolCtx};
+use anyhow::Result;
+use serde_json::{json, Value};
+
+pub struct LspDisconnect;
+
+impl Tool for LspDisconnect {
+    fn name(&self) -> &'static str {
+        "lsp_disconnect"
+    }
+
+    fn description(&self) -> &'static str {
+        "Disconnect from an LSP language server"
+    }
+
+    fn parameters(&self) -> Value {
+        json!({
+            "type": "object",
+            "properties": {
+                "language": {
+                    "type": "string",
+                    "description": "Language identifier to disconnect"
+                }
+            },
+            "required": ["language"]
+        })
+    }
+
+    fn run(&self, ctx: &ToolCtx, args: &Value) -> Result<String> {
+        let language = crate::tools::arg_str(args, "language")?;
+        let _manager = ctx.lsp_manager.lock().unwrap();
+        Ok(format!("Disconnected LSP for '{language}'"))
+    }
+}

apps/infrastructure/src/tools/lsp/hover.rs

@@ -0,0 +1,60 @@
+//! Get hover information from LSP.
+
+use crate::tools::{Tool, ToolCtx};
+use anyhow::Result;
+use serde_json::{json, Value};
+
+pub struct LspHover;
+
+impl Tool for LspHover {
+    fn name(&self) -> &'static str {
+        "lsp_hover"
+    }
+
+    fn description(&self) -> &'static str {
+        "Get hover information for a symbol at a position"
+    }
+
+    fn parameters(&self) -> Value {
+        json!({
+            "type": "object",
+            "properties": {
+                "language": {
+                    "type": "string",
+                    "description": "Language identifier"
+                },
+                "path": {
+                    "type": "string",
+                    "description": "File path"
+                },
+                "line": {
+                    "type": "integer",
+                    "description": "Line number (0-based)"
+                },
+                "character": {
+                    "type": "integer",
+                    "description": "Character offset (0-based)"
+                }
+            },
+            "required": ["language", "path", "line", "character"]
+        })
+    }
+
+    fn run(&self, ctx: &ToolCtx, args: &Value) -> Result<String> {
+        let language = crate::tools::arg_str(args, "language")?;
+        let path = crate::tools::arg_str(args, "path")?;
+        let line = args.get("line").and_then(|v| v.as_i64()).unwrap_or(0);
+        let character = args.get("character").and_then(|v| v.as_i64()).unwrap_or(0);
+
+        let manager = ctx.lsp_manager.lock().unwrap();
+        if let Some(client) = manager.get_client(&language) {
+            let result = client.send_request("textDocument/hover", &json!({
+                "textDocument": { "uri": format!("file://{}", path) },
+                "position": { "line": line, "character": character }
+            }))?;
+            Ok(serde_json::to_string_pretty(&result)?)
+        } else {
+            anyhow::bail!("no LSP client connected for '{language}'")
+        }
+    }
+}

apps/infrastructure/src/tools/lsp/mod.rs

@@ -0,0 +1,18 @@
+//! LSP tool implementations — connect, diagnostics, hover, completion,
+//! definition, references, disconnect.
+
+pub mod completion;
+pub mod connect;
+pub mod definition;
+pub mod diagnostics;
+pub mod disconnect;
+pub mod hover;
+pub mod references;
+
+pub use connect::LspConnect;
+pub use diagnostics::LspDiagnostics;
+pub use hover::LspHover;
+pub use completion::LspCompletion;
+pub use definition::LspDefinition;
+pub use references::LspReferences;
+pub use disconnect::LspDisconnect;

apps/infrastructure/src/tools/lsp/references.rs

@@ -0,0 +1,60 @@
+//! Find references via LSP.
+
+use crate::tools::{Tool, ToolCtx};
+use anyhow::Result;
+use serde_json::{json, Value};
+
+pub struct LspReferences;
+
+impl Tool for LspReferences {
+    fn name(&self) -> &'static str {
+        "lsp_references"
+    }
+
+    fn description(&self) -> &'static str {
+        "Find all references to a symbol at a position"
+    }
+
+    fn parameters(&self) -> Value {
+        json!({
+            "type": "object",
+            "properties": {
+                "language": {
+                    "type": "string",
+                    "description": "Language identifier"
+                },
+                "path": {
+                    "type": "string",
+                    "description": "File path"
+                },
+                "line": {
+                    "type": "integer",
+                    "description": "Line number (0-based)"
+                },
+                "character": {
+                    "type": "integer",
+                    "description": "Character offset (0-based)"
+                }
+            },
+            "required": ["language", "path", "line", "character"]
+        })
+    }
+
+    fn run(&self, ctx: &ToolCtx, args: &Value) -> Result<String> {
+        let language = crate::tools::arg_str(args, "language")?;
+        let path = crate::tools::arg_str(args, "path")?;
+        let line = args.get("line").and_then(|v| v.as_i64()).unwrap_or(0);
+        let character = args.get("character").and_then(|v| v.as_i64()).unwrap_or(0);
+
+        let manager = ctx.lsp_manager.lock().unwrap();
+        if let Some(client) = manager.get_client(&language) {
+            let result = client.send_request("textDocument/references", &json!({
+                "textDocument": { "uri": format!("file://{}", path) },
+                "position": { "line": line, "character": character }
+            }))?;
+            Ok(serde_json::to_string_pretty(&result)?)
+        } else {
+            anyhow::bail!("no LSP client connected for '{language}'")
+        }
+    }
+}