pumuki 6.3.60 → 6.3.61

package/VERSION

@@ -1 +1 @@
-v6.3.57
+v6.3.61

package/assets/rule-packs/ios-swiftui-modernization-v1.json

@@ -0,0 +1,77 @@
+{
+  "snapshotId": "ios-swiftui-modernization-v1",
+  "version": "1.0.0",
+  "generatedAt": "2026-03-31T00:00:00.000Z",
+  "sourceSkill": "swiftui-expert-skill",
+  "sourceReferences": [
+    "vendor/skills/swiftui-expert-skill/references/modern-apis.md",
+    "vendor/skills/swiftui-expert-skill/references/text-formatting.md",
+    "vendor/skills/swiftui-expert-skill/references/scroll-patterns.md"
+  ],
+  "entries": [
+    {
+      "id": "foreground-color",
+      "ruleId": "skills.ios.no-foreground-color",
+      "heuristicRuleId": "heuristics.ios.foreground-color.ast",
+      "category": "styling",
+      "legacyApi": ".foregroundColor(...)",
+      "modernApi": ".foregroundStyle(...)",
+      "rationale": "foregroundStyle supports hierarchical styles, gradients and materials.",
+      "confidence": "HIGH",
+      "minimumStage": "PRE_PUSH",
+      "minimumIos": "13.0",
+      "match": {
+        "kind": "regex",
+        "pattern": "\\.\\s*foregroundColor\\s*\\("
+      }
+    },
+    {
+      "id": "corner-radius",
+      "ruleId": "skills.ios.no-corner-radius",
+      "heuristicRuleId": "heuristics.ios.corner-radius.ast",
+      "category": "styling",
+      "legacyApi": ".cornerRadius(...)",
+      "modernApi": ".clipShape(.rect(cornerRadius: ...))",
+      "rationale": "cornerRadius is deprecated in modern SwiftUI and clipShape is explicit about the rendered shape.",
+      "confidence": "HIGH",
+      "minimumStage": "PRE_PUSH",
+      "minimumIos": "17.0",
+      "match": {
+        "kind": "regex",
+        "pattern": "\\.\\s*cornerRadius\\s*\\("
+      }
+    },
+    {
+      "id": "tab-item",
+      "ruleId": "skills.ios.no-tab-item",
+      "heuristicRuleId": "heuristics.ios.tab-item.ast",
+      "category": "tabs",
+      "legacyApi": ".tabItem { ... }",
+      "modernApi": "Tab { ... } label: { ... }",
+      "rationale": "The Tab API unlocks modern tab roles and avoids mixed syntax issues on iOS 18+.",
+      "confidence": "MEDIUM",
+      "minimumStage": "PRE_PUSH",
+      "minimumIos": "18.0",
+      "match": {
+        "kind": "regex",
+        "pattern": "\\.\\s*tabItem\\s*\\{"
+      }
+    },
+    {
+      "id": "scrollview-shows-indicators",
+      "ruleId": "skills.ios.no-scrollview-shows-indicators",
+      "heuristicRuleId": "heuristics.ios.scrollview-shows-indicators.ast",
+      "category": "scrolling",
+      "legacyApi": "ScrollView(..., showsIndicators: false)",
+      "modernApi": ".scrollIndicators(.hidden)",
+      "rationale": "The modifier-based API keeps the initializer clean and matches modern SwiftUI scrolling patterns.",
+      "confidence": "HIGH",
+      "minimumStage": "PRE_PUSH",
+      "minimumIos": "16.0",
+      "match": {
+        "kind": "regex",
+        "pattern": "\\bScrollView\\s*\\([\\s\\S]{0,80}showsIndicators\\s*:\\s*false\\b"
+      }
+    }
+  ]
+}

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

@@ -8,19 +8,28 @@ import {
   findSwiftPresentationSrpMatch,
   hasSwiftAnyViewUsage,
   hasSwiftCallbackStyleSignature,
+  hasSwiftCornerRadiusUsage,
   hasSwiftDispatchGroupUsage,
   hasSwiftDispatchQueueUsage,
   hasSwiftDispatchSemaphoreUsage,
   hasSwiftForceCastUsage,
+  hasSwiftForegroundColorUsage,
   hasSwiftForceTryUsage,
   hasSwiftForceUnwrap,
+  hasSwiftLegacyXCTestImportUsage,
+  hasSwiftNSManagedObjectAsyncBoundaryUsage,
+  hasSwiftNSManagedObjectBoundaryUsage,
   hasSwiftNavigationViewUsage,
   hasSwiftObservableObjectUsage,
   hasSwiftOnTapGestureUsage,
   hasSwiftOperationQueueUsage,
+  hasSwiftScrollViewShowsIndicatorsUsage,
   hasSwiftStringFormatUsage,
+  hasSwiftTabItemUsage,
   hasSwiftTaskDetachedUsage,
   hasSwiftUIScreenMainBoundsUsage,
+  hasSwiftXCTestAssertionUsage,
+  hasSwiftXCTUnwrapUsage,
   hasSwiftUncheckedSendableUsage,
 } from './ios';
 
@@ -159,15 +168,29 @@ test('detectores SwiftUI modernos detectan patrones legacy relevantes', () => {
   const source = `
 final class LegacyViewModel: ObservableObject {}
 NavigationView { Text("x") }
+Text("Primary").foregroundColor(.blue)
+Image("hero").cornerRadius(12)
+TabView {
+  HomeView().tabItem {
+    Label("Home", systemImage: "house")
+  }
+}
 Text("Tap").onTapGesture { }
 let value = String(format: "%d", 1)
 let width = UIScreen.main.bounds.width
+ScrollView(.horizontal, showsIndicators: false) {
+  Text("feed")
+}
 `;
   assert.equal(hasSwiftObservableObjectUsage(source), true);
   assert.equal(hasSwiftNavigationViewUsage(source), true);
+  assert.equal(hasSwiftForegroundColorUsage(source), true);
+  assert.equal(hasSwiftCornerRadiusUsage(source), true);
+  assert.equal(hasSwiftTabItemUsage(source), true);
   assert.equal(hasSwiftOnTapGestureUsage(source), true);
   assert.equal(hasSwiftStringFormatUsage(source), true);
   assert.equal(hasSwiftUIScreenMainBoundsUsage(source), true);
+  assert.equal(hasSwiftScrollViewShowsIndicatorsUsage(source), true);
 });
 
 test('detectores legacy ignoran strings y comentarios', () => {
@@ -177,11 +200,129 @@ let a = "Task.detached { }"
 let b = "NavigationView { }"
 let c = "String(format: \\\"%d\\\", 1)"
 let d = "UIScreen.main.bounds.width"
+let e = ".foregroundColor(.blue)"
+let f = ".cornerRadius(12)"
+let g = ".tabItem { Label(\\\"Home\\\", systemImage: \\\"house\\\") }"
+let h = "ScrollView(showsIndicators: false) { }"
 `;
   assert.equal(hasSwiftTaskDetachedUsage(source), false);
   assert.equal(hasSwiftNavigationViewUsage(source), false);
+  assert.equal(hasSwiftForegroundColorUsage(source), false);
+  assert.equal(hasSwiftCornerRadiusUsage(source), false);
+  assert.equal(hasSwiftTabItemUsage(source), false);
   assert.equal(hasSwiftStringFormatUsage(source), false);
   assert.equal(hasSwiftUIScreenMainBoundsUsage(source), false);
+  assert.equal(hasSwiftScrollViewShowsIndicatorsUsage(source), false);
+});
+
+test('detectores snapshot SwiftUI ignoran reemplazos modernos', () => {
+  const source = `
+Text("Primary").foregroundStyle(.blue)
+Image("hero").clipShape(.rect(cornerRadius: 12))
+TabView {
+  Tab("Home", systemImage: "house") {
+    HomeView()
+  }
+}
+ScrollView {
+  Text("feed")
+}
+.scrollIndicators(.hidden)
+`;
+  assert.equal(hasSwiftForegroundColorUsage(source), false);
+  assert.equal(hasSwiftCornerRadiusUsage(source), false);
+  assert.equal(hasSwiftTabItemUsage(source), false);
+  assert.equal(hasSwiftScrollViewShowsIndicatorsUsage(source), false);
+});
+
+test('hasSwiftLegacyXCTestImportUsage detecta XCTest unitario y excluye UI/performance', () => {
+  const unitTest = `
+import XCTest
+
+final class LoginTests: XCTestCase {}
+`;
+  const uiTest = `
+import XCTest
+
+final class LoginUITests: XCTestCase {
+  func testLoginFlow() {
+    let app = XCUIApplication()
+    app.launch()
+  }
+}
+`;
+  const performanceTest = `
+import XCTest
+
+final class SyncTests: XCTestCase {
+  func testPerformance() {
+    measure {
+      runSync()
+    }
+  }
+}
+`;
+
+  assert.equal(hasSwiftLegacyXCTestImportUsage(unitTest), true);
+  assert.equal(hasSwiftLegacyXCTestImportUsage(uiTest), false);
+  assert.equal(hasSwiftLegacyXCTestImportUsage(performanceTest), false);
+});
+
+test('hasSwiftXCTestAssertionUsage detecta XCTAssert y XCTFail reales', () => {
+  const source = `
+XCTAssertEqual(value, expected)
+XCTFail("boom")
+`;
+  const ignored = `
+// XCTAssertEqual(value, expected)
+let text = "XCTAssertEqual(value, expected)"
+`;
+
+  assert.equal(hasSwiftXCTestAssertionUsage(source), true);
+  assert.equal(hasSwiftXCTestAssertionUsage(ignored), false);
+});
+
+test('hasSwiftXCTUnwrapUsage detecta XCTUnwrap real y evita strings', () => {
+  const source = `
+let value = try XCTUnwrap(optionalValue)
+`;
+  const ignored = `
+let text = "XCTUnwrap(optionalValue)"
+`;
+
+  assert.equal(hasSwiftXCTUnwrapUsage(source), true);
+  assert.equal(hasSwiftXCTUnwrapUsage(ignored), false);
+});
+
+test('hasSwiftNSManagedObjectBoundaryUsage detecta boundaries con NSManagedObject y excluye IDs o subclases', () => {
+  const source = `
+func persist(_ entity: NSManagedObject) {}
+var selectedEntity: NSManagedObject?
+`;
+  const ignored = `
+final class TodoEntity: NSManagedObject {}
+var selectedID: NSManagedObjectID?
+let context: NSManagedObjectContext
+`;
+
+  assert.equal(hasSwiftNSManagedObjectBoundaryUsage(source), true);
+  assert.equal(hasSwiftNSManagedObjectBoundaryUsage(ignored), false);
+});
+
+test('hasSwiftNSManagedObjectAsyncBoundaryUsage detecta async APIs con NSManagedObject', () => {
+  const source = `
+func fetchEntity() async throws -> NSManagedObject {
+  fatalError()
+}
+`;
+  const ignored = `
+func fetchEntityID() async throws -> NSManagedObjectID {
+  fatalError()
+}
+`;
+
+  assert.equal(hasSwiftNSManagedObjectAsyncBoundaryUsage(source), true);
+  assert.equal(hasSwiftNSManagedObjectAsyncBoundaryUsage(ignored), false);
 });
 
 test('findSwiftPresentationSrpMatch devuelve payload semantico para SRP-iOS en presentation', () => {

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

@@ -6,6 +6,7 @@ import {
   readIdentifierBackward,
   scanCodeLikeSource,
 } from './utils';
+import { getIosSwiftUiModernizationEntry } from './iosSwiftUiModernizationSnapshot';
 
 export type SwiftSemanticNodeMatch = {
   kind: 'class' | 'property' | 'call' | 'member';
@@ -85,6 +86,26 @@ const collectSwiftRegexLines = (source: string, regex: RegExp): readonly number[
   return matches;
 };
 
+const sanitizeSwiftSourceForMultilineRegex = (source: string): string => {
+  return source
+    .replace(/\/\*[\s\S]*?\*\//g, ' ')
+    .replace(/\/\/.*$/gm, '')
+    .replace(/"(?:\\.|[^"\\])*"/g, '""');
+};
+
+const hasSwiftSanitizedRegexMatch = (source: string, regex: RegExp): boolean => {
+  regex.lastIndex = 0;
+  return regex.test(sanitizeSwiftSourceForMultilineRegex(source));
+};
+
+const hasSwiftUiModernizationSnapshotMatch = (source: string, entryId: string): boolean => {
+  const entry = getIosSwiftUiModernizationEntry(entryId);
+  if (!entry) {
+    return false;
+  }
+  return hasSwiftSanitizedRegexMatch(source, new RegExp(entry.match.pattern, 'g'));
+};
+
 const sortedUniqueLines = (lines: ReadonlyArray<number>): readonly number[] => {
   return Array.from(new Set(lines.filter((line) => Number.isFinite(line)).map((line) => Math.trunc(line))))
     .sort((left, right) => left - right);
@@ -370,6 +391,18 @@ export const hasSwiftNavigationViewUsage = (source: string): boolean => {
   });
 };
 
+export const hasSwiftForegroundColorUsage = (source: string): boolean => {
+  return hasSwiftUiModernizationSnapshotMatch(source, 'foreground-color');
+};
+
+export const hasSwiftCornerRadiusUsage = (source: string): boolean => {
+  return hasSwiftUiModernizationSnapshotMatch(source, 'corner-radius');
+};
+
+export const hasSwiftTabItemUsage = (source: string): boolean => {
+  return hasSwiftUiModernizationSnapshotMatch(source, 'tab-item');
+};
+
 export const hasSwiftOnTapGestureUsage = (source: string): boolean => {
   return scanCodeLikeSource(source, ({ source: swiftSource, index, current }) => {
     if (current !== 'o') {
@@ -427,6 +460,48 @@ export const hasSwiftUIScreenMainBoundsUsage = (source: string): boolean => {
   });
 };
 
+export const hasSwiftScrollViewShowsIndicatorsUsage = (source: string): boolean => {
+  return hasSwiftUiModernizationSnapshotMatch(source, 'scrollview-shows-indicators');
+};
+
+export const hasSwiftLegacyXCTestImportUsage = (source: string): boolean => {
+  const hasXCTestImport = collectSwiftRegexLines(source, /^\s*import\s+XCTest\b/).length > 0;
+  if (!hasXCTestImport) {
+    return false;
+  }
+
+  if (hasSwiftSanitizedRegexMatch(source, /\bXCUIApplication\b|\bXCTMetric\b|\bmeasure\s*(?:\(|\{)/)) {
+    return false;
+  }
+
+  return true;
+};
+
+export const hasSwiftXCTestAssertionUsage = (source: string): boolean => {
+  return (
+    collectSwiftRegexLines(source, /\bXCTAssert[A-Za-z0-9_]*\s*\(/).length > 0 ||
+    collectSwiftRegexLines(source, /\bXCTFail\s*\(/).length > 0
+  );
+};
+
+export const hasSwiftXCTUnwrapUsage = (source: string): boolean => {
+  return collectSwiftRegexLines(source, /\bXCTUnwrap\s*\(/).length > 0;
+};
+
+export const hasSwiftNSManagedObjectBoundaryUsage = (source: string): boolean => {
+  return hasSwiftSanitizedRegexMatch(
+    source,
+    /\bfunc\b[\s\S]{0,240}\([^)]*\bNSManagedObject\b(?!ID\b|Context\b)[^)]*\)|\b(?:var|let)\s+[A-Za-z_][A-Za-z0-9_]*\s*:\s*(?:\[[^\]]*NSManagedObject\b(?!ID\b|Context\b)[^\]]*\]|NSManagedObject\b(?!ID\b|Context\b))/g
+  );
+};
+
+export const hasSwiftNSManagedObjectAsyncBoundaryUsage = (source: string): boolean => {
+  return hasSwiftSanitizedRegexMatch(
+    source,
+    /\bfunc\b[\s\S]{0,240}\basync\b[\s\S]{0,200}(?:\([^)]*\bNSManagedObject\b(?!ID\b|Context\b)[^)]*\)|->\s*(?:\[[^\]]*NSManagedObject\b(?!ID\b|Context\b)[^\]]*\]|NSManagedObject\b(?!ID\b|Context\b)))/g
+  );
+};
+
 export const hasSwiftForceTryUsage = (source: string): boolean => {
   return scanCodeLikeSource(source, ({ source: swiftSource, index, current }) => {
     if (current !== 't' || !hasIdentifierAt(swiftSource, index, 'try')) {

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

@@ -0,0 +1,31 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  getIosSwiftUiModernizationEntry,
+  IOS_SWIFTUI_MODERNIZATION_SNAPSHOT,
+  listIosSwiftUiModernizationEntries,
+} from './iosSwiftUiModernizationSnapshot';
+
+test('iosSwiftUiModernizationSnapshot expone snapshot versionado y determinista', () => {
+  assert.equal(IOS_SWIFTUI_MODERNIZATION_SNAPSHOT.snapshotId, 'ios-swiftui-modernization-v1');
+  assert.equal(IOS_SWIFTUI_MODERNIZATION_SNAPSHOT.version, '1.0.0');
+  assert.equal(IOS_SWIFTUI_MODERNIZATION_SNAPSHOT.sourceSkill, 'swiftui-expert-skill');
+  assert.deepEqual(
+    listIosSwiftUiModernizationEntries().map((entry) => entry.id),
+    ['foreground-color', 'corner-radius', 'tab-item', 'scrollview-shows-indicators']
+  );
+});
+
+test('iosSwiftUiModernizationSnapshot resuelve entradas canonicas con ruleIds y heuristics alineados', () => {
+  const foregroundColor = getIosSwiftUiModernizationEntry('foreground-color');
+  const tabItem = getIosSwiftUiModernizationEntry('tab-item');
+
+  assert.ok(foregroundColor);
+  assert.equal(foregroundColor.ruleId, 'skills.ios.no-foreground-color');
+  assert.equal(foregroundColor.heuristicRuleId, 'heuristics.ios.foreground-color.ast');
+
+  assert.ok(tabItem);
+  assert.equal(tabItem.ruleId, 'skills.ios.no-tab-item');
+  assert.equal(tabItem.heuristicRuleId, 'heuristics.ios.tab-item.ast');
+  assert.equal(tabItem.minimumIos, '18.0');
+});

package/core/facts/detectors/text/iosSwiftUiModernizationSnapshot.ts

@@ -0,0 +1,110 @@
+import rawSnapshot from '../../../../assets/rule-packs/ios-swiftui-modernization-v1.json';
+
+export type IosSwiftUiModernizationConfidence = 'HIGH' | 'MEDIUM';
+export type IosSwiftUiModernizationStage = 'PRE_COMMIT' | 'PRE_PUSH' | 'CI';
+export type IosSwiftUiModernizationCategory = 'styling' | 'tabs' | 'scrolling';
+
+export type IosSwiftUiModernizationMatch = {
+  kind: 'regex';
+  pattern: string;
+};
+
+export type IosSwiftUiModernizationEntry = {
+  id: string;
+  ruleId: string;
+  heuristicRuleId: string;
+  category: IosSwiftUiModernizationCategory;
+  legacyApi: string;
+  modernApi: string;
+  rationale: string;
+  confidence: IosSwiftUiModernizationConfidence;
+  minimumStage: IosSwiftUiModernizationStage;
+  minimumIos: string;
+  match: IosSwiftUiModernizationMatch;
+};
+
+export type IosSwiftUiModernizationSnapshot = {
+  snapshotId: string;
+  version: string;
+  generatedAt: string;
+  sourceSkill: string;
+  sourceReferences: readonly string[];
+  entries: readonly IosSwiftUiModernizationEntry[];
+};
+
+const isObject = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null;
+
+const isNonEmptyString = (value: unknown): value is string =>
+  typeof value === 'string' && value.trim().length > 0;
+
+const isStage = (value: unknown): value is IosSwiftUiModernizationStage =>
+  value === 'PRE_COMMIT' || value === 'PRE_PUSH' || value === 'CI';
+
+const isConfidence = (value: unknown): value is IosSwiftUiModernizationConfidence =>
+  value === 'HIGH' || value === 'MEDIUM';
+
+const isCategory = (value: unknown): value is IosSwiftUiModernizationCategory =>
+  value === 'styling' || value === 'tabs' || value === 'scrolling';
+
+const isMatch = (value: unknown): value is IosSwiftUiModernizationMatch => {
+  return (
+    isObject(value) &&
+    value.kind === 'regex' &&
+    isNonEmptyString(value.pattern)
+  );
+};
+
+const isEntry = (value: unknown): value is IosSwiftUiModernizationEntry => {
+  return (
+    isObject(value) &&
+    isNonEmptyString(value.id) &&
+    isNonEmptyString(value.ruleId) &&
+    isNonEmptyString(value.heuristicRuleId) &&
+    isCategory(value.category) &&
+    isNonEmptyString(value.legacyApi) &&
+    isNonEmptyString(value.modernApi) &&
+    isNonEmptyString(value.rationale) &&
+    isConfidence(value.confidence) &&
+    isStage(value.minimumStage) &&
+    isNonEmptyString(value.minimumIos) &&
+    isMatch(value.match)
+  );
+};
+
+const isSnapshot = (value: unknown): value is IosSwiftUiModernizationSnapshot => {
+  return (
+    isObject(value) &&
+    isNonEmptyString(value.snapshotId) &&
+    isNonEmptyString(value.version) &&
+    isNonEmptyString(value.generatedAt) &&
+    isNonEmptyString(value.sourceSkill) &&
+    Array.isArray(value.sourceReferences) &&
+    value.sourceReferences.every((item) => isNonEmptyString(item)) &&
+    Array.isArray(value.entries) &&
+    value.entries.every((entry) => isEntry(entry))
+  );
+};
+
+const parseSnapshot = (value: unknown): IosSwiftUiModernizationSnapshot => {
+  if (!isSnapshot(value)) {
+    throw new Error('Invalid iOS SwiftUI modernization snapshot.');
+  }
+  return value;
+};
+
+export const IOS_SWIFTUI_MODERNIZATION_SNAPSHOT = parseSnapshot(rawSnapshot);
+
+const entryById = new Map(
+  IOS_SWIFTUI_MODERNIZATION_SNAPSHOT.entries.map((entry) => [entry.id, entry] as const)
+);
+
+export const listIosSwiftUiModernizationEntries = (): readonly IosSwiftUiModernizationEntry[] => {
+  return IOS_SWIFTUI_MODERNIZATION_SNAPSHOT.entries;
+};
+
+export const getIosSwiftUiModernizationEntry = (
+  entryId: string
+): IosSwiftUiModernizationEntry | undefined => {
+  return entryById.get(entryId);
+};

package/core/facts/extractHeuristicFacts.ts

@@ -128,6 +128,10 @@ const isSwiftTestPath = (path: string): boolean => {
   );
 };
 
+const isIOSSwiftTestPath = (path: string): boolean => {
+  return isIOSSwiftPath(path) && isSwiftTestPath(path);
+};
+
 const isKotlinTestPath = (path: string): boolean => {
   const normalized = path.toLowerCase();
   return (
@@ -594,9 +598,18 @@ const textDetectorRegistry: ReadonlyArray<TextDetectorRegistryEntry> = [
   { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftUncheckedSendableUsage, ruleId: 'heuristics.ios.unchecked-sendable.ast', code: 'HEURISTICS_IOS_UNCHECKED_SENDABLE_AST', message: 'AST heuristic detected @unchecked Sendable usage.' },
   { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftObservableObjectUsage, ruleId: 'heuristics.ios.observable-object.ast', code: 'HEURISTICS_IOS_OBSERVABLE_OBJECT_AST', message: 'AST heuristic detected ObservableObject usage.' },
   { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftNavigationViewUsage, ruleId: 'heuristics.ios.navigation-view.ast', code: 'HEURISTICS_IOS_NAVIGATION_VIEW_AST', message: 'AST heuristic detected NavigationView usage.' },
+  { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftForegroundColorUsage, ruleId: 'heuristics.ios.foreground-color.ast', code: 'HEURISTICS_IOS_FOREGROUND_COLOR_AST', message: 'AST heuristic detected foregroundColor usage.' },
+  { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftCornerRadiusUsage, ruleId: 'heuristics.ios.corner-radius.ast', code: 'HEURISTICS_IOS_CORNER_RADIUS_AST', message: 'AST heuristic detected cornerRadius usage.' },
+  { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftTabItemUsage, ruleId: 'heuristics.ios.tab-item.ast', code: 'HEURISTICS_IOS_TAB_ITEM_AST', message: 'AST heuristic detected tabItem usage.' },
   { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftOnTapGestureUsage, ruleId: 'heuristics.ios.on-tap-gesture.ast', code: 'HEURISTICS_IOS_ON_TAP_GESTURE_AST', message: 'AST heuristic detected onTapGesture usage where Button may be preferred.' },
   { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftStringFormatUsage, ruleId: 'heuristics.ios.string-format.ast', code: 'HEURISTICS_IOS_STRING_FORMAT_AST', message: 'AST heuristic detected String(format:) usage.' },
+  { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftScrollViewShowsIndicatorsUsage, ruleId: 'heuristics.ios.scrollview-shows-indicators.ast', code: 'HEURISTICS_IOS_SCROLLVIEW_SHOWS_INDICATORS_AST', message: 'AST heuristic detected ScrollView(showsIndicators: false) usage.' },
   { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftUIScreenMainBoundsUsage, ruleId: 'heuristics.ios.uiscreen-main-bounds.ast', code: 'HEURISTICS_IOS_UISCREEN_MAIN_BOUNDS_AST', message: 'AST heuristic detected UIScreen.main.bounds usage.' },
+  { platform: 'ios', pathCheck: isIOSSwiftTestPath, excludePaths: [], detect: TextIOS.hasSwiftLegacyXCTestImportUsage, ruleId: 'heuristics.ios.testing.xctest-import.ast', code: 'HEURISTICS_IOS_TESTING_XCTEST_IMPORT_AST', message: 'AST heuristic detected XCTest-only test usage where Swift Testing may be preferred.' },
+  { platform: 'ios', pathCheck: isIOSSwiftTestPath, excludePaths: [], detect: TextIOS.hasSwiftXCTestAssertionUsage, ruleId: 'heuristics.ios.testing.xctassert.ast', code: 'HEURISTICS_IOS_TESTING_XCTASSERT_AST', message: 'AST heuristic detected XCTest assertion usage where #expect may be preferred.' },
+  { platform: 'ios', pathCheck: isIOSSwiftTestPath, excludePaths: [], detect: TextIOS.hasSwiftXCTUnwrapUsage, ruleId: 'heuristics.ios.testing.xctunwrap.ast', code: 'HEURISTICS_IOS_TESTING_XCTUNWRAP_AST', message: 'AST heuristic detected XCTUnwrap usage where #require may be preferred.' },
+  { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftNSManagedObjectBoundaryUsage, ruleId: 'heuristics.ios.core-data.nsmanagedobject-boundary.ast', code: 'HEURISTICS_IOS_CORE_DATA_NSMANAGEDOBJECT_BOUNDARY_AST', message: 'AST heuristic detected NSManagedObject in a shared boundary.' },
+  { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftNSManagedObjectAsyncBoundaryUsage, ruleId: 'heuristics.ios.core-data.nsmanagedobject-async-boundary.ast', code: 'HEURISTICS_IOS_CORE_DATA_NSMANAGEDOBJECT_ASYNC_BOUNDARY_AST', message: 'AST heuristic detected NSManagedObject in an async boundary.' },
 
   // Android
   { platform: 'android', pathCheck: isAndroidKotlinPath, excludePaths: [isKotlinTestPath], detect: TextAndroid.hasKotlinThreadSleepCall, ruleId: 'heuristics.android.thread-sleep.ast', code: 'HEURISTICS_ANDROID_THREAD_SLEEP_AST', message: 'AST heuristic detected Thread.sleep usage in production Kotlin code.' },
@@ -671,7 +684,7 @@ export const extractHeuristicFacts = (
       if (
         platformDetected &&
         entry.pathCheck(fileFact.path) &&
-        entry.excludePaths.every((exclude) => !exclude(fileFact.path)) &&
+        (entry.excludePaths ?? []).every((exclude) => !exclude(fileFact.path)) &&
         entry.detect(fileFact.content)
       ) {
         heuristicFacts.push(

package/core/gate/GateStage.test.ts

@@ -2,21 +2,23 @@ import assert from 'node:assert/strict';
 import test from 'node:test';
 import type { GateStage } from './GateStage';
 
-test('GateStage soporta STAGED, PRE_COMMIT, PRE_PUSH y CI', () => {
+test('GateStage soporta STAGED, PRE_WRITE, PRE_COMMIT, PRE_PUSH y CI', () => {
   const staged: GateStage = 'STAGED';
+  const preWrite: GateStage = 'PRE_WRITE';
   const preCommit: GateStage = 'PRE_COMMIT';
   const prePush: GateStage = 'PRE_PUSH';
   const ci: GateStage = 'CI';
 
   assert.equal(staged, 'STAGED');
+  assert.equal(preWrite, 'PRE_WRITE');
   assert.equal(preCommit, 'PRE_COMMIT');
   assert.equal(prePush, 'PRE_PUSH');
   assert.equal(ci, 'CI');
 });
 
 test('GateStage permite colecciones tipadas de stages', () => {
-  const stages: GateStage[] = ['STAGED', 'PRE_COMMIT', 'PRE_PUSH', 'CI'];
+  const stages: GateStage[] = ['STAGED', 'PRE_WRITE', 'PRE_COMMIT', 'PRE_PUSH', 'CI'];
 
-  assert.equal(stages.length, 4);
-  assert.deepEqual(stages, ['STAGED', 'PRE_COMMIT', 'PRE_PUSH', 'CI']);
+  assert.equal(stages.length, 5);
+  assert.deepEqual(stages, ['STAGED', 'PRE_WRITE', 'PRE_COMMIT', 'PRE_PUSH', 'CI']);
 });

package/core/gate/GateStage.ts

@@ -1 +1,6 @@
-export type GateStage = 'STAGED' | 'PRE_COMMIT' | 'PRE_PUSH' | 'CI';
+export type GateStage =
+  | 'STAGED'
+  | 'PRE_WRITE'
+  | 'PRE_COMMIT'
+  | 'PRE_PUSH'
+  | 'CI';

package/core/rules/presets/heuristics/ios.test.ts

@@ -3,7 +3,7 @@ import test from 'node:test';
 import { iosRules } from './ios';
 
 test('iosRules define reglas heurísticas locked para plataforma ios', () => {
-  assert.equal(iosRules.length, 16);
+  assert.equal(iosRules.length, 25);
 
   const ids = iosRules.map((rule) => rule.id);
   assert.deepEqual(ids, [
@@ -20,9 +20,18 @@ test('iosRules define reglas heurísticas locked para plataforma ios', () => {
     'heuristics.ios.unchecked-sendable.ast',
     'heuristics.ios.observable-object.ast',
     'heuristics.ios.navigation-view.ast',
+    'heuristics.ios.foreground-color.ast',
+    'heuristics.ios.corner-radius.ast',
+    'heuristics.ios.tab-item.ast',
     'heuristics.ios.on-tap-gesture.ast',
     'heuristics.ios.string-format.ast',
+    'heuristics.ios.scrollview-shows-indicators.ast',
     'heuristics.ios.uiscreen-main-bounds.ast',
+    'heuristics.ios.testing.xctest-import.ast',
+    'heuristics.ios.testing.xctassert.ast',
+    'heuristics.ios.testing.xctunwrap.ast',
+    'heuristics.ios.core-data.nsmanagedobject-boundary.ast',
+    'heuristics.ios.core-data.nsmanagedobject-async-boundary.ast',
   ]);
 
   const byId = new Map(iosRules.map((rule) => [rule.id, rule]));
@@ -38,6 +47,18 @@ test('iosRules define reglas heurísticas locked para plataforma ios', () => {
     byId.get('heuristics.ios.uiscreen-main-bounds.ast')?.then.code,
     'HEURISTICS_IOS_UISCREEN_MAIN_BOUNDS_AST'
   );
+  assert.equal(
+    byId.get('heuristics.ios.foreground-color.ast')?.then.code,
+    'HEURISTICS_IOS_FOREGROUND_COLOR_AST'
+  );
+  assert.equal(
+    byId.get('heuristics.ios.testing.xctassert.ast')?.then.code,
+    'HEURISTICS_IOS_TESTING_XCTASSERT_AST'
+  );
+  assert.equal(
+    byId.get('heuristics.ios.core-data.nsmanagedobject-async-boundary.ast')?.then.code,
+    'HEURISTICS_IOS_CORE_DATA_NSMANAGEDOBJECT_ASYNC_BOUNDARY_AST'
+  );
 
   for (const rule of iosRules) {
     assert.equal(rule.platform, 'ios');