chore(api): remove unused backend endpoints after MCP audit

Remove legacy backend routes that no longer have frontend or internal
callers, including the old Claude/Codex MCP APIs, unused Cursor and Codex
helper endpoints, stale TaskMaster detection/next/initialize routes,
and unused command/project helpers.

This reduces duplicated MCP behavior now handled by the provider-based
MCP API, shrinks the exposed backend surface, and removes probe/service
code that only existed for deleted endpoints.

Add an MCP settings API audit document to capture the route-usage
analysis and explain why the legacy MCP endpoints were considered safe
to remove.

server/modules/providers/shared/mcp/mcp.provider.ts

@@ -1,8 +1,5 @@
-import { once } from 'node:events';
 import path from 'node:path';
 
-import spawn from 'cross-spawn';
-
 import type { IProviderMcp } from '@/shared/interfaces.js';
 import type { LLMProvider, McpScope, McpTransport, ProviderMcpServer, UpsertProviderMcpServerInput } from '@/shared/types.js';
 import { AppError } from '@/shared/utils.js';
@@ -22,74 +19,6 @@ const normalizeServerName = (name: string): string => {
   return normalized;
 };
 
-const runStdioServerProbe = async (
-  server: ProviderMcpServer,
-  workspacePath: string,
-): Promise<{ reachable: boolean; error?: string }> => {
-  if (!server.command) {
-    return { reachable: false, error: 'Missing stdio command.' };
-  }
-
-  try {
-    const child = spawn(server.command, server.args ?? [], {
-      cwd: server.cwd ? path.resolve(workspacePath, server.cwd) : workspacePath,
-      env: {
-        ...process.env,
-        ...(server.env ?? {}),
-      },
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-
-    const timeout = setTimeout(() => {
-      if (!child.killed && child.exitCode === null) {
-        child.kill('SIGTERM');
-      }
-    }, 1_500);
-
-    const errorPromise = once(child, 'error').then(([error]) => {
-      throw error;
-    });
-    const closePromise = once(child, 'close');
-    await Promise.race([closePromise, errorPromise]);
-    clearTimeout(timeout);
-
-    if (typeof child.exitCode === 'number' && child.exitCode !== 0) {
-      return {
-        reachable: false,
-        error: `Process exited with code ${child.exitCode}.`,
-      };
-    }
-
-    return { reachable: true };
-  } catch (error) {
-    return {
-      reachable: false,
-      error: error instanceof Error ? error.message : 'Failed to start stdio process',
-    };
-  }
-};
-
-const runHttpServerProbe = async (
-  url: string,
-): Promise<{ reachable: boolean; statusCode?: number; error?: string }> => {
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), 3_000);
-  try {
-    const response = await fetch(url, { method: 'GET', signal: controller.signal });
-    clearTimeout(timeout);
-    return {
-      reachable: true,
-      statusCode: response.status,
-    };
-  } catch (error) {
-    clearTimeout(timeout);
-    return {
-      reachable: false,
-      error: error instanceof Error ? error.message : 'Network probe failed',
-    };
-  }
-};
-
 /**
  * Shared MCP provider for provider-specific config readers/writers.
  */
@@ -182,63 +111,6 @@ export abstract class McpProvider implements IProviderMcp {
     return { removed, provider: this.provider, name: normalizedName, scope };
   }
 
-  async runServer(
-    input: { name: string; scope?: McpScope; workspacePath?: string },
-  ): Promise<{
-    provider: LLMProvider;
-    name: string;
-    scope: McpScope;
-    transport: McpTransport;
-    reachable: boolean;
-    statusCode?: number;
-    error?: string;
-  }> {
-    const scope = input.scope ?? 'project';
-    this.assertScope(scope);
-
-    const workspacePath = resolveWorkspacePath(input.workspacePath);
-    const normalizedName = normalizeServerName(input.name);
-    const scopedServers = await this.readScopedServers(scope, workspacePath);
-    const rawConfig = scopedServers[normalizedName];
-    if (!rawConfig || typeof rawConfig !== 'object') {
-      throw new AppError(`MCP server "${normalizedName}" was not found.`, {
-        code: 'MCP_SERVER_NOT_FOUND',
-        statusCode: 404,
-      });
-    }
-
-    const normalized = this.normalizeServerConfig(scope, normalizedName, rawConfig);
-    if (!normalized) {
-      throw new AppError(`MCP server "${normalizedName}" has an invalid configuration.`, {
-        code: 'MCP_SERVER_INVALID_CONFIG',
-        statusCode: 400,
-      });
-    }
-
-    if (normalized.transport === 'stdio') {
-      const result = await runStdioServerProbe(normalized, workspacePath);
-      return {
-        provider: this.provider,
-        name: normalizedName,
-        scope,
-        transport: normalized.transport,
-        reachable: result.reachable,
-        error: result.error,
-      };
-    }
-
-    const result = await runHttpServerProbe(normalized.url ?? '');
-    return {
-      provider: this.provider,
-      name: normalizedName,
-      scope,
-      transport: normalized.transport,
-      reachable: result.reachable,
-      statusCode: result.statusCode,
-      error: result.error,
-    };
-  }
-
   protected abstract readScopedServers(
     scope: McpScope,
     workspacePath: string,