In part I think the concern originating this post is that it is not clear enough how Darwin's Foundation and swift-corelibs-foundation are related and managed.
Phrases like the work on swift-corelibs-foundation and community feedback and API enhancements in cooperation with the community, could transmit that Foundation is in some degree an open-design project, as Swift is, but it is not. Design is closed and done in-house (taking external feedback, of course, but as all Apple frameworks) and the community is limited to re-implementing parts of Foundation supporting other platforms and sending feedback (it is not even clear where that feedback should go ā Apple Radar / Swift Bug Reporter / Forums ?).
I think it would be a lot clearer and better for the community and Apple if Foundation would be structured code-wise in two parts:
- The core which would be the Objective-C Foundation on Darwin and
swift-corelibs-foundation on other platforms. That part would remain be closed-design.
- A public open-design common Swift Foundation overlay where the community could really propose features and extend Foundation (Swift Evolution-like). Maybe other module?
Foundation+? 
There are a lot of Foundation features that are needed in the overall Swift ecosystem but are a very low priority for Apple, this could solve that tension.
Example
Take Process, it is a powerful tool in Foundation but it lacks really basic things like finding an executable by name in the PATH, checking the output and status of the execution or easily extracting the process output. For comparison:
On Python:
import subprocess
key_data = subprocess.check_output(["openssl", "genrsa", "2048"])
Current Swift (no joke; minimum equivalent cross-platform implementation):
import Foundation
#if os(Windows)
let pathSeparator: Character = ";"
let defaultExecutableExtensions = ["COM", "EXE", "BAT", "CMD"]
#else
let pathSeparator: Character = ":"
let defaultExecutableExtensions = [""]
#endif
var uppercasedEnvironment: [String : String] = [:]
for (key, value) in ProcessInfo.processInfo.environment {
uppercasedEnvironment[key.uppercased()] = value
}
var executableDirectories: [URL] = []
if let path = uppercasedEnvironment["PATH"] {
executableDirectories = path.split(separator: pathSeparator).map { URL(fileURLWithPath: String($0)) }
}
var executableExtensions = defaultExecutableExtensions
#if os(Windows)
if let pathExtensions = uppercasedEnvironment["PATHEXT"] {
executableExtensions = pathExtensions.split(separator: pathSeparator).map(String.init)
}
#endif
func getExecutableURL(name: String) -> URL? {
for executableDirectory in executableDirectories {
for executableExtension in executableExtensions {
let executableURL = executableDirectory
.appendingPathComponent(name)
.appendingPathExtension(executableExtension)
if FileManager.default.fileExists(at: executableURL) {
return executableURL
}
}
}
return nil
}
var executableURL = getExecutableURL(name: "openssl")!
let opensslProcess = Process()
opensslProcess.executableURL = executableURL
opensslProcess.arguments = ["genrsa", "2048"]
let outputPipe = Pipe()
opensslProcess.standardOutput = outputPipe
try opensslProcess.run()
try opensslProcess.waitUntilExit()
if opensslProcess.terminationStatus != 0 {
throw NSError(
domain: NSCocoaErrorDomain,code: Int(self.terminationStatus)),
userInfo: [NSLocalizedDescriptionKey: "Process terminated with failure (termination status code: \(self.terminationStatus))"])
}
let keyData = outputPipe.fileHandleForReading.readDataToEndOfFile()
Future Swift 
:
import Foundation
let opensslProcess = Process(executableName: "openssl", arguments: ["genrsa", "2048"])
let keyData = try opensslProcess.readOutput()
This hypothetical high-level Process features would be very useful in server-side Swift and when building CLI tools but understandably they are a very low-level priority for Apple.
Having this open-design part of Foundation would be an awesome scape-hatch for this types of features. And it would be the first part of Foundation to have a shared implementation between Darwin and other platforms.