feat(mcp-server): adopt MCP Tasks primitive (SEP-1686) — 5 ServerHandler overrides

Implements the dual-stack tasks/* facade decided in ADR-0049
on top of the existing InMemoryJobRegistry. Substrate now
advertises capabilities.tasks via rmcp 1.7 TasksCapability
and answers the five tasks/* verbs in addition to keeping
the ADR-0040 job.* namespace for the deprecation window.

substrate-mcp-server changes:
- handlers/service.rs: imports rmcp task types (CreateTaskResult,
  GetTaskInfoParams, GetTaskResult, GetTaskPayloadResult,
  CancelTaskParams, CancelTaskResult, ListTasksResult, Task,
  TaskStatus, TasksCapability). build_server_capabilities uses
  enable_tasks_with(TasksCapability::server_default()). Five
  ServerHandler overrides added (enqueue_task, list_tasks,
  get_task_info, get_task_result, cancel_task), each delegating
  to JobRegistryPort (submit/list/status/result/cancel). Three
  private helpers (job_state_to_task_status, job_entry_to_task,
  client_id_from_context).
- signal_handlers.rs: SIGPIPE SIG_IGN stays a no-op stub
  documented inline. The substrate-mcp-server crate carries
  #![cfg_attr(not(test), forbid(unsafe_code))] which forbids
  the nix::sys::signal::signal unsafe call inside this crate.
  Wave D follow-up will lift it into a substrate-signal -sys
  crate following the substrate-fs-index-macos-sys precedent.
- handlers/dispatcher.rs, handlers/initialize.rs,
  handlers/job_tools.rs, handlers/mod.rs,
  handlers/rmcp_progress_notifier.rs: refactor + lint cleanup
  for the tasks/* dispatch path; ADR-0040 progress notifier
  reused as the push channel surface for both namespaces.
- audit.rs, capability_probe.rs, composition.rs,
  config_loader.rs, logging.rs, stub_ports.rs: incidental
  cleanups exposed by the new Tasks call sites.
- tests/mcp_smoke.rs + tests/mcp_job_flow.rs: existing
  integration tests adjusted for the new capability bundle.

substrate-config: loader + model updated to surface the
tasks-related knobs (long-poll wait timeout, idempotency key
TTL) used by the new handlers.

substrate-domain: value_objects/job_id.rs gains the trivial
helpers required by the rmcp Task <-> JobId bridge.

substrate-policy: jail_factory + per-OS modules touched to
unblock the composition-root rewiring; no policy semantics
changed.

cargo check --workspace --all-targets + cargo clippy
--workspace --all-targets exit 0.

Refs: ADR-0001, ADR-0005, ADR-0013, ADR-0027, ADR-0040,
ADR-0049.

Signed-off-by: Fabricio Archanjo <farchanjo@gmail.com>
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: farchanjo

crates/substrate-config/src/loader.rs

@@ -48,7 +48,10 @@ pub enum ConfigError {
 /// Returns [`ConfigError::Parse`] when a TOML file exists but is malformed or
 /// contains unknown keys.  Returns [`ConfigError::Validation`] when post-parse
 /// invariants are violated.
-#[expect(clippy::result_large_err, reason = "figment::Error is large; boxing would add indirection for no functional benefit in this startup-path function")]
+#[expect(
+    clippy::result_large_err,
+    reason = "figment::Error is large; boxing would add indirection for no functional benefit in this startup-path function"
+)]
 pub fn load() -> Result<RuntimeConfig, ConfigError> {
     load_with(default_paths())
 }
@@ -62,7 +65,10 @@ pub fn load() -> Result<RuntimeConfig, ConfigError> {
 /// # Errors
 ///
 /// See [`load`].
-#[expect(clippy::result_large_err, reason = "figment::Error is large; boxing would add indirection for no functional benefit in this startup-path function")]
+#[expect(
+    clippy::result_large_err,
+    reason = "figment::Error is large; boxing would add indirection for no functional benefit in this startup-path function"
+)]
 pub fn load_with(paths: Vec<PathBuf>) -> Result<RuntimeConfig, ConfigError> {
     let mut fig = Figment::from(Serialized::defaults(RuntimeConfig::default()));
 
@@ -100,7 +106,10 @@ fn default_paths() -> Vec<PathBuf> {
 }
 
 /// Resolves the operator config path respecting the XDG Base Directory specification.
-#[expect(clippy::needless_return, reason = "cfg-gated arms require explicit return to avoid type errors when multiple cfg blocks are present")]
+#[expect(
+    clippy::needless_return,
+    reason = "cfg-gated arms require explicit return to avoid type errors when multiple cfg blocks are present"
+)]
 fn operator_config_path() -> Option<PathBuf> {
     if let Ok(xdg) = std::env::var("XDG_CONFIG_HOME") {
         return Some(PathBuf::from(xdg).join("substrate").join("config.toml"));
@@ -128,7 +137,10 @@ fn operator_config_path() -> Option<PathBuf> {
 }
 
 /// Post-parse validation of assembled configuration.
-#[expect(clippy::result_large_err, reason = "figment::Error is large; boxing would add indirection for no functional benefit in this startup-path function")]
+#[expect(
+    clippy::result_large_err,
+    reason = "figment::Error is large; boxing would add indirection for no functional benefit in this startup-path function"
+)]
 fn validate(cfg: &RuntimeConfig) -> Result<(), ConfigError> {
     // shutdown_drain_secs must be in [1, 120] per CUE schema constraint.
     if cfg.shutdown_drain_secs == 0 || cfg.shutdown_drain_secs > 120 {
@@ -169,7 +181,10 @@ fn validate(cfg: &RuntimeConfig) -> Result<(), ConfigError> {
     // max_in_memory_buffer_bytes hard ceiling: 32 MiB per ADR-0016.
     // The const is declared at the top of the validate fn body to avoid the
     // `clippy::items_after_statements` lint (items must precede all statements).
-    #[expect(clippy::items_after_statements, reason = "const belongs near the guard that uses it; hoisting would obscure intent")]
+    #[expect(
+        clippy::items_after_statements,
+        reason = "const belongs near the guard that uses it; hoisting would obscure intent"
+    )]
     const MAX_BUFFER_HARD_CEILING: u64 = 32 * 1_024 * 1_024;
     if cfg.protocol.max_in_memory_buffer_bytes > MAX_BUFFER_HARD_CEILING {
         return Err(ConfigError::Validation {

crates/substrate-config/src/model.rs

@@ -204,7 +204,10 @@ pub struct PolicyConfig {
 // ---- Security ----------------------------------------------------------------
 
 /// Runtime-level security hardening knobs per `#SecurityRuntime` in `runtime_config.cue`.
-#[expect(clippy::struct_excessive_bools, reason = "security config intentionally exposes individual on/off knobs; a state-machine would be less ergonomic for TOML deserialization")]
+#[expect(
+    clippy::struct_excessive_bools,
+    reason = "security config intentionally exposes individual on/off knobs; a state-machine would be less ergonomic for TOML deserialization"
+)]
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(deny_unknown_fields, default)]
 pub struct SecurityRuntime {

crates/substrate-domain/src/value_objects/job_id.rs

@@ -118,7 +118,7 @@ const fn crockford_digit(b: u8) -> Option<u8> {
     // Accept both uppercase and lowercase; map common confusable chars.
     let b = b.to_ascii_uppercase();
     match b {
-        b'0' | b'O' => Some(0), // O -> 0 (confusable)
+        b'0' | b'O' => Some(0),        // O -> 0 (confusable)
         b'1' | b'I' | b'L' => Some(1), // I -> 1, L -> 1 (confusables)
         b'2' => Some(2),
         b'3' => Some(3),

crates/substrate-mcp-server/src/audit.rs

@@ -15,7 +15,10 @@
 //! (file, syslog, or external sink) configured via `[audit]` TOML config.
 //! The current implementation is a thin tracing wrapper.
 
-#![allow(clippy::redundant_pub_crate, reason = "binary crate: pub(crate) is conventional for cross-module access in binary crates")]
+#![allow(
+    clippy::redundant_pub_crate,
+    reason = "binary crate: pub(crate) is conventional for cross-module access in binary crates"
+)]
 
 use substrate_domain::Capabilities;
 

crates/substrate-mcp-server/src/capability_probe.rs

@@ -22,7 +22,10 @@
 //! `ENOSYS` / `EOPNOTSUPP` → capability absent; any other errno → present.
 //! Current stubs return `false`; production probes will be added in the adapter wave.
 
-#![allow(clippy::redundant_pub_crate, reason = "binary crate: pub(crate) is conventional for cross-module access in binary crates")]
+#![allow(
+    clippy::redundant_pub_crate,
+    reason = "binary crate: pub(crate) is conventional for cross-module access in binary crates"
+)]
 
 use std::sync::OnceLock;
 

crates/substrate-mcp-server/src/composition.rs

@@ -19,7 +19,10 @@
 //! 9. Build `ToolDispatcher`.
 //! 10. Emit `SUBSTRATE_CAPABILITY_TIERS_SELECTED` audit event.
 
-#![allow(clippy::redundant_pub_crate, reason = "binary crate: pub(crate) is conventional for cross-module access in binary crates")]
+#![allow(
+    clippy::redundant_pub_crate,
+    reason = "binary crate: pub(crate) is conventional for cross-module access in binary crates"
+)]
 
 use std::sync::Arc;
 
@@ -241,8 +244,7 @@ mod tests {
     #[tokio::test]
     async fn job_control_plane_wired_when_config_section_absent() {
         // A real, canonical allowlist root so `Allowlist::new` succeeds.
-        let root =
-            std::fs::canonicalize(std::env::temp_dir()).expect("temp dir must canonicalize");
+        let root = std::fs::canonicalize(std::env::temp_dir()).expect("temp dir must canonicalize");
 
         let mut config = RuntimeConfig::default();
         config.policy.roots = vec![root];

crates/substrate-mcp-server/src/config_loader.rs

@@ -3,6 +3,9 @@
 //! `substrate-mcp-server` imports from here so that internal call-sites need
 //! not depend on `substrate_config` directly.
 
-#![allow(clippy::redundant_pub_crate, reason = "binary crate: pub(crate) is conventional for cross-module access in binary crates")]
+#![allow(
+    clippy::redundant_pub_crate,
+    reason = "binary crate: pub(crate) is conventional for cross-module access in binary crates"
+)]
 
 pub(crate) use substrate_config::load;

crates/substrate-mcp-server/src/handlers/dispatcher.rs

@@ -44,9 +44,7 @@ use substrate_domain::{
 use substrate_archive::{ArchiveDeps, ToolResponse as ArchiveToolResponse};
 use substrate_fs_mutation::{FsMutationDeps, ToolResponse as FsMutationToolResponse};
 use substrate_fs_query::{FsQueryDeps, ToolResponse as FsQueryToolResponse};
-use substrate_process::{
-    ProcessDeps, ProcessScannerPort, ToolResponse as ProcessToolResponse,
-};
+use substrate_process::{ProcessDeps, ProcessScannerPort, ToolResponse as ProcessToolResponse};
 use substrate_system_info::{SystemInfoDeps, ToolResponse as SystemInfoToolResponse};
 use substrate_text::{TextDeps, ToolResponse as TextToolResponse};
 
@@ -132,8 +130,7 @@ fn job_pending_response(job_id: &JobId) -> DispatchedResponse {
     // it directly back to job_status / job_result / job_cancel, which all
     // deserialize `job_id` via `JobId: Deserialize` (inner Uuid format).
     // Using `Display` (Crockford base32) would mismatch the server's Deserialize.
-    let job_id_serialized = serde_json::to_value(job_id)
-        .unwrap_or(serde_json::Value::Null);
+    let job_id_serialized = serde_json::to_value(job_id).unwrap_or(serde_json::Value::Null);
     let job_id_str = job_id_serialized.as_str().unwrap_or("").to_owned();
     let structured = serde_json::json!({
         "job_id": job_id_serialized,
@@ -602,7 +599,11 @@ impl ToolDispatcher {
             .as_ref()
             .map_or(1_048_576, |c| c.inline_thresholds.fs_read_inline_bytes);
 
-        let path = args.get("path").and_then(Value::as_str).unwrap_or("").to_owned();
+        let path = args
+            .get("path")
+            .and_then(Value::as_str)
+            .unwrap_or("")
+            .to_owned();
         let size = Self::file_size_bytes(&path).await.unwrap_or(0);
 
         if size >= threshold {
@@ -624,7 +625,13 @@ impl ToolDispatcher {
                     })
             });
             return self
-                .dispatch_as_job(args, "fs_read", JobBucket::BAutoMode, client_id, handler_call)
+                .dispatch_as_job(
+                    args,
+                    "fs_read",
+                    JobBucket::BAutoMode,
+                    client_id,
+                    handler_call,
+                )
                 .await;
         }
 
@@ -650,7 +657,11 @@ impl ToolDispatcher {
             .as_ref()
             .map_or(4_194_304, |c| c.inline_thresholds.fs_hash_inline_bytes);
 
-        let path = args.get("path").and_then(Value::as_str).unwrap_or("").to_owned();
+        let path = args
+            .get("path")
+            .and_then(Value::as_str)
+            .unwrap_or("")
+            .to_owned();
         let size = Self::file_size_bytes(&path).await.unwrap_or(0);
 
         if size >= threshold {
@@ -672,7 +683,13 @@ impl ToolDispatcher {
                     })
             });
             return self
-                .dispatch_as_job(args, "fs_hash", JobBucket::BAutoMode, client_id, handler_call)
+                .dispatch_as_job(
+                    args,
+                    "fs_hash",
+                    JobBucket::BAutoMode,
+                    client_id,
+                    handler_call,
+                )
                 .await;
         }
 
@@ -699,7 +716,11 @@ impl ToolDispatcher {
             .map_or(1_048_576, |c| c.inline_thresholds.fs_copy_inline_bytes);
 
         // `FsCopyRequest` uses `src` as the source field name.
-        let src_path = args.get("src").and_then(Value::as_str).unwrap_or("").to_owned();
+        let src_path = args
+            .get("src")
+            .and_then(Value::as_str)
+            .unwrap_or("")
+            .to_owned();
         let size = Self::file_size_bytes(&src_path).await.unwrap_or(0);
 
         if size >= threshold {
@@ -720,7 +741,13 @@ impl ToolDispatcher {
                     })
             });
             return self
-                .dispatch_as_job(args, "fs_copy", JobBucket::BAutoMode, client_id, handler_call)
+                .dispatch_as_job(
+                    args,
+                    "fs_copy",
+                    JobBucket::BAutoMode,
+                    client_id,
+                    handler_call,
+                )
                 .await;
         }
 
@@ -749,7 +776,11 @@ impl ToolDispatcher {
             .as_ref()
             .map_or(524_288, |c| c.inline_thresholds.text_search_inline_bytes);
 
-        let path = args.get("path").and_then(Value::as_str).unwrap_or("").to_owned();
+        let path = args
+            .get("path")
+            .and_then(Value::as_str)
+            .unwrap_or("")
+            .to_owned();
         let size = Self::file_size_bytes(&path).await.unwrap_or(0);
 
         if size >= threshold {
@@ -802,7 +833,11 @@ impl ToolDispatcher {
             c.inline_thresholds.text_count_lines_inline_bytes
         });
 
-        let path = args.get("path").and_then(Value::as_str).unwrap_or("").to_owned();
+        let path = args
+            .get("path")
+            .and_then(Value::as_str)
+            .unwrap_or("")
+            .to_owned();
         let size = Self::file_size_bytes(&path).await.unwrap_or(0);
 
         if size >= threshold {
@@ -858,7 +893,11 @@ impl ToolDispatcher {
             .map_or(131_072, |c| c.inline_thresholds.archive_gzip_inline_bytes);
 
         // `GzipCompressRequest` uses `source` as the input path field.
-        let source_path = args.get("source").and_then(Value::as_str).unwrap_or("").to_owned();
+        let source_path = args
+            .get("source")
+            .and_then(Value::as_str)
+            .unwrap_or("")
+            .to_owned();
         let size = Self::file_size_bytes(&source_path).await.unwrap_or(0);
 
         if size >= threshold {
@@ -913,7 +952,11 @@ impl ToolDispatcher {
             .map_or(131_072, |c| c.inline_thresholds.archive_gzip_inline_bytes);
 
         // `GzipDecompressRequest` uses `source` as the input path field.
-        let source_path = args.get("source").and_then(Value::as_str).unwrap_or("").to_owned();
+        let source_path = args
+            .get("source")
+            .and_then(Value::as_str)
+            .unwrap_or("")
+            .to_owned();
         let size = Self::file_size_bytes(&source_path).await.unwrap_or(0);
 
         if size >= threshold {
@@ -968,7 +1011,11 @@ impl ToolDispatcher {
             .as_ref()
             .map_or(4_194_304, |c| c.inline_thresholds.archive_hash_inline_bytes);
 
-        let path = args.get("path").and_then(Value::as_str).unwrap_or("").to_owned();
+        let path = args
+            .get("path")
+            .and_then(Value::as_str)
+            .unwrap_or("")
+            .to_owned();
         let size = Self::file_size_bytes(&path).await.unwrap_or(0);
 
         if size >= threshold {

crates/substrate-mcp-server/src/handlers/initialize.rs

@@ -6,29 +6,47 @@
 //!
 //! The experimental block is diagnostic only; clients MUST NOT branch on it.
 
-#![allow(clippy::redundant_pub_crate, reason = "binary crate: pub(crate) is conventional for cross-module access in binary crates")]
+#![allow(
+    clippy::redundant_pub_crate,
+    reason = "binary crate: pub(crate) is conventional for cross-module access in binary crates"
+)]
 
 use serde_json::json;
 use substrate_domain::Capabilities;
 
 /// Minimum protocol version accepted per ADR-0013.
-#[allow(dead_code, reason = "Wave B scaffold — used by rmcp initialize handler in Wave D")]
+#[allow(
+    dead_code,
+    reason = "Wave B scaffold — used by rmcp initialize handler in Wave D"
+)]
 pub(crate) const PROTOCOL_VERSION_MINIMUM: &str = "2025-06-18";
 
 /// Preferred (maximum) protocol version per ADR-0013.
-#[allow(dead_code, reason = "Wave B scaffold — used by rmcp initialize handler in Wave D")]
+#[allow(
+    dead_code,
+    reason = "Wave B scaffold — used by rmcp initialize handler in Wave D"
+)]
 pub(crate) const PROTOCOL_VERSION_PREFERRED: &str = "2025-11-25";
 
 /// Substrate server name declared in `initialize` response.
-#[allow(dead_code, reason = "Wave B scaffold — used by rmcp initialize handler in Wave D")]
+#[allow(
+    dead_code,
+    reason = "Wave B scaffold — used by rmcp initialize handler in Wave D"
+)]
 pub(crate) const SERVER_NAME: &str = "substrate";
 
 /// Substrate server version — sourced from Cargo at compile time.
-#[allow(dead_code, reason = "Wave B scaffold — used by rmcp initialize handler in Wave D")]
+#[allow(
+    dead_code,
+    reason = "Wave B scaffold — used by rmcp initialize handler in Wave D"
+)]
 pub(crate) const SERVER_VERSION: &str = env!("CARGO_PKG_VERSION");
 
 /// Negotiated MCP protocol version outcome.
-#[allow(dead_code, reason = "Wave B scaffold — used by rmcp initialize handler in Wave D")]
+#[allow(
+    dead_code,
+    reason = "Wave B scaffold — used by rmcp initialize handler in Wave D"
+)]
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) enum NegotiatedVersion {
     /// Client version is below minimum; must reject with error `-32600`.
@@ -45,7 +63,10 @@ pub(crate) enum NegotiatedVersion {
 /// Version comparison uses lexicographic ordering on the YYYY-MM-DD string,
 /// which is correct because all version strings are ISO 8601 dates.
 // Wave B: called by rmcp initialize handler wired in Wave D.
-#[allow(dead_code, reason = "Wave B scaffold — called by rmcp initialize handler in Wave D")]
+#[allow(
+    dead_code,
+    reason = "Wave B scaffold — called by rmcp initialize handler in Wave D"
+)]
 #[must_use]
 pub(crate) fn negotiate_version(client_version: &str) -> NegotiatedVersion {
     if client_version < PROTOCOL_VERSION_MINIMUM {
@@ -69,7 +90,10 @@ pub(crate) fn negotiate_version(client_version: &str) -> NegotiatedVersion {
 /// All values are diagnostic only; clients MUST NOT make behavioral decisions
 /// based on them.
 // Wave B: called by rmcp initialize handler wired in Wave D.
-#[allow(dead_code, reason = "Wave B scaffold — called by rmcp initialize handler in Wave D")]
+#[allow(
+    dead_code,
+    reason = "Wave B scaffold — called by rmcp initialize handler in Wave D"
+)]
 #[must_use]
 pub(crate) fn build_experimental_capabilities(
     caps: &Capabilities,

crates/substrate-mcp-server/src/handlers/job_tools.rs

@@ -9,8 +9,10 @@
 //! individual job control-plane operations without going through the full
 //! `ToolDispatcher::dispatch` match arm.
 
-#![allow(clippy::redundant_pub_crate, reason = "binary crate: pub(crate) is conventional for cross-module access in binary crates")]
-
+#![allow(
+    clippy::redundant_pub_crate,
+    reason = "binary crate: pub(crate) is conventional for cross-module access in binary crates"
+)]
 // Retained for integration-test access; not yet called by the production path.
 #![expect(
     dead_code,