dsh-ops 0.0.0-stage → 0.2.2

package/vendor/fastctx/src/search_parallelism.rs

@@ -0,0 +1,106 @@
+// Modified by dsh-ops (https://github.com/T-Auto/dsh-ops): removed the TUI-only editable-input parser and its error type, which the deleted src/tui/ editors were the only callers of.
+//! Shared detection and validation for grep/glob CPU parallelism.
+
+use std::fmt;
+
+/// Hard ceiling for effective `P`: one request-local base lane plus shared extra lanes.
+pub(crate) const MAX_SEARCH_PARALLELISM: usize = 16;
+
+/// Resolved search parallelism using the same ceiling as the executor.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) struct SearchParallelism {
+    /// Engine-visible CPU ceiling derived from `available_parallelism`.
+    pub(crate) available: usize,
+    /// Explicit user limit, or `None` for automatic parallelism.
+    pub(crate) configured: Option<usize>,
+    /// Effective `P`, including the request-local base lane.
+    pub(crate) effective: usize,
+}
+
+/// Range failure for a typed persisted CPU limit.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) struct SearchParallelismRangeError {
+    pub(crate) maximum: usize,
+}
+
+impl fmt::Display for SearchParallelismRangeError {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            formatter,
+            "must be an integer in 1..={} or omitted for automatic parallelism",
+            self.maximum
+        )
+    }
+}
+
+/// Detects the exact upper bound used by the search executor.
+pub(crate) fn detected_available() -> usize {
+    std::thread::available_parallelism()
+        .map(usize::from)
+        .unwrap_or(1)
+        .clamp(1, MAX_SEARCH_PARALLELISM)
+}
+
+/// Resolves an optional persisted limit against the current engine-visible ceiling.
+pub(crate) fn resolve(
+    configured: Option<i64>,
+) -> Result<SearchParallelism, SearchParallelismRangeError> {
+    resolve_with_available(configured, detected_available())
+}
+
+fn resolve_with_available(
+    configured: Option<i64>,
+    available: usize,
+) -> Result<SearchParallelism, SearchParallelismRangeError> {
+    let available = available.clamp(1, MAX_SEARCH_PARALLELISM);
+    let configured = configured
+        .map(|value| validate(value, available))
+        .transpose()?;
+    Ok(SearchParallelism {
+        available,
+        configured,
+        effective: configured.unwrap_or(available),
+    })
+}
+
+fn validate(value: i64, maximum: usize) -> Result<usize, SearchParallelismRangeError> {
+    usize::try_from(value)
+        .ok()
+        .filter(|value| (1..=maximum).contains(value))
+        .ok_or(SearchParallelismRangeError { maximum })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{MAX_SEARCH_PARALLELISM, resolve_with_available};
+
+    #[test]
+    fn engine_ceiling_and_configured_limit_share_one_resolution_path() {
+        let automatic = resolve_with_available(None, 64).unwrap();
+        assert_eq!(automatic.available, MAX_SEARCH_PARALLELISM);
+        assert_eq!(automatic.configured, None);
+        assert_eq!(automatic.effective, MAX_SEARCH_PARALLELISM);
+
+        let configured = resolve_with_available(Some(4), 64).unwrap();
+        assert_eq!(configured.available, MAX_SEARCH_PARALLELISM);
+        assert_eq!(configured.configured, Some(4));
+        assert_eq!(configured.effective, 4);
+
+        let fallback_machine = resolve_with_available(None, 0).unwrap();
+        assert_eq!(fallback_machine.available, 1);
+        assert_eq!(fallback_machine.effective, 1);
+    }
+
+    #[test]
+    fn persisted_limits_accept_both_boundaries_and_reject_every_out_of_range_shape() {
+        for value in [1, 4, 8] {
+            let resolved = resolve_with_available(Some(value), 8).unwrap();
+            assert_eq!(resolved.configured, Some(value as usize));
+            assert_eq!(resolved.effective, value as usize);
+        }
+        for value in [i64::MIN, -1, 0, 9, i64::MAX] {
+            let error = resolve_with_available(Some(value), 8).unwrap_err();
+            assert_eq!(error.maximum, 8);
+        }
+    }
+}

package/vendor/fastctx/src/search_text.rs

@@ -0,0 +1,227 @@
+//! Immutable UTF-8 search input shared by ripgrep callbacks and captured ranges.
+
+use crate::file_snapshot::{SnapshotByteRange, SnapshotReader};
+use crate::operation::{WorkCheckpoint, WorkStop};
+use std::fs::File;
+use std::io::{self, BufReader, Cursor, Read, Seek, SeekFrom, Write};
+use std::ops::Range;
+use std::sync::Arc;
+
+const MEMORY_TEXT_LIMIT: usize = 8 * 1024 * 1024;
+const TEXT_CHUNK_BYTES: usize = 64 * 1024;
+
+#[derive(Debug)]
+struct TempText {
+    file: tempfile::NamedTempFile,
+}
+
+impl TempText {
+    fn open_reader(&self) -> io::Result<TextReader<'static>> {
+        Ok(TextReader::Temp(BufReader::new(self.file.reopen()?)))
+    }
+
+    fn read_range(&self, range: Range<u64>) -> io::Result<Vec<u8>> {
+        let range_len = range.end.checked_sub(range.start).ok_or_else(|| {
+            io::Error::new(
+                io::ErrorKind::InvalidData,
+                "captured text range is reversed",
+            )
+        })?;
+        let length = usize::try_from(range_len).map_err(|_| {
+            io::Error::new(
+                io::ErrorKind::InvalidData,
+                "captured text range does not fit in memory",
+            )
+        })?;
+        let mut file = self.file.reopen()?;
+        file.seek(SeekFrom::Start(range.start))?;
+        let mut bytes = vec![0_u8; length];
+        file.read_exact(&mut bytes)?;
+        Ok(bytes)
+    }
+}
+
+#[derive(Debug)]
+enum TextStorage {
+    Snapshot(SnapshotByteRange),
+    Memory(Arc<[u8]>),
+    Temp(Arc<TempText>),
+}
+
+/// One immutable decoded UTF-8 source whose offsets are ripgrep's absolute offsets.
+#[derive(Debug)]
+pub(crate) struct SearchText {
+    len: u64,
+    storage: TextStorage,
+}
+
+impl SearchText {
+    /// Reuses a validated UTF-8 snapshot suffix without copying its memory or temp backing.
+    pub(crate) fn from_snapshot(range: SnapshotByteRange) -> Arc<Self> {
+        Arc::new(Self {
+            len: range.len(),
+            storage: TextStorage::Snapshot(range),
+        })
+    }
+
+    /// Captures a validated UTF-8 reader once, spilling above 8 MiB without an unbounded heap copy.
+    pub(crate) fn capture(
+        mut reader: impl Read,
+        operation: Option<&dyn WorkCheckpoint>,
+    ) -> Result<Arc<Self>, SearchTextFailure> {
+        let mut memory = Vec::with_capacity(MEMORY_TEXT_LIMIT.min(TEXT_CHUNK_BYTES));
+        let mut temp: Option<tempfile::NamedTempFile> = None;
+        let mut total = 0_u64;
+        let mut chunk = [0_u8; TEXT_CHUNK_BYTES];
+
+        loop {
+            check_operation(operation)?;
+            let read = reader.read(&mut chunk).map_err(SearchTextFailure::Io)?;
+            check_operation(operation)?;
+            if read == 0 {
+                break;
+            }
+            total = total.checked_add(read as u64).ok_or_else(|| {
+                SearchTextFailure::Io(io::Error::other("search text is too large"))
+            })?;
+
+            if temp.is_none() && memory.len().saturating_add(read) > MEMORY_TEXT_LIMIT {
+                let mut promoted = tempfile::NamedTempFile::new().map_err(SearchTextFailure::Io)?;
+                promoted.write_all(&memory).map_err(SearchTextFailure::Io)?;
+                memory.clear();
+                temp = Some(promoted);
+            }
+            if let Some(file) = &mut temp {
+                file.write_all(&chunk[..read])
+                    .map_err(SearchTextFailure::Io)?;
+            } else {
+                memory.extend_from_slice(&chunk[..read]);
+            }
+        }
+
+        check_operation(operation)?;
+        let storage = if let Some(mut file) = temp {
+            file.flush().map_err(SearchTextFailure::Io)?;
+            check_operation(operation)?;
+            TextStorage::Temp(Arc::new(TempText { file }))
+        } else {
+            TextStorage::Memory(Arc::from(memory))
+        };
+        Ok(Arc::new(Self {
+            len: total,
+            storage,
+        }))
+    }
+
+    pub(crate) fn memory_bytes(&self) -> Option<&[u8]> {
+        match &self.storage {
+            TextStorage::Snapshot(range) => range.memory_bytes(),
+            TextStorage::Memory(bytes) => Some(bytes),
+            TextStorage::Temp(_) => None,
+        }
+    }
+
+    pub(crate) fn open_reader(&self) -> io::Result<TextReader<'_>> {
+        match &self.storage {
+            TextStorage::Snapshot(range) => Ok(TextReader::Snapshot(range.open_reader()?)),
+            TextStorage::Memory(bytes) => Ok(TextReader::Memory(Cursor::new(bytes))),
+            TextStorage::Temp(temp) => temp.open_reader(),
+        }
+    }
+
+    pub(crate) fn range_str(&self, range: Range<u64>) -> io::Result<RangeText<'_>> {
+        self.validate_range(&range)?;
+        match &self.storage {
+            TextStorage::Snapshot(backing) => {
+                if let Some(bytes) = backing.memory_bytes() {
+                    let text = borrowed_utf8_range(bytes, range)?;
+                    Ok(RangeText::Borrowed(text))
+                } else {
+                    let bytes = backing.read_range(range)?;
+                    let text = String::from_utf8(bytes)
+                        .map_err(|error| invalid_utf8_range(error.utf8_error()))?;
+                    Ok(RangeText::Owned(Arc::from(text)))
+                }
+            }
+            TextStorage::Memory(bytes) => {
+                let text = borrowed_utf8_range(bytes, range)?;
+                Ok(RangeText::Borrowed(text))
+            }
+            TextStorage::Temp(temp) => {
+                let bytes = temp.read_range(range)?;
+                let text = String::from_utf8(bytes)
+                    .map_err(|error| invalid_utf8_range(error.utf8_error()))?;
+                Ok(RangeText::Owned(Arc::from(text)))
+            }
+        }
+    }
+
+    fn validate_range(&self, range: &Range<u64>) -> io::Result<()> {
+        if range.start <= range.end && range.end <= self.len {
+            Ok(())
+        } else {
+            Err(io::Error::new(
+                io::ErrorKind::InvalidData,
+                "ripgrep reported a byte range outside its immutable search input",
+            ))
+        }
+    }
+}
+
+fn borrowed_utf8_range(bytes: &[u8], range: Range<u64>) -> io::Result<&str> {
+    let start = usize::try_from(range.start).map_err(|_| text_range_error())?;
+    let end = usize::try_from(range.end).map_err(|_| text_range_error())?;
+    let bytes = bytes.get(start..end).ok_or_else(text_range_error)?;
+    std::str::from_utf8(bytes).map_err(invalid_utf8_range)
+}
+
+fn text_range_error() -> io::Error {
+    io::Error::new(
+        io::ErrorKind::InvalidData,
+        "captured text range lies outside its immutable search input",
+    )
+}
+
+fn invalid_utf8_range(error: std::str::Utf8Error) -> io::Error {
+    io::Error::new(
+        io::ErrorKind::InvalidData,
+        format!("ripgrep reported a range that is not valid UTF-8: {error}"),
+    )
+}
+
+fn check_operation(operation: Option<&dyn WorkCheckpoint>) -> Result<(), SearchTextFailure> {
+    match operation.map(WorkCheckpoint::check_work) {
+        Some(Err(stop)) => Err(SearchTextFailure::Stopped(stop)),
+        Some(Ok(())) | None => Ok(()),
+    }
+}
+
+/// A decoded text range, borrowed in memory and owned only when read from temp storage.
+#[derive(Debug)]
+pub(crate) enum RangeText<'a> {
+    Borrowed(&'a str),
+    Owned(Arc<str>),
+}
+
+/// A reader over the same immutable decoded UTF-8 backing.
+pub(crate) enum TextReader<'a> {
+    Snapshot(SnapshotReader<'a>),
+    Memory(Cursor<&'a [u8]>),
+    Temp(BufReader<File>),
+}
+
+impl Read for TextReader<'_> {
+    fn read(&mut self, output: &mut [u8]) -> io::Result<usize> {
+        match self {
+            Self::Snapshot(reader) => reader.read(output),
+            Self::Memory(reader) => reader.read(output),
+            Self::Temp(reader) => reader.read(output),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) enum SearchTextFailure {
+    Io(io::Error),
+    Stopped(WorkStop),
+}

package/vendor/fastctx/src/server.rs

@@ -0,0 +1,359 @@
+//! Unified rmcp registration, feature gating, and shared tool state.
+
+use crate::budget::{GLOB_TOKEN_BUDGET_ENV, GREP_TOKEN_BUDGET_ENV, READ_TOKEN_BUDGET_ENV};
+use crate::edit::ReplaceService;
+use crate::file_executor::GrepGlobExecutor;
+use crate::glob_tool::{GlobRequest, glob_files_cancellable};
+use crate::grep_tool::{GrepRequest, grep_files_cancellable};
+use crate::read_tool::{ReadRequest, read_file};
+use crate::server_manifest::{ToolContract, ToolManifest};
+use crate::server_support::{
+    BudgetRetry, CancellableBlockingRequest, run_blocking, run_blocking_cancellable,
+};
+use crate::session::SessionContext;
+use crate::shell::FastShell;
+use rmcp::handler::server::router::tool::ToolRouter;
+use rmcp::handler::server::wrapper::Parameters;
+use rmcp::model::{CallToolResult, Implementation, ServerCapabilities, ServerInfo};
+use rmcp::service::RequestContext;
+use rmcp::{RoleServer, ServerHandler, tool, tool_handler, tool_router};
+use std::sync::Arc;
+use tokio::sync::Semaphore;
+
+const MAX_FILE_OPERATIONS: usize = 8;
+const MAX_SHELL_OPERATIONS: usize = 16;
+const MAX_REPLACE_OPERATIONS: usize = 8;
+
+/// Optional tool groups published by the single `fastctx` server.
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
+pub struct ServerOptions {
+    /// Publish the five shell tools.
+    pub enable_shell: bool,
+}
+
+impl ServerOptions {
+    /// Enables all nine tools; intended for contract tests and doctor probes.
+    pub const fn all() -> Self {
+        Self { enable_shell: true }
+    }
+}
+
+/// The single stateful MCP server for default file tools and the optional shell group.
+#[derive(Clone, Debug)]
+pub struct FastCtxServer {
+    tool_router: ToolRouter<Self>,
+    options: ServerOptions,
+    pub(crate) shell: FastShell,
+    pub(crate) replace: ReplaceService,
+    pub(crate) file_permits: Arc<Semaphore>,
+    pub(crate) grep_glob_executor: Arc<GrepGlobExecutor>,
+    pub(crate) shell_permits: Arc<Semaphore>,
+    pub(crate) replace_permits: Arc<Semaphore>,
+    pub(crate) session: Arc<SessionContext>,
+    pub(crate) activity: Arc<crate::runtime::activity::RuntimeActivity>,
+}
+
+/// Expensive executors and process-wide admission gates shared by every control-center session.
+#[derive(Clone, Debug)]
+pub struct SharedRuntime {
+    file_permits: Arc<Semaphore>,
+    grep_glob_executor: Arc<GrepGlobExecutor>,
+    shell_permits: Arc<Semaphore>,
+    replace: ReplaceService,
+    replace_permits: Arc<Semaphore>,
+    activity: Arc<crate::runtime::activity::RuntimeActivity>,
+}
+
+impl SharedRuntime {
+    /// Creates one per-user runtime around the configured search executor.
+    pub(crate) fn new(grep_glob_executor: Arc<GrepGlobExecutor>) -> Arc<Self> {
+        Self::with_activity(
+            grep_glob_executor,
+            crate::runtime::activity::RuntimeActivity::new(),
+        )
+    }
+
+    pub(crate) fn with_activity(
+        grep_glob_executor: Arc<GrepGlobExecutor>,
+        activity: Arc<crate::runtime::activity::RuntimeActivity>,
+    ) -> Arc<Self> {
+        Arc::new(Self {
+            file_permits: Arc::new(Semaphore::new(MAX_FILE_OPERATIONS)),
+            grep_glob_executor,
+            shell_permits: Arc::new(Semaphore::new(MAX_SHELL_OPERATIONS)),
+            replace: ReplaceService::new(),
+            replace_permits: Arc::new(Semaphore::new(MAX_REPLACE_OPERATIONS)),
+            activity,
+        })
+    }
+}
+
+impl FastCtxServer {
+    /// Creates the default four-tool server, including byte-preserving replacement.
+    pub fn new() -> Self {
+        Self::with_options(ServerOptions::default())
+    }
+
+    /// Creates one server whose visible tools are selected by startup flags.
+    pub fn with_options(options: ServerOptions) -> Self {
+        Self::with_options_and_executor(options, GrepGlobExecutor::shared())
+    }
+
+    /// Creates a server with the process-startup search executor selected by current-user config.
+    pub(crate) fn with_options_and_executor(
+        options: ServerOptions,
+        grep_glob_executor: Arc<GrepGlobExecutor>,
+    ) -> Self {
+        Self::with_session_and_runtime(
+            options,
+            SessionContext::library_default(),
+            SharedRuntime::new(grep_glob_executor),
+        )
+    }
+
+    /// Creates one isolated MCP connection backed by a shared per-user runtime.
+    pub(crate) fn with_session_and_runtime(
+        options: ServerOptions,
+        session: Arc<SessionContext>,
+        runtime: Arc<SharedRuntime>,
+    ) -> Self {
+        let mut tool_router = Self::file_tool_router();
+        tool_router.merge(Self::shell_tool_router());
+        tool_router.merge(Self::edit_tool_router());
+        // rmcp's attribute accepts only a literal. Replace its inert placeholder before the router
+        // is observable so the positive route still has one production source.
+        tool_router
+            .map
+            .get_mut("inspect_local_file")
+            .expect("the compiled file router must contain inspect_local_file")
+            .attr
+            .description = Some(crate::model_guidance::inspect_tool_description().into());
+        for entry in ToolManifest::entries() {
+            if !entry.group.enabled(options.enable_shell) {
+                tool_router.remove_route(entry.name);
+            }
+        }
+        // Every consumer of a tool definition reads it back out of this router — the
+        // stdio `tools/list` answer, `tool_definitions`, and the contract hashes doctor
+        // compares across processes. Normalizing here keeps all of them on one shape;
+        // doing it in `tool_definitions` instead would make doctor compare a normalized
+        // expectation against an underived wire answer.
+        for route in tool_router.map.values_mut() {
+            route.attr.input_schema = Arc::new(crate::tool_schema::normalize_published_schema(
+                &route.attr.input_schema,
+            ));
+        }
+        let definitions = tool_router.list_all();
+        ToolManifest::validate(&definitions, options.enable_shell)
+            .expect("the compiled tool router must match ToolManifest");
+        Self {
+            tool_router,
+            options,
+            shell: FastShell::with_session(Arc::clone(&session)),
+            replace: runtime.replace.clone(),
+            file_permits: Arc::clone(&runtime.file_permits),
+            grep_glob_executor: Arc::clone(&runtime.grep_glob_executor),
+            shell_permits: Arc::clone(&runtime.shell_permits),
+            replace_permits: Arc::clone(&runtime.replace_permits),
+            activity: Arc::clone(&runtime.activity),
+            session,
+        }
+    }
+
+    /// Returns every definition exposed by MCP `tools/list` for tests and diagnostics.
+    pub fn tool_definitions(&self) -> Vec<rmcp::model::Tool> {
+        self.tool_router.list_all()
+    }
+
+    /// Returns stable contract hashes for every currently published tool.
+    pub fn tool_contracts(&self) -> Vec<ToolContract> {
+        ToolManifest::contracts(&self.tool_definitions())
+            .expect("validated server tools must have manifest entries")
+    }
+
+    /// Returns the startup feature selection used by this server.
+    pub const fn options(&self) -> ServerOptions {
+        self.options
+    }
+}
+
+impl Default for FastCtxServer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[tool_router(router = file_tool_router, vis = "pub(crate)")]
+impl FastCtxServer {
+    #[tool(
+        name = "inspect_local_file",
+        description = "Inspect local files.",
+        annotations(
+            title = "Inspect local file",
+            read_only_hint = true,
+            destructive_hint = false,
+            open_world_hint = false
+        )
+    )]
+    async fn inspect_local_file(
+        &self,
+        Parameters(request): Parameters<ReadRequest>,
+    ) -> CallToolResult {
+        let _activity = self.activity.request();
+        let status_shell = self.shell.clone();
+        run_blocking(
+            Arc::clone(&self.session),
+            Arc::clone(&self.file_permits),
+            READ_TOKEN_BUDGET_ENV,
+            move || status_shell.background_status(None),
+            BudgetRetry::Safe,
+            move || read_file(request.clone()),
+        )
+        .await
+    }
+
+    #[tool(
+        name = "grep",
+        description = "Fast regex content search (ripgrep engine; Rust regex, no lookaround). Output\nmodes: \"files_with_matches\" (default, paths only), \"content\", \"count\" (total\nmatches, not matching lines), \"summary\" (global totals). Respects .gitignore;\nsearches hidden files; skips .git and binaries. Files are decoded to UTF-8\nbefore searching; files whose encoding can't be determined, that change, or\nthat cannot be searched are skipped and listed for directory targets; the\nequivalent single-file failure returns an error. Matching is line-by-line:\n`^` and `$` anchor line boundaries and are CRLF-aware. A path component of the\nform ~fastctx~b...~ (reversible bytes/UTF-8) or ~fastctx~w...~ (Windows UTF-16)\nis a filename escape; copy that whole component verbatim in later calls and\ndo not decode or rewrite it. The last line of every successful result states\nComplete or Partial — continue only with the exact offset a Partial note\nprovides; errors are self-contained.",
+        annotations(
+            title = "Search file contents",
+            read_only_hint = true,
+            destructive_hint = false,
+            open_world_hint = false
+        )
+    )]
+    async fn grep(
+        &self,
+        Parameters(request): Parameters<GrepRequest>,
+        context: RequestContext<RoleServer>,
+    ) -> CallToolResult {
+        let _activity = self.activity.request();
+        run_blocking_cancellable(
+            CancellableBlockingRequest::new(
+                Arc::clone(&self.session),
+                context.id,
+                context.ct,
+                Arc::clone(&self.file_permits),
+                Arc::clone(&self.grep_glob_executor),
+                GREP_TOKEN_BUDGET_ENV,
+            ),
+            {
+                let shell = self.shell.clone();
+                move || shell.background_status(None)
+            },
+            move |operation, executor| grep_files_cancellable(operation, executor, request.clone()),
+        )
+        .await
+    }
+
+    #[tool(
+        name = "glob",
+        description = "Find files by glob pattern, e.g. \"**/*.rs\" or \"src/**/*.ts\". Matches files\nonly, never directories. Returns absolute paths sorted by path (or newest first\nwith sort=\"modified\"), 100 per page by default. filter_mode defaults to\n\"ignore\" (plain .ignore files only); \"all\" disables that filtering. Hidden\nfiles and .git are always visible unless a negative pattern excludes them.\noutput_mode defaults to \"paths\"; \"details\" returns compact JSON lines with\npath, byte size, and UTC modification time. Omit `path` entirely for the session\nworking directory — never pass \"null\" or \"undefined\". A path component of the\nform ~fastctx~b...~ (reversible bytes/UTF-8) or ~fastctx~w...~ (Windows UTF-16)\nis a filename escape; copy that whole component verbatim in later calls and do\nnot decode or rewrite it. The last line of every successful result states\nComplete or Partial — continue only with the exact offset a Partial note\nprovides; errors are self-contained.",
+        annotations(
+            title = "Match file paths",
+            read_only_hint = true,
+            destructive_hint = false,
+            open_world_hint = false
+        )
+    )]
+    async fn glob(
+        &self,
+        Parameters(request): Parameters<GlobRequest>,
+        context: RequestContext<RoleServer>,
+    ) -> CallToolResult {
+        let _activity = self.activity.request();
+        run_blocking_cancellable(
+            CancellableBlockingRequest::new(
+                Arc::clone(&self.session),
+                context.id,
+                context.ct,
+                Arc::clone(&self.file_permits),
+                Arc::clone(&self.grep_glob_executor),
+                GLOB_TOKEN_BUDGET_ENV,
+            ),
+            {
+                let shell = self.shell.clone();
+                move || shell.background_status(None)
+            },
+            move |operation, executor| glob_files_cancellable(operation, executor, request.clone()),
+        )
+        .await
+    }
+}
+
+#[tool_handler(router = self.tool_router)]
+impl ServerHandler for FastCtxServer {
+    fn get_info(&self) -> ServerInfo {
+        self.activity.touch();
+        ServerInfo::new(ServerCapabilities::builder().enable_tools().build())
+            .with_server_info(Implementation::new(
+                env!("CARGO_PKG_NAME"),
+                env!("CARGO_PKG_VERSION"),
+            ))
+            // 2026-07-24: hosts render these instructions as the tool namespace's one-line
+            // blurb and may keep only its first line and first 250 characters, so this text
+            // has to introduce the toolset within that budget. Behavioural rules belong in
+            // the host guidance file, which has no such limit.
+            .with_instructions(crate::model_guidance::server_instructions(
+                self.options.enable_shell,
+            ))
+    }
+
+    // The three `resources/*` methods stay on the rmcp defaults on purpose: both list methods
+    // answer with an empty list, and `resources/read` answers method-not-found. Overriding them
+    // to reject uniformly (added 0.2.2, reverted 2026-08-01) turned "this server has none" into a
+    // failure, and a failed call makes a model retry with a different `server` argument rather
+    // than switch tools — users reported chains of invented server names that the empty list
+    // never produced. Do not reintroduce an override without evidence from a released build.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{FastCtxServer, ServerOptions, SharedRuntime};
+    use crate::file_executor::GrepGlobExecutor;
+    use crate::search_parallelism::MAX_SEARCH_PARALLELISM;
+    use std::sync::Arc;
+
+    #[test]
+    fn configured_executor_is_the_server_search_source_for_serial_mid_and_maximum_p() {
+        let middle = (MAX_SEARCH_PARALLELISM / 2).max(1);
+        for parallelism in [1, middle, MAX_SEARCH_PARALLELISM] {
+            let executor = Arc::new(GrepGlobExecutor::with_test_parallelism(parallelism));
+            let server = FastCtxServer::with_options_and_executor(
+                ServerOptions::default(),
+                Arc::clone(&executor),
+            );
+            assert!(Arc::ptr_eq(&server.grep_glob_executor, &executor));
+            assert_eq!(server.grep_glob_executor.parallelism(), parallelism);
+            assert_eq!(server.grep_glob_executor.extra_capacity(), parallelism - 1);
+        }
+    }
+
+    #[test]
+    fn connections_share_runtime_resources_but_keep_distinct_session_contexts() {
+        let executor = Arc::new(GrepGlobExecutor::with_test_parallelism(1));
+        let runtime = SharedRuntime::new(Arc::clone(&executor));
+        let first = FastCtxServer::with_session_and_runtime(
+            ServerOptions::all(),
+            crate::session::SessionContext::library_default(),
+            Arc::clone(&runtime),
+        );
+        let second = FastCtxServer::with_session_and_runtime(
+            ServerOptions::all(),
+            crate::session::SessionContext::library_default(),
+            runtime,
+        );
+
+        assert!(Arc::ptr_eq(&first.grep_glob_executor, &executor));
+        assert!(Arc::ptr_eq(
+            &first.grep_glob_executor,
+            &second.grep_glob_executor
+        ));
+        assert!(Arc::ptr_eq(&first.file_permits, &second.file_permits));
+        assert!(Arc::ptr_eq(&first.shell_permits, &second.shell_permits));
+        assert!(Arc::ptr_eq(&first.replace_permits, &second.replace_permits));
+        assert!(first.replace.shares_locks_with(&second.replace));
+        assert!(Arc::ptr_eq(&first.activity, &second.activity));
+        assert!(!Arc::ptr_eq(&first.session, &second.session));
+    }
+}