pumuki 6.3.306 → 6.3.308

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [6.3.308] - 2026-05-20
+
+- `R_GO`: PRE_WRITE deja de exigir `skills.ios.critical-test-quality` cuando no hay cambios efectivos de test iOS en el scope actual aunque la evidencia previa arrastre `platforms.ios`. Evita el bloqueo falso `EVIDENCE_PLATFORM_CRITICAL_SKILLS_RULES_MISSING` sobre `.ai_evidence.json` en repos limpios/no-code.
+- iOS AST skills: añadidos detectores nodales con lineas y metadata accionable para `clean architecture layer direction`, `third-party UI test framework` y `excessive public API`.
+- Canary multi-plataforma: endurecido para exigir bloqueo real, diagnostico `violations-detected`, rule id esperado/equivalente y finding asociado al archivo canario.
+
 ## [6.3.301] - 2026-05-19
 
 - `PUMUKI-INC-157`: PRE_WRITE no longer hard-blocks when evidence reports `ai_gate.status=BLOCKED` but exposes no real blocking causes and only non-blocking WARN signals such as worktree hygiene warnings. Explicit AST/skills findings with `blocking=true` still block, even when their inherited severity is WARN.

package/core/facts/detectors/text/ios.test.ts

@@ -12,6 +12,7 @@ import {
   collectSwiftMakeSUTWithoutMemoryTrackingLines,
   collectSwiftMixedTestingFrameworkLines,
   collectSwiftQuickNimbleLines,
+  collectSwiftThirdPartyUiTestFrameworkLines,
   collectSwiftWaitForExpectationsLines,
   collectSwiftXCTestAssertionLines,
   collectSwiftXCTUnwrapLines,
@@ -20,6 +21,7 @@ import {
   collectSwiftCallbackStyleSignatureLines,
   collectSwiftDispatchGroupLines,
   collectSwiftDispatchSemaphoreLines,
+  collectSwiftDummyAwaitLines,
   hasSwiftAnyViewUsage,
   hasSwiftAnyTypeErasureUsage,
   hasSwiftAsyncWithoutAwaitUsage,
@@ -29,7 +31,9 @@ import {
   hasSwiftDispatchGroupUsage,
   collectSwiftDispatchQueueLines,
   hasSwiftDispatchQueueUsage,
+  hasSwiftDummyAwaitUsage,
   hasSwiftDispatchSemaphoreUsage,
+  collectSwiftLongAsyncOperationWithoutCancellationCheckLines,
   hasSwiftAdHocLoggingUsage,
   hasSwiftAlamofireUsage,
   collectSwiftComposableArchitectureUsageLines,
@@ -40,8 +44,20 @@ import {
   hasSwiftPackageBranchDependencyUsage,
   collectSwiftPackageToolsVersionBelow62Lines,
   hasSwiftPackageToolsVersionBelow62Usage,
+  collectSwiftPackageDefaultIsolationNotMainActorLines,
+  hasSwiftPackageDefaultIsolationNotMainActorUsage,
+  collectSwiftPackageStrictConcurrencyBelowCompleteLines,
+  hasSwiftPackageStrictConcurrencyBelowCompleteUsage,
+  collectSwiftCrossFeatureImportLines,
+  hasSwiftCrossFeatureImportUsage,
+  collectSwiftExcessivePublicApiLines,
+  hasSwiftExcessivePublicApiUsage,
+  collectSwiftLayerDirectionViolationLines,
+  hasSwiftLayerDirectionViolationUsage,
   collectSwiftStrictConcurrencyBelowCompleteLines,
   hasSwiftStrictConcurrencyBelowCompleteUsage,
+  collectSwiftDefaultActorIsolationNotMainActorLines,
+  hasSwiftDefaultActorIsolationNotMainActorUsage,
   hasSwiftForEachIndicesUsage,
   hasSwiftForEachSelfIdentityUsage,
   collectSwiftForceCastLines,
@@ -70,6 +86,8 @@ import {
   collectSwiftAnimationWithoutReduceMotionLines,
   collectSwiftUiInlineActionLogicLines,
   collectSwiftOnTapGestureWithoutButtonTraitLines,
+  collectSwiftGlassInteractiveOnStaticElementLines,
+  collectSwiftGlassEffectIDWithoutNamespaceLines,
   collectSwiftForEachIndicesLines,
   collectSwiftForEachSelfIdentityLines,
   collectSwiftInlineForEachTransformLines,
@@ -86,6 +104,7 @@ import {
   collectSwiftEnvironmentObjectLines,
   hasSwiftEnvironmentObjectUsage,
   hasSwiftLowContrastStaticColorPairUsage,
+  hasSwiftLongAsyncOperationWithoutCancellationCheckUsage,
   hasSwiftMainThreadBlockingSleepUsage,
   hasSwiftDirectSUTInstantiationWithoutMakeSUTUsage,
   hasSwiftMakeSUTWithoutMemoryTrackingUsage,
@@ -125,6 +144,8 @@ import {
   collectSwiftOnAppearTaskLines,
   hasSwiftOnTapGestureUsage,
   hasSwiftOnTapGestureWithoutButtonTraitUsage,
+  hasSwiftGlassInteractiveOnStaticElementUsage,
+  hasSwiftGlassEffectIDWithoutNamespaceUsage,
   hasSwiftOperationQueueUsage,
   hasSwiftContainsUserFilterUsage,
   hasSwiftCustomSingletonUsage,
@@ -132,8 +153,11 @@ import {
   hasSwiftPhysicalTextAlignmentUsage,
   hasSwiftPreconcurrencyUsage,
   hasSwiftProductionCommentUsage,
+  collectSwiftThreadCentricDebuggingLines,
+  hasSwiftThreadCentricDebuggingUsage,
   hasSwiftProductionTestDoubleUsage,
   hasSwiftQuickNimbleUsage,
+  hasSwiftThirdPartyUiTestFrameworkUsage,
   hasSwiftTestDoubleWithoutProtocolConformanceUsage,
   hasSwiftSheetIsPresentedUsage,
   hasSwiftScrollViewShowsIndicatorsUsage,
@@ -164,6 +188,8 @@ import {
   hasSwiftManualMemoryManagementUsage,
   collectSwiftNonPascalCaseTypeDeclarationLines,
   hasSwiftNonPascalCaseTypeDeclarationUsage,
+  collectSwiftEndpointEnumLines,
+  hasSwiftEndpointEnumUsage,
   collectSwiftCellCreationWithoutReuseLines,
   hasSwiftCellCreationWithoutReuseUsage,
   hasSwiftWaitForExpectationsUsage,
@@ -256,6 +282,46 @@ let ignored = "[unowned self]"
   assert.equal(hasSwiftUnownedSelfCaptureUsage(safe), false);
 });
 
+test('hasSwiftLongAsyncOperationWithoutCancellationCheckUsage detecta bucles async sin cancelacion cooperativa', () => {
+  const source = `
+final class SyncService {
+  func syncAll(items: [Item]) async throws {
+    for item in items {
+      try await upload(item)
+    }
+  }
+
+  func poll() async {
+    while true {
+      await refresh()
+    }
+  }
+}
+`;
+  const safe = `
+final class SyncService {
+  func syncAll(items: [Item]) async throws {
+    for item in items {
+      if Task.isCancelled { return }
+      try await upload(item)
+    }
+  }
+
+  func poll() async throws {
+    while isRunning {
+      try Task.checkCancellation()
+      await refresh()
+    }
+  }
+}
+`;
+
+  assert.equal(hasSwiftLongAsyncOperationWithoutCancellationCheckUsage(source), true);
+  assert.deepEqual(collectSwiftLongAsyncOperationWithoutCancellationCheckLines(source), [4, 10]);
+  assert.equal(hasSwiftLongAsyncOperationWithoutCancellationCheckUsage(safe), false);
+  assert.deepEqual(collectSwiftLongAsyncOperationWithoutCancellationCheckLines(safe), []);
+});
+
 test('hasSwiftManualMemoryManagementUsage detecta bypass manual de ARC', () => {
   const source = `
 final class LegacyBridge {
@@ -307,6 +373,36 @@ let sample = "struct user_profile {}"
   assert.deepEqual(collectSwiftNonPascalCaseTypeDeclarationLines(safe), []);
 });
 
+test('hasSwiftEndpointEnumUsage detecta endpoints iOS como enum central no OCP', () => {
+  const source = `
+enum APIEndpoint {
+  case login
+}
+
+enum OrdersEndpoint: String {
+  case list = "/orders"
+}
+`;
+  const safe = `
+struct APIEndpoint: Sendable {
+  let path: String
+  let method: HTTPMethod
+
+  static func login() -> APIEndpoint {
+    APIEndpoint(path: "/login", method: .post)
+  }
+}
+
+let sample = "enum APIEndpoint { case login }"
+// enum OrdersEndpoint { case list }
+`;
+
+  assert.equal(hasSwiftEndpointEnumUsage(source), true);
+  assert.deepEqual(collectSwiftEndpointEnumLines(source), [2, 6]);
+  assert.equal(hasSwiftEndpointEnumUsage(safe), false);
+  assert.deepEqual(collectSwiftEndpointEnumLines(safe), []);
+});
+
 test('hasSwiftCellCreationWithoutReuseUsage detecta celdas UIKit sin reutilizacion', () => {
   const source = `
 final class OrdersDataSource: NSObject, UITableViewDataSource {
@@ -596,6 +692,198 @@ buildSettings = {
   assert.deepEqual(collectSwiftStrictConcurrencyBelowCompleteLines(safe), []);
 });
 
+test('detectores SwiftPM de concurrencia detectan aislamiento y strict concurrency inseguros', () => {
+  const source = `
+let package = Package(
+  name: "App",
+  swiftSettings: [
+    .defaultIsolation(nonisolated),
+    .enableExperimentalFeature("StrictConcurrency=targeted"),
+    .enableUpcomingFeature("StrictConcurrency=minimal")
+  ]
+)
+`;
+  const safe = `
+let package = Package(
+  name: "App",
+  swiftSettings: [
+    .defaultIsolation(MainActor.self),
+    .enableUpcomingFeature("NonisolatedNonsendingByDefault")
+  ]
+)
+let sample = ".defaultIsolation(nonisolated)"
+// .enableExperimentalFeature("StrictConcurrency=targeted")
+`;
+
+  assert.equal(hasSwiftPackageDefaultIsolationNotMainActorUsage(source), true);
+  assert.deepEqual(collectSwiftPackageDefaultIsolationNotMainActorLines(source), [5]);
+  assert.equal(hasSwiftPackageStrictConcurrencyBelowCompleteUsage(source), true);
+  assert.deepEqual(collectSwiftPackageStrictConcurrencyBelowCompleteLines(source), [6, 7]);
+  assert.equal(hasSwiftPackageDefaultIsolationNotMainActorUsage(safe), false);
+  assert.deepEqual(collectSwiftPackageDefaultIsolationNotMainActorLines(safe), []);
+  assert.equal(hasSwiftPackageStrictConcurrencyBelowCompleteUsage(safe), false);
+  assert.deepEqual(collectSwiftPackageStrictConcurrencyBelowCompleteLines(safe), []);
+});
+
+test('hasSwiftCrossFeatureImportUsage detecta imports entre bounded contexts iOS', () => {
+  const source = `
+import SwiftUI
+import SharedKernel
+import Orders
+import BuyerCommerce
+`;
+  const path = 'apps/ios/Presentation/Features/BuyerCommerce/LoginView.swift';
+  const safe = `
+import SwiftUI
+import SharedKernel
+import BuyerCommerce
+// import Orders
+let sample = "import Orders"
+`;
+
+  assert.equal(hasSwiftCrossFeatureImportUsage(source, path), true);
+  assert.deepEqual(collectSwiftCrossFeatureImportLines(source, path), [4]);
+  assert.equal(hasSwiftCrossFeatureImportUsage(safe, path), false);
+  assert.deepEqual(collectSwiftCrossFeatureImportLines(safe, path), []);
+  assert.equal(hasSwiftCrossFeatureImportUsage(source, 'apps/ios/Presentation/LoginView.swift'), false);
+});
+
+test('hasSwiftLayerDirectionViolationUsage detecta imports prohibidos por capa Clean Architecture', () => {
+  const domainSource = `
+import Foundation
+import SwiftUI
+import CoreData
+import CheckoutApplication
+import Combine
+`;
+  const applicationSource = `
+import Foundation
+import UIKit
+import Alamofire
+import AuthInfrastructure
+`;
+  const presentationSource = `
+import SwiftUI
+import CoreData
+import DesignSystem
+import AuthInfrastructure
+`;
+  const safeDomain = `
+import Foundation
+import SharedKernel
+`;
+
+  assert.equal(
+    hasSwiftLayerDirectionViolationUsage(
+      domainSource,
+      'apps/ios/Features/Orders/Domain/Entities/Order.swift'
+    ),
+    true
+  );
+  assert.deepEqual(
+    collectSwiftLayerDirectionViolationLines(
+      domainSource,
+      'apps/ios/Features/Orders/Domain/Entities/Order.swift'
+    ),
+    [3, 4, 5, 6]
+  );
+  assert.deepEqual(
+    collectSwiftLayerDirectionViolationLines(
+      applicationSource,
+      'apps/ios/Features/Orders/Application/UseCases/LoadOrders.swift'
+    ),
+    [3, 4, 5]
+  );
+  assert.deepEqual(
+    collectSwiftLayerDirectionViolationLines(
+      presentationSource,
+      'apps/ios/Features/Orders/Presentation/OrdersView.swift'
+    ),
+    [3, 5]
+  );
+  assert.equal(
+    hasSwiftLayerDirectionViolationUsage(
+      safeDomain,
+      'apps/ios/Features/Orders/Domain/Entities/Order.swift'
+    ),
+    false
+  );
+});
+
+test('hasSwiftExcessivePublicApiUsage detecta public/open excesivo en app iOS', () => {
+  const appSource = `
+import SwiftUI
+
+public final class BuyerShellViewModel {
+  public var selectedTab: Tab = .home
+  public init() {}
+  public func openCheckout() {}
+}
+`;
+  const minimalPublicSource = `
+public struct CheckoutRoute {}
+internal struct CheckoutState {}
+private struct CheckoutReducer {}
+`;
+  const packageSource = `
+public struct PublicSDKSurface {}
+public func makeClient() {}
+public let version = "1"
+`;
+
+  assert.equal(
+    hasSwiftExcessivePublicApiUsage(
+      appSource,
+      'apps/ios/Presentation/Features/BuyerCommerce/BuyerShellViewModel.swift'
+    ),
+    true
+  );
+  assert.deepEqual(
+    collectSwiftExcessivePublicApiLines(
+      appSource,
+      'apps/ios/Presentation/Features/BuyerCommerce/BuyerShellViewModel.swift'
+    ),
+    [4, 5, 6, 7]
+  );
+  assert.equal(
+    hasSwiftExcessivePublicApiUsage(
+      minimalPublicSource,
+      'apps/ios/Presentation/Features/BuyerCommerce/CheckoutRoute.swift'
+    ),
+    false
+  );
+  assert.deepEqual(
+    collectSwiftExcessivePublicApiLines(
+      packageSource,
+      'apps/ios/Sources/PublicSDK/PublicSDK.swift'
+    ),
+    []
+  );
+});
+
+test('hasSwiftDefaultActorIsolationNotMainActorUsage detecta aislamiento por defecto distinto de MainActor', () => {
+  const source = `
+buildSettings = {
+  SWIFT_DEFAULT_ACTOR_ISOLATION = nonisolated;
+  OTHER_SWIFT_FLAGS = "$(inherited)";
+  SWIFT_DEFAULT_ACTOR_ISOLATION = SomeCustomActor;
+};
+`;
+  const safe = `
+buildSettings = {
+  SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor;
+  SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor.self;
+  let sample = "SWIFT_DEFAULT_ACTOR_ISOLATION = nonisolated;"
+  // SWIFT_DEFAULT_ACTOR_ISOLATION = SomeCustomActor;
+};
+`;
+
+  assert.equal(hasSwiftDefaultActorIsolationNotMainActorUsage(source), true);
+  assert.deepEqual(collectSwiftDefaultActorIsolationNotMainActorLines(source), [3, 5]);
+  assert.equal(hasSwiftDefaultActorIsolationNotMainActorUsage(safe), false);
+  assert.deepEqual(collectSwiftDefaultActorIsolationNotMainActorLines(safe), []);
+});
+
 test('hasSwiftNonLazyScrollForEachUsage detecta ScrollView con stack no lazy y preserva LazyVStack', () => {
   const source = `
 struct FeedView: View {
@@ -1733,6 +2021,30 @@ func wait() async throws {
   assert.equal(hasSwiftMainThreadBlockingSleepUsage(ignored), false);
 });
 
+test('detector iOS de concurrencia detecta depuracion centrada en hilos', () => {
+  const source = `
+func traceCurrentExecution() {
+  print(Thread.current)
+  if Thread.isMainThread { recordMainThread() }
+  let pthread = pthread_self()
+  let mach = pthread_mach_thread_np(pthread)
+}
+`;
+  const ignored = `
+@MainActor
+func updateUI() {
+  let description = "Thread.current"
+  // Thread.isMainThread
+  Task { await reload() }
+}
+`;
+
+  assert.equal(hasSwiftThreadCentricDebuggingUsage(source), true);
+  assert.deepEqual(collectSwiftThreadCentricDebuggingLines(source), [3, 4, 5, 6]);
+  assert.equal(hasSwiftThreadCentricDebuggingUsage(ignored), false);
+  assert.deepEqual(collectSwiftThreadCentricDebuggingLines(ignored), []);
+});
+
 test('detector iOS de concurrencia detecta async privado sin await y evita boundaries publicos', () => {
   const source = `
 final class ProfileLoader {
@@ -1761,6 +2073,33 @@ final class ProfileLoader: RemoteLoader {
   assert.equal(hasSwiftAsyncWithoutAwaitUsage(ignored), false);
 });
 
+test('detector iOS de concurrencia detecta dummy awaits usados como workaround', () => {
+  const source = `
+final class Loader {
+  func load() async {
+    await Task.yield()
+    try? await Task.sleep(nanoseconds: 0)
+    try? await Task.sleep(for: .zero)
+    try? await Task.sleep(for: .seconds(0))
+  }
+}
+`;
+  const ignored = `
+final class Loader {
+  func load() async throws {
+    try await Task.sleep(for: .seconds(1))
+    let message = "await Task.yield()"
+    // await Task.yield()
+  }
+}
+`;
+
+  assert.equal(hasSwiftDummyAwaitUsage(source), true);
+  assert.deepEqual(collectSwiftDummyAwaitLines(source), [4, 5, 6, 7]);
+  assert.equal(hasSwiftDummyAwaitUsage(ignored), false);
+  assert.deepEqual(collectSwiftDummyAwaitLines(ignored), []);
+});
+
 test('detector iOS de accesibilidad detecta botones icon-only sin label explicita', () => {
   const source = `
 struct ToolbarView: View {
@@ -2005,6 +2344,81 @@ struct RowView: View {
   assert.deepEqual(collectSwiftOnTapGestureWithoutButtonTraitLines(safe), []);
 });
 
+test('hasSwiftGlassInteractiveOnStaticElementUsage detecta Liquid Glass interactivo en contenido estatico', () => {
+  const source = `
+struct CardView: View {
+  var body: some View {
+    Text("Estado")
+      .padding()
+      .glassEffect(.regular.interactive(), in: .rect(cornerRadius: 16))
+  }
+}
+`;
+  const safe = `
+struct CardView: View {
+  var body: some View {
+    Button("Continuar") { submit() }
+      .glassEffect(.regular.interactive(), in: .capsule)
+
+    Text("Mas informacion")
+      .onTapGesture { showDetails() }
+      .glassEffect(.regular.interactive(), in: .rect(cornerRadius: 16))
+
+    Text("decorativo")
+      .glassEffect(.regular, in: .rect(cornerRadius: 16))
+
+    let sample = ".glassEffect(.regular.interactive())"
+    // .glassEffect(.regular.interactive())
+  }
+}
+`;
+
+  assert.equal(hasSwiftGlassInteractiveOnStaticElementUsage(source), true);
+  assert.deepEqual(collectSwiftGlassInteractiveOnStaticElementLines(source), [6]);
+  assert.equal(hasSwiftGlassInteractiveOnStaticElementUsage(safe), false);
+  assert.deepEqual(collectSwiftGlassInteractiveOnStaticElementLines(safe), []);
+});
+
+test('hasSwiftGlassEffectIDWithoutNamespaceUsage detecta glassEffectID sin Namespace real', () => {
+  const source = `
+struct CardView: View {
+  var body: some View {
+    Text("Card")
+      .glassEffect()
+      .glassEffectID("card", in: animation)
+  }
+}
+`;
+  const safe = `
+struct CardView: View {
+  @Namespace private var animation
+
+  var body: some View {
+    Text("Card")
+      .glassEffect()
+      .glassEffectID("card", in: animation)
+  }
+}
+
+struct ChildCard: View {
+  let animation: Namespace.ID
+
+  var body: some View {
+    Text("Card")
+      .glassEffectID("card", in: animation)
+  }
+}
+
+let sample = ".glassEffectID(\\"card\\", in: animation)"
+// .glassEffectID("card", in: animation)
+`;
+
+  assert.equal(hasSwiftGlassEffectIDWithoutNamespaceUsage(source), true);
+  assert.deepEqual(collectSwiftGlassEffectIDWithoutNamespaceLines(source), [6]);
+  assert.equal(hasSwiftGlassEffectIDWithoutNamespaceUsage(safe), false);
+  assert.deepEqual(collectSwiftGlassEffectIDWithoutNamespaceLines(safe), []);
+});
+
 test('detectores legacy ignoran strings y comentarios', () => {
   const source = `
 // Task.detached { }
@@ -2779,6 +3193,51 @@ struct LoginTests {
   assert.deepEqual(collectSwiftQuickNimbleLines(swiftTesting), []);
 });
 
+test('hasSwiftThirdPartyUiTestFrameworkUsage detecta frameworks UI test no nativos', () => {
+  const kifSuite = `
+import XCTest
+import KIF
+
+final class CheckoutUITests: XCTestCase {
+  func testCheckout() {
+    tester().tapView(withAccessibilityLabel: "Pay")
+  }
+}
+`;
+  const earlGreySuite = `
+import XCTest
+import EarlGrey
+
+final class LoginUITests: XCTestCase {
+  func testLogin() {
+    EarlGrey.selectElement(with: grey_accessibilityID("login")).perform(grey_tap())
+  }
+}
+`;
+  const nativeXcuiTest = `
+import XCTest
+
+final class LoginUITests: XCTestCase {
+  func testLogin() {
+    let app = XCUIApplication()
+    app.buttons["login"].tap()
+  }
+}
+`;
+  const ignored = `
+let text = "import KIF"
+// EarlGrey.selectElement(with: grey_accessibilityID("login"))
+`;
+
+  assert.equal(hasSwiftThirdPartyUiTestFrameworkUsage(kifSuite), true);
+  assert.deepEqual(collectSwiftThirdPartyUiTestFrameworkLines(kifSuite), [3, 7]);
+  assert.equal(hasSwiftThirdPartyUiTestFrameworkUsage(earlGreySuite), true);
+  assert.deepEqual(collectSwiftThirdPartyUiTestFrameworkLines(earlGreySuite), [3, 7]);
+  assert.equal(hasSwiftThirdPartyUiTestFrameworkUsage(nativeXcuiTest), false);
+  assert.deepEqual(collectSwiftThirdPartyUiTestFrameworkLines(nativeXcuiTest), []);
+  assert.equal(hasSwiftThirdPartyUiTestFrameworkUsage(ignored), false);
+});
+
 test('hasSwiftXCTestAssertionUsage detecta XCTAssert y XCTFail reales', () => {
   const source = `
 XCTAssertEqual(value, expected)
@@ -2795,6 +3254,24 @@ let text = "XCTAssertEqual(value, expected)"
   assert.deepEqual(collectSwiftXCTestAssertionLines(ignored), []);
 });
 
+test('hasSwiftXCTestAssertionUsage permite UI tests XCTest brownfield explicitos', () => {
+  const uiTest = `
+import XCTest
+
+final class BuyerCommerceUISmokeTests: XCTestCase {
+  func testCheckoutFlow() {
+    let app = XCUIApplication()
+    app.launch()
+    XCTAssertTrue(app.buttons["Continue"].exists)
+    XCTAssertEqual(app.staticTexts["Title"].label, "RuralGo")
+  }
+}
+`;
+
+  assert.equal(hasSwiftXCTestAssertionUsage(uiTest), false);
+  assert.deepEqual(collectSwiftXCTestAssertionLines(uiTest), []);
+});
+
 test('hasSwiftXCTUnwrapUsage detecta XCTUnwrap real y evita strings', () => {
   const source = `
 let value = try XCTUnwrap(optionalValue)
@@ -2832,6 +3309,24 @@ let sample = "waitForExpectations(timeout: 1)"
   assert.deepEqual(collectSwiftWaitForExpectationsLines(modernWait), []);
 });
 
+test('hasSwiftWaitForExpectationsUsage permite waits en UI tests XCTest brownfield explicitos', () => {
+  const uiWait = `
+import XCTest
+
+final class BuyerCommerceUISmokeTests: XCTestCase {
+  func testCheckoutFlow() {
+    let app = XCUIApplication()
+    app.launch()
+    XCTAssertTrue(app.buttons["Continue"].waitForExistence(timeout: 5))
+    wait(for: [expectation(description: "Loaded")], timeout: 1)
+  }
+}
+`;
+
+  assert.equal(hasSwiftWaitForExpectationsUsage(uiWait), false);
+  assert.deepEqual(collectSwiftWaitForExpectationsLines(uiWait), []);
+});
+
 test('hasSwiftLegacyExpectationDescriptionUsage detecta expectation(description:) sin flujo moderno', () => {
   const legacyExpectation = `
 let expectation = expectation(description: "Done")