pumuki 6.3.296 → 6.3.298

package/AGENTS.md

@@ -113,12 +113,67 @@ Antes de realizar cualquier accion:
   - `release/*`: debe salir de `develop` y solo contener cambios de estabilizacion/release.
   - `hotfix/*`: debe salir de `main` para fixes urgentes de produccion.
 - Esta prohibido commitear en `main` y `develop` sin instruccion explicita del usuario.
+- Ciclo de cierre de ramas obligatorio:
+  - una rama `feature/*`, `bugfix/*`, `chore/*`, `refactor/*` o `docs/*` terminada debe integrarse en `develop` mediante el flujo acordado;
+  - una rama `release/*` terminada debe integrarse en `main` y `develop`;
+  - una rama `hotfix/*` terminada debe integrarse en `main` y propagarse a `develop`;
+  - tras confirmar que la rama esta mergeada en sus destinos obligatorios, debe eliminarse la rama local y remota si existe;
+  - las ramas cerradas no pueden quedar acumuladas como backlog, marcador historico o pseudo-tracking.
+- Criterio de borrado seguro de ramas:
+  - antes de borrar cualquier rama, comprobar si esta mergeada con `git branch --merged <destino>`;
+  - si no aparece como mergeada, no borrarla sin revisar commits no integrados;
+  - si contiene commits utiles no integrados, integrarlos, crear backup branch explicita o stash/patch documentado antes de eliminar;
+  - nunca usar borrado forzado de ramas (`git branch -D` o delete remoto forzado) sin instruccion explicita y evidencia de preservacion.
+- La limpieza de ramas forma parte del cierre de cada slice:
+  - no se considera cerrada una task si deja worktrees temporales o ramas de trabajo ya mergeadas sin limpiar;
+  - si no se puede limpiar por riesgo, reportar `STATUS: BLOCKED` o dejar `NEXT instruction` explicita con la razon.
 - Si la rama actual no cumple naming o flujo:
   - detener implementacion,
   - declarar `STATUS: BLOCKED`,
   - explicar el conflicto de rama/flujo, y
   - pedir al usuario el cambio o confirmacion de rama antes de continuar.
 
+## Contrato hard de commits atomicos y limite de worktree (no negociable)
+- Todo cambio debe cerrarse en commits atomicos por slice funcional, bug o contrato tecnico.
+- Esta prohibido acumular cambios de varios subsistemas sin commit intermedio.
+- Un commit atomico debe tener una unica intencion verificable, por ejemplo:
+  - un detector AST/nodal concreto y sus tests,
+  - una correccion de gate/lifecycle concreta y sus tests,
+  - una mejora de notificacion concreta y sus tests,
+  - una actualizacion de tracking/docs estrictamente asociada a esa slice,
+  - una preparacion de release/versionado separada del codigo funcional.
+- Esta prohibido mezclar en el mismo commit:
+  - detectores AST con versionado/release,
+  - cambios de lifecycle/gate con cambios de menu/runtime no relacionados,
+  - cambios de consumers con cambios internos de Pumuki,
+  - tracking amplio con implementacion funcional no relacionada,
+  - limpieza de ramas/worktrees con codigo de producto.
+- Umbral hard de higiene:
+  - si `git status --short` muestra mas de 24 rutas pendientes, no se permite seguir implementando;
+  - si muestra mas de 12 rutas pendientes, se debe evaluar si la slice ya debe cerrarse;
+  - si existen archivos `??` fuera del alcance de la slice, deben clasificarse antes de continuar.
+- Si el worktree supera el umbral hard:
+  - declarar `STATUS: BLOCKED`,
+  - detener nuevas ediciones funcionales,
+  - listar cambios por subsistema,
+  - crear commits atomicos separados o stashes con nombre explicito antes de continuar,
+  - no usar un commit masivo para "limpiar" el estado.
+- Antes de cada commit:
+  - revisar `git diff --cached --name-status`,
+  - confirmar que todos los archivos staged pertenecen a la misma intencion,
+  - dejar fuera del stage cualquier archivo no relacionado,
+  - documentar en la respuesta la relacion `escenario -> tests -> evidencia -> task`.
+- Si los hooks bloquean por deuda ajena al staged:
+  - no ampliar el commit para "aprovechar",
+  - reportar la causa exacta,
+  - corregir Pumuki si es bug del gate,
+  - o aislar la slice si es deuda del worktree.
+- Las ramas locales y worktrees temporales deben revisarse con inventario antes de borrarse.
+- Esta prohibido borrar ramas, worktrees, stashes o directorios temporales con cambios sin:
+  - comprobar estado,
+  - preservar cambios en commit o stash con nombre explicito,
+  - y reportar la evidencia.
+
 ## Gate operativo obligatorio (antes de editar codigo)
 - Declarar internamente las skills aplicables y tratarlas como activas durante TODO el turno.
 - Verificar cumplimiento minimo previo:

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [6.3.298] - 2026-05-19
+
+- Release line for the merged notification/evidence/context cleanup on develop. Keeps the published package unique after 6.3.297 was already present on npm, preserving the actionable notification payloads, expanded AST detector coverage, PRE_WRITE lease/evidence cause propagation, lifecycle hook alignment, local context gate scaffold and atomic Git hygiene rules.
+
+## [6.3.297] - 2026-05-19
+
+- `PUMUKI-INC-157`: staged no-code/documentation/repin scopes no longer fail the skills contract with `EVIDENCE_SKILLS_PLATFORMS_UNDETECTED`. When the effective staged scope has no iOS, Android, backend or frontend code paths, platform skills are reported as `NOT_APPLICABLE` instead of blocking, while code-bearing slices keep the hard skills gate.
+
 ## [6.3.296] - 2026-05-19
 
 - `PUMUKI-INC-156`: follow-up after RuralGo replay. Broad SwiftUI findings are now considered non-actionable even when they include a `primary_node` if that node spans many lines. Only a bounded AST/node range can hard-block a staged diff; file-level brownfield SwiftUI debt remains advisory for the atomic slice.

package/VERSION

@@ -1 +1 @@
-6.3.294
+6.3.298

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

@@ -8,6 +8,8 @@ import {
   findSwiftPresentationSrpMatch,
   collectSwiftModernizableXCTestSuiteLines,
   collectSwiftLegacyExpectationDescriptionLines,
+  collectSwiftDirectSUTInstantiationWithoutMakeSUTLines,
+  collectSwiftMakeSUTWithoutMemoryTrackingLines,
   collectSwiftMixedTestingFrameworkLines,
   collectSwiftQuickNimbleLines,
   collectSwiftWaitForExpectationsLines,
@@ -35,6 +37,10 @@ import {
   hasSwiftNSErrorThrowUsage,
   collectSwiftPackageBranchDependencyLines,
   hasSwiftPackageBranchDependencyUsage,
+  collectSwiftPackageToolsVersionBelow62Lines,
+  hasSwiftPackageToolsVersionBelow62Usage,
+  collectSwiftStrictConcurrencyBelowCompleteLines,
+  hasSwiftStrictConcurrencyBelowCompleteUsage,
   hasSwiftForEachIndicesUsage,
   hasSwiftForEachSelfIdentityUsage,
   collectSwiftForceCastLines,
@@ -60,7 +66,9 @@ import {
   collectSwiftHardcodedUiStringLines,
   collectSwiftNonLazyScrollForEachLines,
   collectSwiftUiForEachConditionalViewCountLines,
+  collectSwiftAnimationWithoutReduceMotionLines,
   collectSwiftUiInlineActionLogicLines,
+  collectSwiftOnTapGestureWithoutButtonTraitLines,
   collectSwiftForEachIndicesLines,
   collectSwiftForEachSelfIdentityLines,
   collectSwiftInlineForEachTransformLines,
@@ -78,6 +86,8 @@ import {
   hasSwiftEnvironmentObjectUsage,
   hasSwiftLowContrastStaticColorPairUsage,
   hasSwiftMainThreadBlockingSleepUsage,
+  hasSwiftDirectSUTInstantiationWithoutMakeSUTUsage,
+  hasSwiftMakeSUTWithoutMemoryTrackingUsage,
   hasSwiftMassiveViewControllerResponsibilityUsage,
   hasSwiftMagicNumberLayoutUsage,
   hasSwiftMixedTestingFrameworksUsage,
@@ -86,8 +96,13 @@ import {
   hasSwiftNestedIfPyramidUsage,
   hasSwiftNonLazyScrollForEachUsage,
   hasSwiftUiForEachConditionalViewCountUsage,
+  hasSwiftAnimationWithoutReduceMotionUsage,
   hasSwiftViewBodyObjectCreationUsage,
   hasSwiftUiImageDataDecodingUsage,
+  collectSwiftUiManualRenderingWithoutImageRendererLines,
+  hasSwiftUiManualRenderingWithoutImageRendererUsage,
+  collectSwiftLargeViewBuilderFunctionLines,
+  hasSwiftLargeViewBuilderFunctionUsage,
   hasSwiftUiInlineActionLogicUsage,
   hasSwiftAssumeIsolatedUsage,
   hasSwiftCoreDataLayerLeakUsage,
@@ -108,6 +123,7 @@ import {
   hasSwiftOnAppearTaskUsage,
   collectSwiftOnAppearTaskLines,
   hasSwiftOnTapGestureUsage,
+  hasSwiftOnTapGestureWithoutButtonTraitUsage,
   hasSwiftOperationQueueUsage,
   hasSwiftContainsUserFilterUsage,
   hasSwiftCustomSingletonUsage,
@@ -128,6 +144,7 @@ import {
   hasSwiftExplicitColorStaticMemberUsage,
   hasSwiftClosureBasedViewBuilderContentUsage,
   collectSwiftForceUnwrapLines,
+  collectSwiftUIKitManualFrameLayoutLines,
   collectSwiftWarningSuppressionLines,
   hasSwiftLargeConfigContextViewPropertyUsage,
   hasSwiftUiConditionalSameViewIdentityUsage,
@@ -141,12 +158,19 @@ import {
   hasSwiftTabItemUsage,
   hasSwiftTaskDetachedUsage,
   hasSwiftUnownedSelfCaptureUsage,
+  collectSwiftManualMemoryManagementLines,
+  hasSwiftManualMemoryManagementUsage,
+  collectSwiftNonPascalCaseTypeDeclarationLines,
+  hasSwiftNonPascalCaseTypeDeclarationUsage,
+  collectSwiftCellCreationWithoutReuseLines,
+  hasSwiftCellCreationWithoutReuseUsage,
   hasSwiftWaitForExpectationsUsage,
   hasSwiftWarningSuppressionUsage,
   hasSwiftUIScreenMainBoundsUsage,
   hasSwiftXCTestAssertionUsage,
   hasSwiftXCTUnwrapUsage,
   hasSwiftUncheckedSendableUsage,
+  hasSwiftUIKitManualFrameLayoutUsage,
 } from './ios';
 
 test('hasSwiftForceUnwrap detecta force unwrap postfix en expresiones', () => {
@@ -230,6 +254,87 @@ let ignored = "[unowned self]"
   assert.equal(hasSwiftUnownedSelfCaptureUsage(safe), false);
 });
 
+test('hasSwiftManualMemoryManagementUsage detecta bypass manual de ARC', () => {
+  const source = `
+final class LegacyBridge {
+  func load(_ pointer: UnsafeRawPointer) {
+    let value = Unmanaged<NSObject>.fromOpaque(pointer).takeRetainedValue()
+    CFRetain(value)
+    CFRelease(value)
+  }
+}
+`;
+  const safe = `
+final class NativeBridge {
+  private let value = NSObject()
+  func load() -> NSObject {
+    let sample = "Unmanaged<NSObject>.fromOpaque(pointer)"
+    // CFRelease(value)
+    return value
+  }
+}
+`;
+
+  assert.equal(hasSwiftManualMemoryManagementUsage(source), true);
+  assert.deepEqual(collectSwiftManualMemoryManagementLines(source), [4, 5, 6]);
+  assert.equal(hasSwiftManualMemoryManagementUsage(safe), false);
+  assert.deepEqual(collectSwiftManualMemoryManagementLines(safe), []);
+});
+
+test('hasSwiftNonPascalCaseTypeDeclarationUsage detecta tipos Swift sin PascalCase', () => {
+  const source = `
+struct user_profile {}
+final class orderView {}
+protocol _service {}
+enum CheckoutState {}
+actor CartActor {}
+`;
+  const safe = `
+struct UserProfile {}
+final class OrderView {}
+protocol PaymentService {}
+enum CheckoutState {}
+actor CartActor {}
+let sample = "struct user_profile {}"
+// class orderView {}
+`;
+
+  assert.equal(hasSwiftNonPascalCaseTypeDeclarationUsage(source), true);
+  assert.deepEqual(collectSwiftNonPascalCaseTypeDeclarationLines(source), [2, 3, 4]);
+  assert.equal(hasSwiftNonPascalCaseTypeDeclarationUsage(safe), false);
+  assert.deepEqual(collectSwiftNonPascalCaseTypeDeclarationLines(safe), []);
+});
+
+test('hasSwiftCellCreationWithoutReuseUsage detecta celdas UIKit sin reutilizacion', () => {
+  const source = `
+final class OrdersDataSource: NSObject, UITableViewDataSource {
+  func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
+    let cell = UITableViewCell(style: .subtitle, reuseIdentifier: "OrderCell")
+    return cell
+  }
+
+  func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
+    return UICollectionViewCell(frame: .zero)
+  }
+}
+`;
+  const safe = `
+final class OrdersDataSource: NSObject, UITableViewDataSource {
+  func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
+    let cell = tableView.dequeueReusableCell(withIdentifier: "OrderCell", for: indexPath)
+    return cell
+  }
+}
+let sample = "UITableViewCell(style: .subtitle, reuseIdentifier: nil)"
+// return UICollectionViewCell(frame: .zero)
+`;
+
+  assert.equal(hasSwiftCellCreationWithoutReuseUsage(source), true);
+  assert.deepEqual(collectSwiftCellCreationWithoutReuseLines(source), [4, 9]);
+  assert.equal(hasSwiftCellCreationWithoutReuseUsage(safe), false);
+  assert.deepEqual(collectSwiftCellCreationWithoutReuseLines(safe), []);
+});
+
 test('hasSwiftNestedIfPyramidUsage detecta pyramid of doom y preserva guard clauses', () => {
   const source = `
 func submit() {
@@ -443,6 +548,52 @@ let sample = ".package(url: branch:)"
   assert.deepEqual(collectSwiftPackageBranchDependencyLines(safe), []);
 });
 
+test('hasSwiftPackageToolsVersionBelow62Usage detecta Package.swift iOS bajo Swift 6.2', () => {
+  const source = `
+// swift-tools-version: 5.9
+import PackageDescription
+`;
+  const sourceSixOne = `
+// swift-tools-version:6.1
+import PackageDescription
+`;
+  const safe = `
+// swift-tools-version: 6.2
+import PackageDescription
+// ordinary comment swift-tools-version: 5.9
+let sample = "// swift-tools-version: 5.9"
+`;
+
+  assert.equal(hasSwiftPackageToolsVersionBelow62Usage(source), true);
+  assert.deepEqual(collectSwiftPackageToolsVersionBelow62Lines(source), [2]);
+  assert.equal(hasSwiftPackageToolsVersionBelow62Usage(sourceSixOne), true);
+  assert.deepEqual(collectSwiftPackageToolsVersionBelow62Lines(sourceSixOne), [2]);
+  assert.equal(hasSwiftPackageToolsVersionBelow62Usage(safe), false);
+  assert.deepEqual(collectSwiftPackageToolsVersionBelow62Lines(safe), []);
+});
+
+test('hasSwiftStrictConcurrencyBelowCompleteUsage detecta Xcode strict concurrency inferior a complete', () => {
+  const source = `
+buildSettings = {
+  SWIFT_STRICT_CONCURRENCY = targeted;
+  OTHER_SWIFT_FLAGS = "$(inherited)";
+  SWIFT_STRICT_CONCURRENCY = minimal;
+};
+`;
+  const safe = `
+buildSettings = {
+  SWIFT_STRICT_CONCURRENCY = complete;
+  let sample = "SWIFT_STRICT_CONCURRENCY = targeted;"
+  // SWIFT_STRICT_CONCURRENCY = minimal;
+};
+`;
+
+  assert.equal(hasSwiftStrictConcurrencyBelowCompleteUsage(source), true);
+  assert.deepEqual(collectSwiftStrictConcurrencyBelowCompleteLines(source), [3, 5]);
+  assert.equal(hasSwiftStrictConcurrencyBelowCompleteUsage(safe), false);
+  assert.deepEqual(collectSwiftStrictConcurrencyBelowCompleteLines(safe), []);
+});
+
 test('hasSwiftNonLazyScrollForEachUsage detecta ScrollView con stack no lazy y preserva LazyVStack', () => {
   const source = `
 struct FeedView: View {
@@ -571,6 +722,74 @@ struct AvatarView: View {
   assert.equal(hasSwiftUiImageDataDecodingUsage(safe), false);
 });
 
+test('hasSwiftUiManualRenderingWithoutImageRendererUsage detecta render manual de SwiftUI sin ImageRenderer', () => {
+  const source = `
+struct ReceiptExporter {
+  func image(from receipt: ReceiptView) -> UIImage {
+    let controller = UIHostingController(rootView: receipt)
+    let renderer = UIGraphicsImageRenderer(size: controller.view.bounds.size)
+    return renderer.image { _ in
+      controller.view.drawHierarchy(in: controller.view.bounds, afterScreenUpdates: true)
+    }
+  }
+}
+`;
+  const safe = `
+struct ReceiptExporter {
+  func image(from receipt: ReceiptView) -> UIImage? {
+    let renderer = ImageRenderer(content: receipt)
+    let sample = "UIHostingController(rootView: receipt)"
+    // UIGraphicsImageRenderer(size: .zero)
+    return renderer.uiImage
+  }
+}
+`;
+
+  assert.equal(hasSwiftUiManualRenderingWithoutImageRendererUsage(source), true);
+  assert.deepEqual(collectSwiftUiManualRenderingWithoutImageRendererLines(source), [4, 5, 7]);
+  assert.equal(hasSwiftUiManualRenderingWithoutImageRendererUsage(safe), false);
+  assert.deepEqual(collectSwiftUiManualRenderingWithoutImageRendererLines(safe), []);
+});
+
+test('hasSwiftLargeViewBuilderFunctionUsage detecta @ViewBuilder functions grandes y preserva secciones pequenas', () => {
+  const source = `
+struct CheckoutView: View {
+  @ViewBuilder
+  private func checkoutSections() -> some View {
+    HeaderView()
+    SummaryView()
+    AddressView()
+    PaymentView()
+    CouponView()
+    LoyaltyView()
+    DeliveryView()
+    NotesView()
+    LegalView()
+    FooterView()
+    SupportView()
+    TrackingView()
+    ConfirmationView()
+  }
+}
+`;
+  const safe = `
+struct CheckoutView: View {
+  @ViewBuilder
+  private func header() -> some View {
+    HeaderView()
+    SubtitleView()
+    let sample = "@ViewBuilder func huge() { A() B() C() }"
+    // @ViewBuilder func huge() { A() B() C() }
+  }
+}
+`;
+
+  assert.equal(hasSwiftLargeViewBuilderFunctionUsage(source), true);
+  assert.deepEqual(collectSwiftLargeViewBuilderFunctionLines(source), [3, 4]);
+  assert.equal(hasSwiftLargeViewBuilderFunctionUsage(safe), false);
+  assert.deepEqual(collectSwiftLargeViewBuilderFunctionLines(safe), []);
+});
+
 test('hasSwiftUiInlineActionLogicUsage detecta lógica inline en Button y preserva método referenciado', () => {
   const source = `
 struct CheckoutView: View {
@@ -608,6 +827,42 @@ struct CheckoutView: View {
   assert.deepEqual(collectSwiftUiInlineActionLogicLines(safe), []);
 });
 
+test('hasSwiftAnimationWithoutReduceMotionUsage detecta animaciones sin preferencia reduce motion', () => {
+  const source = `
+struct CheckoutView: View {
+  @State private var expanded = false
+
+  var body: some View {
+    Text("Checkout")
+      .animation(.spring(), value: expanded)
+      .onTapGesture {
+        withAnimation {
+          expanded.toggle()
+        }
+      }
+  }
+}
+`;
+  const safe = `
+struct CheckoutView: View {
+  @Environment(\\.accessibilityReduceMotion) private var reduceMotion
+  @State private var expanded = false
+
+  var body: some View {
+    Text("Checkout")
+      .animation(reduceMotion ? nil : .spring(), value: expanded)
+    let sample = "withAnimation { expanded.toggle() }"
+    // .animation(.spring(), value: expanded)
+  }
+}
+`;
+
+  assert.equal(hasSwiftAnimationWithoutReduceMotionUsage(source), true);
+  assert.deepEqual(collectSwiftAnimationWithoutReduceMotionLines(source), [7, 9]);
+  assert.equal(hasSwiftAnimationWithoutReduceMotionUsage(safe), false);
+  assert.deepEqual(collectSwiftAnimationWithoutReduceMotionLines(safe), []);
+});
+
 test('hasSwiftForEachSelfIdentityUsage detecta id self y preserva ids estables', () => {
   const source = `
 struct FeedView: View {
@@ -1129,6 +1384,44 @@ struct ProfileView: View {
   assert.deepEqual(collectSwiftMagicNumberLayoutLines(constants), []);
 });
 
+test('hasSwiftUIKitManualFrameLayoutUsage detecta layout manual UIKit y preserva Auto Layout y SwiftUI frame', () => {
+  const source = `
+final class CheckoutView: UIView {
+  private let titleLabel = UILabel(frame: CGRect(x: 0, y: 0, width: 320, height: 44))
+
+  func layoutBadge() {
+    badgeView.frame = CGRect(x: 16, y: 16, width: 80, height: 32)
+  }
+}
+`;
+  const safe = `
+final class CheckoutView: UIView {
+  private let titleLabel = UILabel()
+
+  func installConstraints() {
+    titleLabel.translatesAutoresizingMaskIntoConstraints = false
+    NSLayoutConstraint.activate([
+      titleLabel.leadingAnchor.constraint(equalTo: leadingAnchor)
+    ])
+  }
+}
+
+struct CheckoutSwiftUIView: View {
+  var body: some View {
+    Text("Checkout").frame(maxWidth: .infinity)
+  }
+}
+
+let sample = "UILabel(frame: CGRect(x: 0, y: 0, width: 10, height: 10))"
+// badgeView.frame = CGRect(x: 0, y: 0, width: 10, height: 10)
+`;
+
+  assert.equal(hasSwiftUIKitManualFrameLayoutUsage(source), true);
+  assert.deepEqual(collectSwiftUIKitManualFrameLayoutLines(source), [3, 6]);
+  assert.equal(hasSwiftUIKitManualFrameLayoutUsage(safe), false);
+  assert.deepEqual(collectSwiftUIKitManualFrameLayoutLines(safe), []);
+});
+
 test('detectores de logging iOS detectan logs ad-hoc y PII en produccion', () => {
   const adHoc = `
 print(user.id)
@@ -1629,6 +1922,38 @@ MainActor.assumeIsolated { reload() }
   assert.equal(hasSwiftPassedValueStateWrapperUsage(source), true);
 });
 
+test('hasSwiftOnTapGestureWithoutButtonTraitUsage detecta tap no semantico sin trait de boton', () => {
+  const source = `
+struct RowView: View {
+  var body: some View {
+    Image(systemName: "cart")
+      .onTapGesture {
+        addToCart()
+      }
+  }
+}
+`;
+  const safe = `
+struct RowView: View {
+  var body: some View {
+    Image(systemName: "cart")
+      .onTapGesture {
+        addToCart()
+      }
+      .accessibilityAddTraits(.isButton)
+
+    let sample = ".onTapGesture { addToCart() }"
+    // .onTapGesture { addToCart() }
+  }
+}
+`;
+
+  assert.equal(hasSwiftOnTapGestureWithoutButtonTraitUsage(source), true);
+  assert.deepEqual(collectSwiftOnTapGestureWithoutButtonTraitLines(source), [5]);
+  assert.equal(hasSwiftOnTapGestureWithoutButtonTraitUsage(safe), false);
+  assert.deepEqual(collectSwiftOnTapGestureWithoutButtonTraitLines(safe), []);
+});
+
 test('detectores legacy ignoran strings y comentarios', () => {
   const source = `
 // Task.detached { }
@@ -2217,6 +2542,88 @@ final class BuyerOnboardingStringsTests: XCTestCase {
   assert.deepEqual(collectSwiftXCTUnwrapLines(brownfieldSpec), []);
 });
 
+test('hasSwiftMakeSUTWithoutMemoryTrackingUsage detecta specs con makeSUT sin trackForMemoryLeaks', () => {
+  const source = `
+import XCTest
+
+final class BuyerAuthScreenTests: XCTestCase {
+  func testRendersTitle() {
+    let sut = makeSUT()
+    XCTAssertNotNil(sut)
+  }
+
+  private func makeSUT() -> BuyerAuthScreen {
+    BuyerAuthScreen()
+  }
+}
+`;
+  const safe = `
+import XCTest
+
+final class BuyerAuthScreenTests: XCTestCase {
+  func testRendersTitle() {
+    let sut = makeSUT()
+    XCTAssertNotNil(sut)
+  }
+
+  private func makeSUT() -> BuyerAuthScreen {
+    let sut = BuyerAuthScreen()
+    trackForMemoryLeaks(sut)
+    return sut
+  }
+}
+
+let sample = "makeSUT() without trackForMemoryLeaks"
+// private func makeSUT() -> Sample { Sample() }
+`;
+
+  assert.equal(hasSwiftMakeSUTWithoutMemoryTrackingUsage(source), true);
+  assert.deepEqual(collectSwiftMakeSUTWithoutMemoryTrackingLines(source), [6, 10]);
+  assert.equal(hasSwiftMakeSUTWithoutMemoryTrackingUsage(safe), false);
+  assert.deepEqual(collectSwiftMakeSUTWithoutMemoryTrackingLines(safe), []);
+});
+
+test('hasSwiftDirectSUTInstantiationWithoutMakeSUTUsage detecta sut inline sin factory', () => {
+  const source = `
+import XCTest
+
+final class BuyerAuthScreenTests: XCTestCase {
+  func testRendersTitle() {
+    let sut = BuyerAuthScreen()
+    XCTAssertNotNil(sut)
+  }
+
+  func testRendersSubtitle() {
+    var sut = BuyerAuthScreen(viewModel: BuyerAuthViewModel())
+    XCTAssertNotNil(sut)
+  }
+}
+`;
+  const safe = `
+import XCTest
+
+final class BuyerAuthScreenTests: XCTestCase {
+  func testRendersTitle() {
+    let sut = makeSUT()
+    XCTAssertNotNil(sut)
+  }
+
+  private func makeSUT() -> BuyerAuthScreen {
+    BuyerAuthScreen()
+  }
+}
+
+let ignored = "let sut = BuyerAuthScreen()"
+// let sut = BuyerAuthScreen()
+let notSut = BuyerAuthScreen()
+`;
+
+  assert.equal(hasSwiftDirectSUTInstantiationWithoutMakeSUTUsage(source), true);
+  assert.deepEqual(collectSwiftDirectSUTInstantiationWithoutMakeSUTLines(source), [6, 11]);
+  assert.equal(hasSwiftDirectSUTInstantiationWithoutMakeSUTUsage(safe), false);
+  assert.deepEqual(collectSwiftDirectSUTInstantiationWithoutMakeSUTLines(safe), []);
+});
+
 test('hasSwiftMixedTestingFrameworksUsage detecta mezcla XCTestCase y Testing/@Test', () => {
   const mixedSuite = `
 import XCTest