ruvnet/RuView · error · Error

MCP specification rejected by ${kernel.resolvedBackend} kern

Error message

MCP specification rejected by ${kernel.resolvedBackend} kernel: ${kernel.mcpValidation}

What it means

RuntimeError raised by _validate_interface (rssi_collector.py:218) because is_available() found that /proc/net/wireless does not exist on this host. Linux exposes per-interface WiFi RSSI stats through that proc file; when the kernel has no wireless subsystem there is nothing to read, so the collector refuses to start. The message itself names the usual culprits: Docker, WSL, headless servers.

Source

Thrown at harness/homecore/src/mcp-server.js:146

        signal: context.signal,
        timeoutMs: TOOL_TIMEOUT_MS,
        onTimeout: () => context.controller?.abort(),
      });
      return result(id, {
        content: [{ type: 'text', text: JSON.stringify(output, null, 2) }],
        isError: output?.ok === false,
      });
    }
    default:
      if (id !== undefined) error(id, -32601, `Method not found: ${method}`);
      return undefined;
  }
}

export async function startMcpServer() {
  const kernel = await getKernelStatus();
  if (kernel.mcpValidation !== null) {
    throw new Error(`MCP specification rejected by ${kernel.resolvedBackend} kernel: ${kernel.mcpValidation}`);
  }
  const configuredRoot = process.env.HOMECORE_TRUSTED_REPO
    ? resolvePath(process.env.HOMECORE_TRUSTED_REPO)
    : findHomecoreRepo();
  const trustedRoot = configuredRoot
    ? assertTrustedHomecoreRepo(configuredRoot, { trustedRoot: configuredRoot })
    : null;
  log(`starting v${SERVER_INFO.version} (protocol ${PROTOCOL_VERSION}, kernel ${kernel.resolvedBackend}, ${listTools({ source: 'mcp' }).length} tools)`);

  let toolChain = Promise.resolve();
  let queuedToolCalls = 0;
  let acceptedToolCalls = 0;
  const cancelled = new Set();
  const queuedIds = new Set();
  const controllers = new Map();
  const dispatch = (message, extraContext = {}) => handle(message, {
    source: 'mcp',
    trustedRoot,

View on GitHub (pinned to 4685618388)

Solutions

Run the collector on a bare Linux host with a real wireless interface (e.g. wlan0 associated with an AP)
Guard construction with the provided non-raising probe before starting: available, reason = RSSICollector.is_available('wlan0'); only start when available
In Docker, run with --network host and ensure the host kernel exposes /proc/net/wireless (containers share the host kernel; if the host has WiFi, host networking plus /proc mounting makes it visible)
For tests/dev without hardware, feed recorded/synthetic RSSI data instead of the live collector

Example fix

# before
collector = RSSICollector(interface='wlan0')
collector.start()  # RuntimeError in Docker/WSL
# after
from src.sensing.rssi_collector import RSSICollector
available, reason = RSSICollector.is_available('wlan0')
if not available:
    logger.warning(f'RSSI collection unavailable: {reason}')
    # fall back to recorded data or skip
else:
    collector = RSSICollector(interface='wlan0')
    collector.start()

Defensive patterns

Strategy: validation

Validate before calling

from src.sensing.rssi_collector import RSSICollector

available, reason = RSSICollector.is_available("wlan0")
if not available:
    print(f"Skipping live RSSI collection: {reason}")
# only construct/start the collector when available is True

Type guard

import os

def host_has_wireless_proc() -> bool:
    """Narrow the environment: /proc/net/wireless must exist before the collector starts."""
    return os.path.exists("/proc/net/wireless")

Try / catch

try:
    collector = RSSICollector(interface="wlan0")
    collector.start()
except RuntimeError as e:
    if "/proc/net/wireless not found" in str(e):
        # environment lacks a wireless subsystem -> use recorded data
        feed = RecordedRSSIStream("captures/session1.rssi")
    else:
        raise

Prevention

Call is_available() at startup and degrade gracefully instead of crashing
Run collection on the bare Linux host, not inside Docker/WSL
In CI, mock the collector or replay recorded RSSI captures
Name the exact interface that appears in /proc/net/wireless (verify with cat /proc/net/wireless)

When it happens

Trigger: Constructing/starting the RSSICollector (which calls _validate_interface) inside a Docker container, WSL1/WSL2 VM, or a VM/server whose kernel lacks cfg80211/wireless extensions; a headless CI runner; a machine whose only NIC is Ethernet (file absent when there is no wireless interface at all).

Common situations: Developing the WiFi-DensePose pipeline on a laptop inside Docker instead of the bare host; CI running unit/integration tests that instantiate the real collector; deploying to a cloud VM with no WiFi hardware; WSL2 where /proc is the VM's, not Windows'.

Related errors

AI-assisted analysis of ruvnet/RuView@4685618388 (2026-08-16). Data as JSON: /api/errors/d0f1f718709613d9. Report an issue: GitHub.