F4-F7: operator quality, survivor actionability, Apple support matrix, release-gate hardening

Summary of what changed since the last publish (private/main e497c7f ..
c7eba5d):

- F4: core operator quality (expanded default/experimental operator
  coverage, schemata lowerers for the newer operators, compile-viability
  fixes).
- F5 + F5.1: survivor actionability reporting -- clustering, coverage-aware
  reason codes (mutationSiteNotCovered / coveredButNotCaught), a
  code-review-driven hardening pass (deterministic tiebreaking, per-cluster
  evidence, corrected coverage semantics).
- F6: Apple platform support matrix, documented honestly including what
  remains real-simulator-unverified (tvOS/watchOS/visionOS).
- F7: feature freeze and full release gate -- T2 (unit/regression) and a
  real-simulator acceptance suite, both green; a release-artifact gate
  verifying the actual packaged tarball end-to-end; a paired before/after
  benchmark harness. Two real product bugs found and fixed along the way:
  WorkspaceManager.cloneProducts breaking on a symlinked products directory
  (SwiftPM's own .build/debug), and HostResourcePreflight hanging past its
  own timeout under concurrent process load (now routed through
  ProcessSupervisor like every other production process spawn).
- Public package hygiene: trimmed research/probe-only executable targets
  out of the public projection via the overlay mechanism.
- A behavior-preserving decomposition of MutationRunner into
  MutationConfirmationCoordinator and MutationEvidenceAssembler.
- A new `mutantkit trust` command and a small Trust Corpus of regression
  fixtures pinning correctness properties (cross-file cache invalidation,
  schemata neutral-path equivalence) that were previously undertested.
- A standalone (not yet wired into execution) mutant-conflict-graph
  component researched as a future safe-batching mechanism, with an
  adversarially-reviewed design document naming its own real, unresolved
  correctness risks rather than glossing over them.
- CodeQL: scan all four languages GitHub's own code-scanning detection
  finds for this repo (actions, c-cpp, python, swift), not just swift --
  the previous single-language config is what surfaced as a code-scanning
  configuration error.

Author: juntaki

.github/workflows/action-smoke-test.yml

@@ -6,14 +6,28 @@ name: CodeQL
 # every PR like ci.yml, plus a weekly schedule so newly-disclosed query-pack
 # findings surface even on a week with no code changes.
 #
+# Four languages, not one: GitHub's own code-scanning default-setup
+# auto-detection (repos/.../code-scanning/default-setup) reports this repo
+# as containing actions, c-cpp, python, and swift — scanning only swift, as
+# an earlier version of this workflow did, left the other three undetected,
+# which is what a "code scanning configuration error" surfaces as (the
+# advanced setup this workflow represents not covering everything GitHub's
+# own detection found). c-cpp is Sources/MutantKitSchemataRuntimeC (a real,
+# plain-C target the SwiftPM package builds); python is Scripts/
+# compare-wave-reports.py; actions is this directory's own workflow YAML.
+#
 # `build-mode: manual` rather than `autobuild`: this is a multi-target
 # SwiftPM package with a plain-C target (MutantKitSchemataRuntimeC) wrapped
 # in a product with an explicit `type: .static`, not a single generic
 # executable — exactly the shape autobuild's build-system heuristics are
 # least reliable on. A manual `swift build` step (the same invocation
 # ci.yml's `unit` job already trusts to build the whole package, including
 # the C target) is both simpler to reason about and guaranteed to match how
-# this package actually builds.
+# this package actually builds. `build-mode` only governs the two compiled
+# languages (swift, c-cpp) — one `swift build` invocation traces both, since
+# the C target compiles as part of the same package build. python and
+# actions are interpreted/config languages CodeQL scans directly with no
+# build step, unaffected by build-mode.
 #
 # macos-15, matching ci.yml/release.yml: this needs the real Xcode/Swift
 # toolchain, not a Linux runner — CodeQL's Swift extractor only runs on
@@ -39,42 +53,22 @@ concurrency:
 
 jobs:
   analyze:
-    name: Analyze (swift)
+    name: Analyze
     runs-on: macos-15
     steps:
       - uses: actions/checkout@v4
 
-      # Same rationale as ci.yml's identical step: SwiftPM independently
-      # re-clones swift-argument-parser/swift-syntax/Yams and re-runs version
-      # resolution on every run today, with zero caching -- this is the same
-      # cost class, not a CodeQL-specific restriction (CodeQL's own build
-      # tracing has no documented issue with pre-populated dependency
-      # checkouts; it only observes the compiler invocations `swift build`
-      # below actually makes).
-      - name: Cache SwiftPM dependencies
-        uses: actions/cache@v4
-        with:
-          path: |
-            .build/checkouts
-            .build/repositories
-            ~/Library/Caches/org.swift.swiftpm
-          key: ${{ runner.os }}-spm-${{ hashFiles('Package.resolved') }}
-          restore-keys: |
-            ${{ runner.os }}-spm-
-
       - name: Toolchain
         run: swift --version && xcodebuild -version
 
       - name: Initialize CodeQL
         uses: github/codeql-action/init@v4
         with:
-          languages: swift
+          languages: actions, c-cpp, python, swift
           build-mode: manual
 
       - name: Build
         run: swift build
 
       - name: Perform CodeQL analysis
         uses: github/codeql-action/analyze@v4
-        with:
-          category: "/language:swift"

.github/workflows/ci.yml

@@ -0,0 +1,19 @@
+// swift-tools-version:6.0
+import PackageDescription
+
+// Schemata supported-matrix fixture: SwiftPM macOS with ONE test target
+// containing both an XCTestCase class and a Swift Testing @Suite —
+// deliberately mixed, not two separate test targets, since the question
+// this fixture answers is whether schemata mode's own test-result parsing
+// (a single .xctest bundle report) handles both frameworks' results
+// correctly when they coexist in the same bundle. See
+// Fixtures/SchemataMatrixXCTest/Package.swift's own comment for why this
+// fixture is fully covered rather than deliberately partial.
+let package = Package(
+    name: "MatrixWidget",
+    platforms: [.macOS(.v14)],
+    targets: [
+        .target(name: "MatrixWidget"),
+        .testTarget(name: "MatrixWidgetTests", dependencies: ["MatrixWidget"])
+    ]
+)

.github/workflows/codeql.yml

@@ -0,0 +1,35 @@
+/// One candidate per default-enabled, schemata-eligible operator — see
+/// this fixture's own Package.swift comment. Every function here is
+/// exercised by a dedicated test that kills every mutant a schemata run
+/// could produce from it.
+public enum MatrixWidget {
+    /// bool-literal-inversion candidate.
+    public static func isFeatureEnabled() -> Bool {
+        true
+    }
+
+    /// relational-operator-replacement candidate.
+    public static func isAdult(age: Int) -> Bool {
+        age >= 18
+    }
+
+    /// logical-connector-replacement candidate.
+    public static func bothRequired(a: Bool, b: Bool) -> Bool {
+        a && b
+    }
+
+    /// unary-not-removal candidate.
+    public static func isInvalid(flag: Bool) -> Bool {
+        !flag
+    }
+
+    /// return-value-replacement candidate.
+    public static func greeting() -> String {
+        "hello"
+    }
+
+    /// ternary-branch-swap candidate.
+    public static func label(flag: Bool) -> String {
+        flag ? "yes" : "no"
+    }
+}

.swiftlint-baseline.json

@@ -0,0 +1,24 @@
+import Testing
+import MatrixWidget
+
+/// Other half of the coverage — see MatrixWidgetXCTestTests.swift's own
+/// doc comment.
+@Suite("MatrixWidget (Swift Testing half)")
+struct MatrixWidgetSwiftTestingTests {
+    @Test
+    func isInvalid() {
+        #expect(MatrixWidget.isInvalid(flag: false))
+        #expect(!MatrixWidget.isInvalid(flag: true))
+    }
+
+    @Test
+    func greeting() {
+        #expect(MatrixWidget.greeting() == "hello")
+    }
+
+    @Test
+    func label() {
+        #expect(MatrixWidget.label(flag: true) == "yes")
+        #expect(MatrixWidget.label(flag: false) == "no")
+    }
+}

Fixtures/SchemataMatrixMixed/Package.swift

@@ -0,0 +1,24 @@
+import XCTest
+import MatrixWidget
+
+/// Half the coverage lives here (XCTest), half in
+/// MatrixWidgetSwiftTestingTests.swift (Swift Testing) — same test bundle,
+/// both frameworks, deliberately.
+final class MatrixWidgetXCTestTests: XCTestCase {
+    func testIsFeatureEnabled() {
+        XCTAssertTrue(MatrixWidget.isFeatureEnabled())
+    }
+
+    func testIsAdultBoundary() {
+        XCTAssertFalse(MatrixWidget.isAdult(age: 17))
+        XCTAssertTrue(MatrixWidget.isAdult(age: 18))
+        XCTAssertTrue(MatrixWidget.isAdult(age: 19))
+    }
+
+    func testBothRequired() {
+        XCTAssertTrue(MatrixWidget.bothRequired(a: true, b: true))
+        XCTAssertFalse(MatrixWidget.bothRequired(a: true, b: false))
+        XCTAssertFalse(MatrixWidget.bothRequired(a: false, b: true))
+        XCTAssertFalse(MatrixWidget.bothRequired(a: false, b: false))
+    }
+}

Fixtures/SchemataMatrixMixed/Sources/MatrixWidget/MatrixWidget.swift

@@ -0,0 +1,15 @@
+// swift-tools-version:6.0
+import PackageDescription
+
+// Schemata supported-matrix fixture: SwiftPM macOS + Swift Testing. See
+// Fixtures/SchemataMatrixXCTest/Package.swift's own comment for why this
+// fixture is fully covered (zero uncovered candidates) rather than
+// deliberately partial like Fixtures/SchemataSwiftPackageMacOS.
+let package = Package(
+    name: "MatrixWidget",
+    platforms: [.macOS(.v14)],
+    targets: [
+        .target(name: "MatrixWidget"),
+        .testTarget(name: "MatrixWidgetTests", dependencies: ["MatrixWidget"])
+    ]
+)

Fixtures/SchemataMatrixMixed/Tests/MatrixWidgetTests/MatrixWidgetSwiftTestingTests.swift

@@ -0,0 +1,35 @@
+/// One candidate per default-enabled, schemata-eligible operator — see
+/// this fixture's own Package.swift comment. Every function here is
+/// exercised by a dedicated test that kills every mutant a schemata run
+/// could produce from it.
+public enum MatrixWidget {
+    /// bool-literal-inversion candidate.
+    public static func isFeatureEnabled() -> Bool {
+        true
+    }
+
+    /// relational-operator-replacement candidate.
+    public static func isAdult(age: Int) -> Bool {
+        age >= 18
+    }
+
+    /// logical-connector-replacement candidate.
+    public static func bothRequired(a: Bool, b: Bool) -> Bool {
+        a && b
+    }
+
+    /// unary-not-removal candidate.
+    public static func isInvalid(flag: Bool) -> Bool {
+        !flag
+    }
+
+    /// return-value-replacement candidate.
+    public static func greeting() -> String {
+        "hello"
+    }
+
+    /// ternary-branch-swap candidate.
+    public static func label(flag: Bool) -> String {
+        flag ? "yes" : "no"
+    }
+}