@@ -14,6 +14,7 @@ All notable changes to sem are documented in this file.
 
 ### Fixed
 
+- **Copilot CLI can connect to the MCP server again.** Unsupported discovery probes return `Method not found` without closing the connection, allowing clients to fall back to `initialize` in both standalone and shared modes. Fixes #497.
 - **Indexed name lookup sees renames and added definitions in edited files.** `sem find` checks indexed file freshness and reparses changed files on demand, without requiring a whole dependency-graph refresh. Includes TypeScript, Python and Rust regression coverage.
 - **Dart dependency graphs now resolve ordinary calls, constructor-bound receivers and typed parameters.** Callers and refs no longer select a same-named Dart method for a TypeScript receiver (or vice versa); imported class owners take precedence. Persisted graph/query caches are invalidated so upgrades rebuild the affected edges. Fixes #491.
 - **Shared MCP clients keep independent context history and stay bound to their repository.** Concurrent daemon startup is serialized with an OS lock, stale sockets recover after crashes, and handshakes are bounded. Adds `sem mcp --status` for health checks and reproducible lifecycle coverage on macOS and Linux.
 
@@ -17,7 +17,7 @@
 import time
 
 
-def read_reply(process, request_id):
+def read_reply(process, request_id, expected_error=None):
     deadline = time.monotonic() + 30
     while time.monotonic() < deadline:
         ready, _, _ = select.select([process.stdout], [], [], max(0, deadline - time.monotonic()))
@@ -28,13 +28,16 @@ def read_reply(process, request_id):
             raise RuntimeError("MCP exited before response")
         reply = json.loads(line)
         if reply.get("id") == request_id:
+            if expected_error is not None:
+                assert reply.get("error", {}).get("code") == expected_error, reply
+                return reply["error"]
             if "error" in reply:
                 raise RuntimeError(reply)
             return reply["result"]
     raise TimeoutError("MCP response timed out")
 
 
-def session(binary, repo, shared):
+def session(binary, repo, shared, discovery=False):
     env = dict(os.environ)
     env.pop("SEM_MCP_SHARED_DAEMON", None)
     if shared:
@@ -54,6 +57,9 @@ def send(method, params, ident=None):
         process.stdin.write((json.dumps(message) + "\n").encode())
         process.stdin.flush()
     try:
+        if discovery:
+            send("server/discover", {}, 0)
+            read_reply(process, 0, expected_error=-32601)
         send("initialize", {"protocolVersion": "2025-03-26", "capabilities": {},
                             "clientInfo": {"name": "shared-benchmark", "version": "1"}}, 1)
         read_reply(process, 1)
@@ -111,6 +117,10 @@ def main():
         stale.close()
         try:
             cold = session(binary, repo, True)
+            # Copilot's discovery probe must not prevent legacy initialization
+            # or actual tool calls, on either transport path.
+            session(binary, repo, False, discovery=True)
+            session(binary, repo, True, discovery=True)
             stop_daemon(repo, crash=True)
             with concurrent.futures.ThreadPoolExecutor(max_workers=8) as pool:
                 concurrent_results = list(pool.map(lambda _: session(binary, repo, True), range(8)))
@@ -130,6 +140,7 @@ def main():
                       "build": str(binary), "concurrent_clients": len(concurrent_results),
                       "stale_socket_recovery": True, "restart_recovery": True,
                       "session_context_isolation": True,
+                      "discovery_fallback_standalone_and_shared": True,
                       "cold_start_ms": cold["ms"],
                       "model_tokens": None, "samples": samples}
             report["summary"] = {name: {"n": len(rows),
 
@@ -1,6 +1,8 @@
 use std::{future::Future, sync::Arc};
 
-use rmcp::model::{ClientJsonRpcMessage, ServerJsonRpcMessage};
+use rmcp::model::{
+    ClientJsonRpcMessage, ClientRequest, ErrorCode, ErrorData, ServerJsonRpcMessage,
+};
 use rmcp::transport::Transport;
 use rmcp::RoleServer;
 use serde::Serialize;
@@ -60,7 +62,35 @@ where
 
             let line = without_line_ending(&line);
             match parse_client_message(line) {
-                IncomingLine::Message(message) => return Some(*message),
+                IncomingLine::Message(message) => {
+                    // Reject unsupported extension methods here, before RMCP's
+                    // initialize gate. Clients such as Copilot probe server/discover
+                    // first and fall back to initialize on Method not found.
+                    // Passing the probe to RMCP 1.x instead terminates the session.
+                    if let ClientJsonRpcMessage::Request(request) = message.as_ref() {
+                        if matches!(request.request, ClientRequest::CustomRequest(_)) {
+                            if let Err(error) = self
+                                .send(ServerJsonRpcMessage::error(
+                                    ErrorData::new(
+                                        ErrorCode::METHOD_NOT_FOUND,
+                                        "Method not found",
+                                        None,
+                                    ),
+                                    request.id.clone(),
+                                ))
+                                .await
+                            {
+                                tracing::error!(
+                                    "Error writing method not found response: {}",
+                                    error
+                                );
+                                return None;
+                            }
+                            continue;
+                        }
+                    }
+                    return Some(*message);
+                }
                 IncomingLine::Ignore => {}
                 IncomingLine::ParseError => {
                     tracing::debug!("Malformed JSON-RPC frame received");
@@ -242,6 +272,36 @@ mod tests {
     use rmcp::model::{ClientRequest, JsonRpcMessage, NumberOrString};
     use tokio::io::AsyncReadExt;
 
+    #[tokio::test]
+    async fn unsupported_probes_preserve_ids_and_keep_transport_open() {
+        let (mut client_input, server_input) = tokio::io::duplex(4096);
+        let (server_output, client_output) = tokio::io::duplex(4096);
+        let mut transport = ResilientStdioTransport::new(server_input, server_output);
+        client_input
+            .write_all(
+                br#"{"jsonrpc":"2.0","id":0,"method":"server/discover","params":{}}
+{"jsonrpc":"2.0","id":"probe","method":"future/extension","params":{}}
+{"jsonrpc":"2.0","id":2,"method":"ping"}
+"#,
+            )
+            .await
+            .unwrap();
+        let message = tokio::time::timeout(std::time::Duration::from_secs(2), transport.receive())
+            .await
+            .unwrap()
+            .unwrap();
+        assert!(matches!(message, ClientJsonRpcMessage::Request(request)
+            if matches!(request.request, ClientRequest::PingRequest(_))));
+        let mut output = BufReader::new(client_output);
+        for id in [serde_json::json!(0), serde_json::json!("probe")] {
+            let mut line = String::new();
+            output.read_line(&mut line).await.unwrap();
+            let response: serde_json::Value = serde_json::from_str(&line).unwrap();
+            assert_eq!(response["id"], id);
+            assert_eq!(response["error"]["code"], -32601);
+        }
+    }
+
     #[tokio::test]
     async fn malformed_json_emits_parse_error_and_keeps_reading() {
         let (mut client_input, server_input) = tokio::io::duplex(1024);
 
@@ -38,6 +38,10 @@ struct McpClient {
 
 impl McpClient {
     fn spawn(repo: &Path) -> Self {
+        Self::spawn_with_discovery(repo, false)
+    }
+
+    fn spawn_with_discovery(repo: &Path, discovery: bool) -> Self {
         let mut child = Command::new(env!("CARGO_BIN_EXE_sem-mcp"))
             .current_dir(repo)
             // These tests exercise one isolated stdio server each.
@@ -55,6 +59,15 @@ impl McpClient {
             stdout,
             next_id: 1,
         };
+        if discovery {
+            let response = client.request("server/discover", json!({
+                "_meta": {
+                    "io.modelcontextprotocol/protocolVersion": "2026-07-28",
+                    "io.modelcontextprotocol/clientInfo": {"name": "copilot-cli", "version": "1.0.88"}
+                }
+            }));
+            assert_eq!(response["error"]["code"], -32601, "{response}");
+        }
         client.initialize();
         client
     }
@@ -173,6 +186,22 @@ fn tool_text(resp: &Value) -> String {
 
 // ── Fixture repo ──
 
+#[test]
+fn copilot_discovery_falls_back_to_initialize_and_tools_work() {
+    let repo = fixture_repo();
+    let mut client = McpClient::spawn_with_discovery(repo.path(), true);
+    assert!(client
+        .tools_list()
+        .iter()
+        .any(|tool| tool["name"] == "sem_entities"));
+    let response = client.call_tool("sem_entities", json!({"path": "src/needle.py"}));
+    assert!(tool_text(&response).contains("needle_target_fn"));
+    // Unknown methods must also leave an initialized session usable.
+    let response = client.request("future/extension", json!({}));
+    assert_eq!(response["error"]["code"], -32601);
+    assert!(!client.tools_list().is_empty());
+}
+
 fn git(repo: &Path, args: &[&str]) {
     let status = Command::new("git")
         .current_dir(repo)