pumuki 6.3.308 → 6.3.310

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

@@ -58,6 +58,16 @@ import {
   hasSwiftStrictConcurrencyBelowCompleteUsage,
   collectSwiftDefaultActorIsolationNotMainActorLines,
   hasSwiftDefaultActorIsolationNotMainActorUsage,
+  collectSwiftUpcomingFeatureDisabledLines,
+  hasSwiftUpcomingFeatureDisabledUsage,
+  collectSwiftUiStateWithoutMainActorLines,
+  hasSwiftUiStateWithoutMainActorUsage,
+  collectSwiftSharedMutableStateWithoutActorLines,
+  hasSwiftSharedMutableStateWithoutActorUsage,
+  collectSwiftMainActorRunPatchLines,
+  hasSwiftMainActorRunPatchUsage,
+  collectSwiftNavigationPathWithoutRestorationLines,
+  hasSwiftNavigationPathWithoutRestorationUsage,
   hasSwiftForEachIndicesUsage,
   hasSwiftForEachSelfIdentityUsage,
   collectSwiftForceCastLines,
@@ -884,6 +894,158 @@ buildSettings = {
   assert.deepEqual(collectSwiftDefaultActorIsolationNotMainActorLines(safe), []);
 });
 
+test('hasSwiftUpcomingFeatureDisabledUsage detecta upcoming features Swift desactivadas', () => {
+  const source = `
+buildSettings = {
+  SWIFT_UPCOMING_FEATURE_CONCISE_MAGIC_FILE = NO;
+  SWIFT_UPCOMING_FEATURE_FORWARD_TRAILING_CLOSURES = 0;
+  SWIFT_ENABLE_EXPERIMENTAL_FEATURES = ;
+};
+`;
+  const safe = `
+buildSettings = {
+  SWIFT_UPCOMING_FEATURE_CONCISE_MAGIC_FILE = YES;
+  SWIFT_UPCOMING_FEATURE_FORWARD_TRAILING_CLOSURES = true;
+  SWIFT_ENABLE_EXPERIMENTAL_FEATURES = StrictConcurrency;
+  let sample = "SWIFT_UPCOMING_FEATURE_CONCISE_MAGIC_FILE = NO;"
+  // SWIFT_ENABLE_EXPERIMENTAL_FEATURES = ;
+};
+`;
+
+  assert.equal(hasSwiftUpcomingFeatureDisabledUsage(source), true);
+  assert.deepEqual(collectSwiftUpcomingFeatureDisabledLines(source), [3, 4, 5]);
+  assert.equal(hasSwiftUpcomingFeatureDisabledUsage(safe), false);
+  assert.deepEqual(collectSwiftUpcomingFeatureDisabledLines(safe), []);
+});
+
+test('hasSwiftUiStateWithoutMainActorUsage detecta estado UI observable sin MainActor', () => {
+  const source = `
+final class BuyerAuthViewModel: ObservableObject {
+  @Published var title = "Login"
+}
+struct BuyerSessionStore {
+  var token: String?
+}
+`;
+  const safe = `
+@MainActor
+@Observable
+final class BuyerAuthViewModel {
+  var title = "Login"
+}
+final class BackgroundStore {
+  let cache = NSCache<NSString, NSString>()
+}
+let sample = "final class FakeViewModel: ObservableObject"
+// final class CommentedViewModel: ObservableObject {}
+`;
+
+  assert.equal(hasSwiftUiStateWithoutMainActorUsage(source), true);
+  assert.deepEqual(collectSwiftUiStateWithoutMainActorLines(source), [2]);
+  assert.equal(hasSwiftUiStateWithoutMainActorUsage(safe), false);
+  assert.deepEqual(collectSwiftUiStateWithoutMainActorLines(safe), []);
+});
+
+test('hasSwiftSharedMutableStateWithoutActorUsage detecta estado compartido mutable sin actor', () => {
+  const source = `
+final class UserSessionManager {
+  private var token: String?
+
+  func update(token: String) {
+    self.token = token
+  }
+}
+`;
+  const safe = `
+actor UserSessionManager {
+  private var token: String?
+
+  func update(token: String) {
+    self.token = token
+  }
+}
+@MainActor
+final class BuyerSessionStore {
+  private var route: String?
+  func update(route: String) { self.route = route }
+}
+final class ValueFormatter {
+  func title() -> String { "OK" }
+}
+let sample = "final class TokenCache { var token: String? }"
+// final class CommentedCache { var value = "" }
+`;
+
+  assert.equal(hasSwiftSharedMutableStateWithoutActorUsage(source), true);
+  assert.deepEqual(collectSwiftSharedMutableStateWithoutActorLines(source), [2]);
+  assert.equal(hasSwiftSharedMutableStateWithoutActorUsage(safe), false);
+  assert.deepEqual(collectSwiftSharedMutableStateWithoutActorLines(safe), []);
+});
+
+test('hasSwiftMainActorRunPatchUsage detecta MainActor.run como parche en owners no aislados', () => {
+  const source = `
+final class BuyerAuthViewModel {
+  func load() async {
+    await MainActor.run {
+      self.title = "Ready"
+    }
+  }
+}
+`;
+  const safe = `
+@MainActor
+final class BuyerAuthViewModel {
+  func load() async {
+    await MainActor.run { self.title = "Ready" }
+  }
+}
+actor BuyerSessionManager {
+  func load() async {
+    await MainActor.run { print("bridge") }
+  }
+}
+func bridgeToUi() async {
+  await MainActor.run { print("approved explicit boundary") }
+}
+let sample = "MainActor.run { value = 1 }"
+// await MainActor.run { value = 2 }
+`;
+
+  assert.equal(hasSwiftMainActorRunPatchUsage(source), true);
+  assert.deepEqual(collectSwiftMainActorRunPatchLines(source), [4]);
+  assert.equal(hasSwiftMainActorRunPatchUsage(safe), false);
+  assert.deepEqual(collectSwiftMainActorRunPatchLines(safe), []);
+});
+
+test('hasSwiftNavigationPathWithoutRestorationUsage detecta NavigationPath sin restauracion', () => {
+  const source = `
+struct ShellView: View {
+  @State private var path = NavigationPath()
+
+  var body: some View {
+    NavigationStack(path: $path) { EmptyView() }
+  }
+}
+`;
+  const safe = `
+struct ShellView: View {
+  @SceneStorage("navigation.path") private var encodedPath = Data()
+  @State private var path = NavigationPath()
+
+  func restoreNavigationPath() {
+    _ = path.codable
+  }
+}
+let sample = "NavigationPath()"
+// let ignored = NavigationPath()
+`;
+
+  assert.equal(hasSwiftNavigationPathWithoutRestorationUsage(source), true);
+  assert.deepEqual(collectSwiftNavigationPathWithoutRestorationLines(source), [3]);
+  assert.equal(hasSwiftNavigationPathWithoutRestorationUsage(safe), false);
+  assert.deepEqual(collectSwiftNavigationPathWithoutRestorationLines(safe), []);
+});
+
 test('hasSwiftNonLazyScrollForEachUsage detecta ScrollView con stack no lazy y preserva LazyVStack', () => {
   const source = `
 struct FeedView: View {

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

@@ -1142,6 +1142,244 @@ export const hasSwiftDefaultActorIsolationNotMainActorUsage = (source: string):
   return collectSwiftDefaultActorIsolationNotMainActorLines(source).length > 0;
 };
 
+export const collectSwiftUpcomingFeatureDisabledLines = (source: string): readonly number[] => {
+  const lines: number[] = [];
+
+  source.split(/\r?\n/).forEach((rawLine, index) => {
+    const line = stripSwiftLineForSemanticScan(rawLine);
+    const upcomingFeatureMatch =
+      /\bSWIFT_UPCOMING_FEATURE_[A-Za-z0-9_]+\s*=\s*([A-Za-z0-9_]+)\s*;?/.exec(line);
+    if (upcomingFeatureMatch) {
+      const value = (upcomingFeatureMatch[1] ?? '').trim().toLowerCase();
+      if (value === 'no' || value === 'false' || value === '0') {
+        lines.push(index + 1);
+      }
+      return;
+    }
+
+    const experimentalFeaturesMatch =
+      /\bSWIFT_ENABLE_EXPERIMENTAL_FEATURES\s*=\s*(.*?)\s*;?$/.exec(line);
+    if (!experimentalFeaturesMatch) {
+      return;
+    }
+
+    const value = (experimentalFeaturesMatch[1] ?? '').trim().toLowerCase();
+    if (value === '' || value === 'no' || value === 'false' || value === '0') {
+      lines.push(index + 1);
+    }
+  });
+
+  return sortedUniqueLines(lines);
+};
+
+export const hasSwiftUpcomingFeatureDisabledUsage = (source: string): boolean => {
+  return collectSwiftUpcomingFeatureDisabledLines(source).length > 0;
+};
+
+const swiftUiStateOwnerDeclarationPattern =
+  /\b(?:final\s+)?(?:class|struct)\s+([A-Za-z_][A-Za-z0-9_]*(?:ViewModel|Presenter|Store))\b/;
+
+const hasSwiftMainActorAnnotationNear = (
+  lines: readonly string[],
+  declarationIndex: number
+): boolean => {
+  const start = Math.max(0, declarationIndex - 3);
+  const context = lines
+    .slice(start, declarationIndex + 1)
+    .map((line) => stripSwiftLineForSemanticScan(line))
+    .join('\n');
+  return /@MainActor\b/.test(context);
+};
+
+const hasSwiftObservableUiStateEvidence = (
+  lines: readonly string[],
+  declarationIndex: number
+): boolean => {
+  const annotationStart = Math.max(0, declarationIndex - 2);
+  const end = Math.min(lines.length, declarationIndex + 60);
+  const annotationContext = lines
+    .slice(annotationStart, declarationIndex + 1)
+    .map((line) => stripSwiftLineForSemanticScan(line))
+    .join('\n');
+  const bodyContext = lines
+    .slice(declarationIndex, end)
+    .map((line) => stripSwiftLineForSemanticScan(line))
+    .join('\n');
+
+  return (
+    /@Observable\b/.test(annotationContext) ||
+    /\bObservableObject\b/.test(bodyContext) ||
+    /@Published\b/.test(bodyContext)
+  );
+};
+
+export const collectSwiftUiStateWithoutMainActorLines = (source: string): readonly number[] => {
+  const matches: number[] = [];
+  const lines = source.split(/\r?\n/);
+
+  lines.forEach((rawLine, index) => {
+    const line = stripSwiftLineForSemanticScan(rawLine);
+    if (!swiftUiStateOwnerDeclarationPattern.test(line)) {
+      return;
+    }
+    if (hasSwiftMainActorAnnotationNear(lines, index)) {
+      return;
+    }
+    if (!hasSwiftObservableUiStateEvidence(lines, index)) {
+      return;
+    }
+    matches.push(index + 1);
+  });
+
+  return sortedUniqueLines(matches);
+};
+
+export const hasSwiftUiStateWithoutMainActorUsage = (source: string): boolean => {
+  return collectSwiftUiStateWithoutMainActorLines(source).length > 0;
+};
+
+const swiftSharedStateOwnerDeclarationPattern =
+  /\b(?:final\s+)?class\s+([A-Za-z_][A-Za-z0-9_]*(?:Cache|Manager|Session|Store|Repository))\b/;
+
+const findSwiftDeclarationBlockEnd = (lines: readonly string[], declarationIndex: number): number => {
+  let depth = 0;
+  let started = false;
+
+  for (let index = declarationIndex; index < lines.length; index += 1) {
+    const line = stripSwiftLineForSemanticScan(lines[index] ?? '');
+    for (const char of line) {
+      if (char === '{') {
+        depth += 1;
+        started = true;
+      } else if (char === '}') {
+        depth -= 1;
+        if (started && depth <= 0) {
+          return index + 1;
+        }
+      }
+    }
+  }
+
+  return Math.min(lines.length, declarationIndex + 80);
+};
+
+const hasSwiftSharedMutableStateBody = (body: string): boolean => {
+  return (
+    /\b(?:private\s+|fileprivate\s+|internal\s+|public\s+|open\s+)?var\s+[A-Za-z_][A-Za-z0-9_]*\b/.test(
+      body
+    ) &&
+    /\bfunc\s+[A-Za-z_][A-Za-z0-9_]*\s*\(/.test(body) &&
+    !/@(?:Observable|Published)\b/.test(body) &&
+    !/\bObservableObject\b/.test(body)
+  );
+};
+
+export const collectSwiftSharedMutableStateWithoutActorLines = (
+  source: string
+): readonly number[] => {
+  const matches: number[] = [];
+  const lines = source.split(/\r?\n/);
+
+  lines.forEach((rawLine, index) => {
+    const line = stripSwiftLineForSemanticScan(rawLine);
+    if (!swiftSharedStateOwnerDeclarationPattern.test(line)) {
+      return;
+    }
+    if (hasSwiftMainActorAnnotationNear(lines, index)) {
+      return;
+    }
+
+    const blockEnd = findSwiftDeclarationBlockEnd(lines, index);
+    const body = lines
+      .slice(index, blockEnd)
+      .map((candidate) => stripSwiftLineForSemanticScan(candidate))
+      .join('\n');
+
+    if (!hasSwiftSharedMutableStateBody(body)) {
+      return;
+    }
+
+    matches.push(index + 1);
+  });
+
+  return sortedUniqueLines(matches);
+};
+
+export const hasSwiftSharedMutableStateWithoutActorUsage = (source: string): boolean => {
+  return collectSwiftSharedMutableStateWithoutActorLines(source).length > 0;
+};
+
+const swiftActorPatchOwnerDeclarationPattern =
+  /\b(?:final\s+)?(?:class|struct)\s+([A-Za-z_][A-Za-z0-9_]*(?:ViewModel|Presenter|Store|Manager))\b/;
+
+const findNearestSwiftActorPatchOwnerIndex = (
+  lines: readonly string[],
+  usageIndex: number
+): number | undefined => {
+  const start = Math.max(0, usageIndex - 80);
+  for (let index = usageIndex; index >= start; index -= 1) {
+    const line = stripSwiftLineForSemanticScan(lines[index] ?? '');
+    if (swiftActorPatchOwnerDeclarationPattern.test(line)) {
+      return index;
+    }
+    if (/^\s*(?:actor|enum|protocol)\s+[A-Za-z_][A-Za-z0-9_]*\b/.test(line)) {
+      return undefined;
+    }
+  }
+  return undefined;
+};
+
+export const collectSwiftMainActorRunPatchLines = (source: string): readonly number[] => {
+  const matches: number[] = [];
+  const lines = source.split(/\r?\n/);
+
+  lines.forEach((rawLine, index) => {
+    const line = stripSwiftLineForSemanticScan(rawLine);
+    if (!/\bMainActor\s*\.\s*run\s*(?:\(|\{)/.test(line)) {
+      return;
+    }
+
+    const ownerIndex = findNearestSwiftActorPatchOwnerIndex(lines, index);
+    if (ownerIndex === undefined) {
+      return;
+    }
+    if (hasSwiftMainActorAnnotationNear(lines, ownerIndex)) {
+      return;
+    }
+
+    matches.push(index + 1);
+  });
+
+  return sortedUniqueLines(matches);
+};
+
+export const hasSwiftMainActorRunPatchUsage = (source: string): boolean => {
+  return collectSwiftMainActorRunPatchLines(source).length > 0;
+};
+
+const swiftNavigationPathRestorationPattern =
+  /@(?:SceneStorage|AppStorage)\b|\bCodableRepresentation\b|\.codable\b|\b(?:restore|rehydrate|persist|save|load)[A-Za-z0-9_]*(?:Navigation)?Path\b/i;
+
+export const collectSwiftNavigationPathWithoutRestorationLines = (
+  source: string
+): readonly number[] => {
+  const lines = collectSwiftRegexLines(source, /\bNavigationPath\s*\(/);
+  if (lines.length === 0) {
+    return [];
+  }
+
+  const sanitized = sanitizeSwiftSourceForMultilineRegex(source);
+  if (swiftNavigationPathRestorationPattern.test(sanitized)) {
+    return [];
+  }
+
+  return sortedUniqueLines(lines);
+};
+
+export const hasSwiftNavigationPathWithoutRestorationUsage = (source: string): boolean => {
+  return collectSwiftNavigationPathWithoutRestorationLines(source).length > 0;
+};
+
 export const hasSwiftOnAppearTaskUsage = (source: string): boolean => {
   return collectSwiftOnAppearTaskLines(source).length > 0;
 };

package/core/facts/extractHeuristicFacts.ts

@@ -758,6 +758,10 @@ const textDetectorRegistry: ReadonlyArray<TextDetectorRegistryEntry> = [
   { platform: 'ios', pathCheck: isIOSSwiftPackageManifestPath, excludePaths: [], detect: TextIOS.hasSwiftPackageStrictConcurrencyBelowCompleteUsage, locateLines: TextIOS.collectSwiftPackageStrictConcurrencyBelowCompleteLines, primaryNode: (lines) => ({ kind: 'call', name: 'SwiftPM StrictConcurrency below complete', lines }), relatedNodes: (lines) => [{ kind: 'call', name: 'replacement: complete strict concurrency baseline', lines }], why: 'SwiftPM strict concurrency settings below complete can leave sendability and actor diagnostics unenforced in iOS packages.', impact: 'Minimal or targeted strict concurrency in Package.swift weakens the same safety baseline that Xcode build settings must enforce.', expected_fix: 'Remove targeted/minimal StrictConcurrency overrides and run the package under the complete Swift concurrency baseline expected by the repo.', ruleId: 'heuristics.ios.concurrency.swiftpm-strict-concurrency-below-complete.ast', code: 'HEURISTICS_IOS_CONCURRENCY_SWIFTPM_STRICT_CONCURRENCY_BELOW_COMPLETE_AST', message: 'AST heuristic detected Package.swift StrictConcurrency below complete.' },
   { platform: 'ios', pathCheck: isIOSXcodeProjectFilePath, excludePaths: [], detect: TextIOS.hasSwiftStrictConcurrencyBelowCompleteUsage, locateLines: TextIOS.collectSwiftStrictConcurrencyBelowCompleteLines, primaryNode: (lines) => ({ kind: 'property', name: 'SWIFT_STRICT_CONCURRENCY below complete', lines }), relatedNodes: (lines) => [{ kind: 'property', name: 'replacement: SWIFT_STRICT_CONCURRENCY = complete', lines }], why: 'The iOS skill contract requires Complete strict concurrency checking so unsafe actor/sendability issues cannot pass silently.', impact: 'Minimal or targeted strict concurrency leaves parts of the module below the Swift concurrency safety baseline and can hide data-race warnings.', expected_fix: 'Set SWIFT_STRICT_CONCURRENCY = complete for the affected iOS build configuration after addressing surfaced warnings.', ruleId: 'heuristics.ios.concurrency.strict-concurrency-below-complete.ast', code: 'HEURISTICS_IOS_CONCURRENCY_STRICT_CONCURRENCY_BELOW_COMPLETE_AST', message: 'AST heuristic detected SWIFT_STRICT_CONCURRENCY below complete in an iOS Xcode project.' },
   { platform: 'ios', pathCheck: isIOSXcodeProjectFilePath, excludePaths: [], detect: TextIOS.hasSwiftDefaultActorIsolationNotMainActorUsage, locateLines: TextIOS.collectSwiftDefaultActorIsolationNotMainActorLines, primaryNode: (lines) => ({ kind: 'property', name: 'SWIFT_DEFAULT_ACTOR_ISOLATION not MainActor', lines }), relatedNodes: (lines) => [{ kind: 'property', name: 'replacement: SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor', lines }], why: 'The iOS concurrency skill requires projects to validate default actor isolation instead of leaving UI-heavy code under an unsafe or ambiguous isolation baseline.', impact: 'A non-MainActor default isolation can let SwiftUI and presentation state cross actor boundaries without the project-wide protection expected by the skills contract.', expected_fix: 'Set SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor for the affected iOS build configuration, or isolate exceptional modules explicitly with documented actor boundaries.', ruleId: 'heuristics.ios.concurrency.default-actor-isolation-not-mainactor.ast', code: 'HEURISTICS_IOS_CONCURRENCY_DEFAULT_ACTOR_ISOLATION_NOT_MAINACTOR_AST', message: 'AST heuristic detected SWIFT_DEFAULT_ACTOR_ISOLATION not set to MainActor in an iOS Xcode project.' },
+  { platform: 'ios', pathCheck: isIOSXcodeProjectFilePath, excludePaths: [], detect: TextIOS.hasSwiftUpcomingFeatureDisabledUsage, locateLines: TextIOS.collectSwiftUpcomingFeatureDisabledLines, primaryNode: (lines) => ({ kind: 'property', name: 'SWIFT_UPCOMING_FEATURE disabled or experimental features empty', lines }), relatedNodes: (lines) => [{ kind: 'property', name: 'replacement: enable required Swift upcoming features explicitly', lines }], why: 'The iOS Swift 6.2 skill requires validating SWIFT_UPCOMING_FEATURE_* and experimental feature settings instead of leaving required language diagnostics disabled.', impact: 'Disabled upcoming features let modules compile below the reviewed Swift language baseline, hiding migration and concurrency diagnostics that the gate expects to enforce.', expected_fix: 'Enable the required SWIFT_UPCOMING_FEATURE_* setting with YES/true and keep SWIFT_ENABLE_EXPERIMENTAL_FEATURES populated only with approved Swift feature names; remove explicit NO/0/false overrides.', ruleId: 'heuristics.ios.concurrency.upcoming-feature-disabled.ast', code: 'HEURISTICS_IOS_CONCURRENCY_UPCOMING_FEATURE_DISABLED_AST', message: 'AST heuristic detected disabled Swift upcoming feature settings in an iOS Xcode project.' },
+  { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftUiStateWithoutMainActorUsage, locateLines: TextIOS.collectSwiftUiStateWithoutMainActorLines, primaryNode: (lines) => ({ kind: 'class', name: 'observable UI state owner without MainActor', lines }), relatedNodes: (lines) => [{ kind: 'property', name: 'replacement: @MainActor isolated ViewModel/Presenter/Store', lines }], why: 'The iOS concurrency skill requires UI-facing state owners to be isolated on MainActor instead of relying on implicit thread discipline.', impact: 'Observable presentation state without MainActor can be mutated from background executors, causing SwiftUI updates off the main actor and nondeterministic UI behavior.', expected_fix: 'Annotate the ViewModel/Presenter/Store with @MainActor, or move non-UI shared state behind an explicit actor boundary and keep UI adapters MainActor-isolated.', ruleId: 'heuristics.ios.concurrency.ui-state-without-mainactor.ast', code: 'HEURISTICS_IOS_CONCURRENCY_UI_STATE_WITHOUT_MAINACTOR_AST', message: 'AST heuristic detected observable iOS UI state without @MainActor isolation.' },
+  { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftSharedMutableStateWithoutActorUsage, locateLines: TextIOS.collectSwiftSharedMutableStateWithoutActorLines, primaryNode: (lines) => ({ kind: 'class', name: 'mutable shared state owner without actor isolation', lines }), relatedNodes: (lines) => [{ kind: 'class', name: 'replacement: actor or explicit MainActor boundary', lines }], why: 'The iOS concurrency skill requires shared mutable state to be protected by actor isolation or an explicit main-actor boundary.', impact: 'Mutable Store/Cache/Manager/Session classes can be accessed from multiple tasks without serialization, creating data races and nondeterministic state transitions.', expected_fix: 'Convert the shared mutable owner to an actor, isolate the UI-facing owner with @MainActor, or move mutable state behind a documented actor boundary.', ruleId: 'heuristics.ios.concurrency.shared-mutable-state-without-actor.ast', code: 'HEURISTICS_IOS_CONCURRENCY_SHARED_MUTABLE_STATE_WITHOUT_ACTOR_AST', message: 'AST heuristic detected shared mutable iOS state without actor isolation.' },
+  { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftMainActorRunPatchUsage, locateLines: TextIOS.collectSwiftMainActorRunPatchLines, primaryNode: (lines) => ({ kind: 'call', name: 'MainActor.run patch inside non-isolated owner', lines }), relatedNodes: (lines) => [{ kind: 'class', name: 'replacement: justified @MainActor/actor isolation boundary', lines }], why: 'The Swift concurrency skill forbids using MainActor as a blanket patch instead of modelling the real isolation boundary.', impact: 'Scattered MainActor.run calls inside non-isolated ViewModel/Store/Manager types hide ownership and allow the rest of the type to remain callable from background executors.', expected_fix: 'Move the owner to @MainActor when it owns UI state, move shared mutable state to an actor, or isolate the exact boundary with a documented adapter instead of sprinkling MainActor.run patches.', ruleId: 'heuristics.ios.concurrency.mainactor-run-patch.ast', code: 'HEURISTICS_IOS_CONCURRENCY_MAINACTOR_RUN_PATCH_AST', message: 'AST heuristic detected MainActor.run used as an isolation patch in iOS production code.' },
   { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftNonPascalCaseTypeDeclarationUsage, locateLines: TextIOS.collectSwiftNonPascalCaseTypeDeclarationLines, primaryNode: (lines) => ({ kind: 'class', name: 'Swift type declaration without PascalCase', lines }), relatedNodes: (lines) => [{ kind: 'class', name: 'replacement: PascalCase type name', lines }], why: 'Swift type declarations should use PascalCase so public and internal APIs remain idiomatic, searchable and reviewable.', impact: 'Non-PascalCase type names make ownership boundaries less consistent and weaken automated remediation because the gate cannot rely on the declaration node name.', expected_fix: 'Rename the Swift class, struct, enum, actor or protocol declaration to PascalCase and update its references in the same slice.', ruleId: 'heuristics.ios.naming.non-pascal-case-type.ast', code: 'HEURISTICS_IOS_NAMING_NON_PASCAL_CASE_TYPE_AST', message: 'AST heuristic detected Swift type declaration without PascalCase.' },
   { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftCrossFeatureImportUsage, locateLines: TextIOS.collectSwiftCrossFeatureImportLines, primaryNode: (lines) => ({ kind: 'member', name: 'cross-feature Swift import', lines }), relatedNodes: (lines) => [{ kind: 'member', name: 'replacement: SharedKernel / routing contract / local feature boundary', lines }], why: 'Feature-first iOS modules must not import sibling features directly; bounded contexts communicate through shared kernel contracts, navigation routes or application-level orchestration.', impact: 'A direct feature-to-feature import couples release cadence, state ownership and navigation behavior across bounded contexts, making product slices harder to isolate and review.', expected_fix: 'Move the shared type to SharedKernel, expose a narrow route/command contract, or orchestrate the collaboration from an application/root layer instead of importing a sibling feature.', ruleId: 'heuristics.ios.architecture.cross-feature-import.ast', code: 'HEURISTICS_IOS_ARCHITECTURE_CROSS_FEATURE_IMPORT_AST', message: 'AST heuristic detected a Swift feature importing another feature module directly.' },
   { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftLayerDirectionViolationUsage, locateLines: TextIOS.collectSwiftLayerDirectionViolationLines, primaryNode: (lines) => ({ kind: 'member', name: 'forbidden import for Clean Architecture layer', lines }), relatedNodes: (lines) => [{ kind: 'member', name: 'replacement: move dependency to allowed layer or depend on protocol/value object', lines }], why: 'Clean Architecture iOS layers must point inward: Domain cannot import UI, persistence or concrete networking frameworks; Application cannot import UI or concrete infrastructure; Presentation cannot import persistence/network implementation frameworks directly.', impact: 'Layer direction violations make feature slices depend on concrete frameworks instead of domain/application contracts, increasing coupling and making remediation unsafe across bounded contexts.', expected_fix: 'Move framework-specific code to Infrastructure or Presentation as appropriate, expose a narrow protocol/value object in Domain/Application, and inject the implementation from the composition root.', ruleId: 'heuristics.ios.architecture.layer-direction-violation.ast', code: 'HEURISTICS_IOS_ARCHITECTURE_LAYER_DIRECTION_VIOLATION_AST', message: 'AST heuristic detected an import that violates Clean Architecture layer direction in iOS code.' },
@@ -855,6 +859,7 @@ const textDetectorRegistry: ReadonlyArray<TextDetectorRegistryEntry> = [
   { platform: 'ios', pathCheck: isIOSPresentationPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftAnimationWithoutReduceMotionUsage, locateLines: TextIOS.collectSwiftAnimationWithoutReduceMotionLines, primaryNode: (lines) => ({ kind: 'call', name: 'SwiftUI animation without reduce motion guard', lines }), relatedNodes: (lines) => [{ kind: 'property', name: 'replacement: accessibilityReduceMotion / UIAccessibility.isReduceMotionEnabled', lines }], why: 'SwiftUI animations must respect the system reduce motion preference.', impact: 'Users who reduce motion can still receive animated transitions, making the UI less accessible.', expected_fix: 'Read @Environment(\\.accessibilityReduceMotion) or UIAccessibility.isReduceMotionEnabled and disable or replace animations when reduce motion is enabled.', ruleId: 'heuristics.ios.accessibility.animation-without-reduce-motion.ast', code: 'HEURISTICS_IOS_ACCESSIBILITY_ANIMATION_WITHOUT_REDUCE_MOTION_AST', message: 'AST heuristic detected SwiftUI animation without reduce motion handling.' },
   { platform: 'ios', pathCheck: isIOSPresentationPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftUiInlineActionLogicUsage, locateLines: TextIOS.collectSwiftUiInlineActionLogicLines, primaryNode: (lines) => ({ kind: 'call', name: 'SwiftUI Button action with inline logic', lines }), relatedNodes: (lines) => [{ kind: 'call', name: 'replacement: extracted action method', lines }], why: 'Inline branching or async work in a SwiftUI action makes the view declaration own behavior instead of delegating to a named action.', impact: 'Reviewers and agents cannot remediate a blocked view safely when the finding lacks the exact Button action node.', expected_fix: 'Extract the action body to a named method or view model command and reference that method from Button.', ruleId: 'heuristics.ios.swiftui.inline-action-logic.ast', code: 'HEURISTICS_IOS_SWIFTUI_INLINE_ACTION_LOGIC_AST', message: 'AST heuristic detected inline logic inside a SwiftUI action handler; action handlers should reference methods and keep view declarations focused.' },
   { 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.hasSwiftNavigationPathWithoutRestorationUsage, locateLines: TextIOS.collectSwiftNavigationPathWithoutRestorationLines, primaryNode: (lines) => ({ kind: 'property', name: 'NavigationPath state without restoration contract', lines }), relatedNodes: (lines) => [{ kind: 'property', name: 'replacement: persisted/rehydrated NavigationPath codable state', lines }], why: 'The iOS navigation skill requires NavigationPath state to be restorable when the app owns path-based navigation.', impact: 'A raw NavigationPath() without restoration loses deep-link and navigation state across process death, scene restoration or app relaunch, making user journeys non-deterministic.', expected_fix: 'Persist and rehydrate the path through SceneStorage/AppStorage or an approved route-store using NavigationPath.CodableRepresentation, or document why the local path is intentionally ephemeral.', ruleId: 'heuristics.ios.navigation.path-without-restoration.ast', code: 'HEURISTICS_IOS_NAVIGATION_PATH_WITHOUT_RESTORATION_AST', message: 'AST heuristic detected NavigationPath without an explicit restoration contract.' },
   { platform: 'ios', pathCheck: isIOSPresentationPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftUntypedNavigationLinkDestinationUsage, ruleId: 'heuristics.ios.swiftui.untyped-navigation-link-destination.ast', code: 'HEURISTICS_IOS_SWIFTUI_UNTYPED_NAVIGATION_LINK_DESTINATION_AST', message: 'AST heuristic detected untyped NavigationLink destination usage; prefer NavigationLink(value:) with navigationDestination(for:) for type-safe navigation.' },
   { platform: 'ios', pathCheck: isIOSSwiftPath, excludePaths: [isSwiftTestPath], detect: TextIOS.hasSwiftForegroundColorUsage, locateLines: TextIOS.collectSwiftForegroundColorLines, primaryNode: (lines) => ({ kind: 'call', name: 'SwiftUI foregroundColor modifier', lines }), relatedNodes: (lines) => [{ kind: 'call', name: 'replacement: foregroundStyle or design token', lines }], why: 'foregroundColor is a legacy SwiftUI styling API compared with foregroundStyle and tokenized style values.', impact: 'Modernization blockers need the exact modifier line to avoid whole-file refactors.', expected_fix: 'Replace .foregroundColor(...) with .foregroundStyle(...) or the repository-approved design token style.', 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, locateLines: TextIOS.collectSwiftCornerRadiusLines, primaryNode: (lines) => ({ kind: 'call', name: 'SwiftUI cornerRadius modifier', lines }), relatedNodes: (lines) => [{ kind: 'call', name: 'replacement: clipShape with rounded rectangle style', lines }], why: 'cornerRadius is a legacy shape shortcut that hides the shape semantics used by modern SwiftUI styling.', impact: 'The fix is local, but without line evidence the gate forces unsafe file-wide remediation.', expected_fix: 'Replace .cornerRadius(...) with .clipShape(.rect(cornerRadius: ...)) or a named reusable shape/style token.', ruleId: 'heuristics.ios.corner-radius.ast', code: 'HEURISTICS_IOS_CORNER_RADIUS_AST', message: 'AST heuristic detected cornerRadius usage.' },

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, 131);
+  assert.equal(iosRules.length, 136);
 
   const ids = iosRules.map((rule) => rule.id);
   assert.deepEqual(ids, [
@@ -61,6 +61,10 @@ test('iosRules define reglas heurísticas locked para plataforma ios', () => {
     'heuristics.ios.concurrency.swiftpm-strict-concurrency-below-complete.ast',
     'heuristics.ios.concurrency.strict-concurrency-below-complete.ast',
     'heuristics.ios.concurrency.default-actor-isolation-not-mainactor.ast',
+    'heuristics.ios.concurrency.upcoming-feature-disabled.ast',
+    'heuristics.ios.concurrency.ui-state-without-mainactor.ast',
+    'heuristics.ios.concurrency.shared-mutable-state-without-actor.ast',
+    'heuristics.ios.concurrency.mainactor-run-patch.ast',
     'heuristics.ios.naming.non-pascal-case-type.ast',
     'heuristics.ios.uikit.cell-without-reuse.ast',
     'heuristics.ios.security.userdefaults-sensitive-data.ast',
@@ -111,6 +115,7 @@ test('iosRules define reglas heurísticas locked para plataforma ios', () => {
     'heuristics.ios.accessibility.animation-without-reduce-motion.ast',
     'heuristics.ios.swiftui.inline-action-logic.ast',
     'heuristics.ios.navigation-view.ast',
+    'heuristics.ios.navigation.path-without-restoration.ast',
     'heuristics.ios.swiftui.untyped-navigation-link-destination.ast',
     'heuristics.ios.foreground-color.ast',
     'heuristics.ios.corner-radius.ast',
@@ -201,6 +206,22 @@ test('iosRules define reglas heurísticas locked para plataforma ios', () => {
     byId.get('heuristics.ios.concurrency.default-actor-isolation-not-mainactor.ast')?.then.code,
     'HEURISTICS_IOS_CONCURRENCY_DEFAULT_ACTOR_ISOLATION_NOT_MAINACTOR_AST'
   );
+  assert.equal(
+    byId.get('heuristics.ios.concurrency.upcoming-feature-disabled.ast')?.then.code,
+    'HEURISTICS_IOS_CONCURRENCY_UPCOMING_FEATURE_DISABLED_AST'
+  );
+  assert.equal(
+    byId.get('heuristics.ios.concurrency.ui-state-without-mainactor.ast')?.then.code,
+    'HEURISTICS_IOS_CONCURRENCY_UI_STATE_WITHOUT_MAINACTOR_AST'
+  );
+  assert.equal(
+    byId.get('heuristics.ios.concurrency.shared-mutable-state-without-actor.ast')?.then.code,
+    'HEURISTICS_IOS_CONCURRENCY_SHARED_MUTABLE_STATE_WITHOUT_ACTOR_AST'
+  );
+  assert.equal(
+    byId.get('heuristics.ios.concurrency.mainactor-run-patch.ast')?.then.code,
+    'HEURISTICS_IOS_CONCURRENCY_MAINACTOR_RUN_PATCH_AST'
+  );
   assert.equal(
     byId.get('heuristics.ios.architecture.cross-feature-import.ast')?.then.code,
     'HEURISTICS_IOS_ARCHITECTURE_CROSS_FEATURE_IMPORT_AST'
@@ -245,6 +266,10 @@ test('iosRules define reglas heurísticas locked para plataforma ios', () => {
     byId.get('heuristics.ios.accessibility.on-tap-without-button-trait.ast')?.then.code,
     'HEURISTICS_IOS_ACCESSIBILITY_ON_TAP_WITHOUT_BUTTON_TRAIT_AST'
   );
+  assert.equal(
+    byId.get('heuristics.ios.navigation.path-without-restoration.ast')?.then.code,
+    'HEURISTICS_IOS_NAVIGATION_PATH_WITHOUT_RESTORATION_AST'
+  );
   assert.equal(
     byId.get('heuristics.ios.swiftui.glasseffectid-without-namespace.ast')?.then.code,
     'HEURISTICS_IOS_SWIFTUI_GLASSEFFECTID_WITHOUT_NAMESPACE_AST'

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

@@ -1001,6 +1001,78 @@ export const iosRules: RuleSet = [
       code: 'HEURISTICS_IOS_CONCURRENCY_DEFAULT_ACTOR_ISOLATION_NOT_MAINACTOR_AST',
     },
   },
+  {
+    id: 'heuristics.ios.concurrency.upcoming-feature-disabled.ast',
+    description: 'Detects Xcode iOS targets with required Swift upcoming features disabled.',
+    severity: 'WARN',
+    platform: 'ios',
+    locked: true,
+    when: {
+      kind: 'Heuristic',
+      where: {
+        ruleId: 'heuristics.ios.concurrency.upcoming-feature-disabled.ast',
+      },
+    },
+    then: {
+      kind: 'Finding',
+      message: 'AST heuristic detected disabled Swift upcoming feature settings in an iOS Xcode project.',
+      code: 'HEURISTICS_IOS_CONCURRENCY_UPCOMING_FEATURE_DISABLED_AST',
+    },
+  },
+  {
+    id: 'heuristics.ios.concurrency.ui-state-without-mainactor.ast',
+    description: 'Detects observable iOS UI state owners without @MainActor isolation.',
+    severity: 'WARN',
+    platform: 'ios',
+    locked: true,
+    when: {
+      kind: 'Heuristic',
+      where: {
+        ruleId: 'heuristics.ios.concurrency.ui-state-without-mainactor.ast',
+      },
+    },
+    then: {
+      kind: 'Finding',
+      message: 'AST heuristic detected observable iOS UI state without @MainActor isolation.',
+      code: 'HEURISTICS_IOS_CONCURRENCY_UI_STATE_WITHOUT_MAINACTOR_AST',
+    },
+  },
+  {
+    id: 'heuristics.ios.concurrency.shared-mutable-state-without-actor.ast',
+    description: 'Detects shared mutable iOS state owners without actor isolation.',
+    severity: 'WARN',
+    platform: 'ios',
+    locked: true,
+    when: {
+      kind: 'Heuristic',
+      where: {
+        ruleId: 'heuristics.ios.concurrency.shared-mutable-state-without-actor.ast',
+      },
+    },
+    then: {
+      kind: 'Finding',
+      message: 'AST heuristic detected shared mutable iOS state without actor isolation.',
+      code: 'HEURISTICS_IOS_CONCURRENCY_SHARED_MUTABLE_STATE_WITHOUT_ACTOR_AST',
+    },
+  },
+  {
+    id: 'heuristics.ios.concurrency.mainactor-run-patch.ast',
+    description: 'Detects MainActor.run used as an isolation patch inside non-isolated iOS state owners.',
+    severity: 'WARN',
+    platform: 'ios',
+    locked: true,
+    when: {
+      kind: 'Heuristic',
+      where: {
+        ruleId: 'heuristics.ios.concurrency.mainactor-run-patch.ast',
+      },
+    },
+    then: {
+      kind: 'Finding',
+      message: 'AST heuristic detected MainActor.run used as an isolation patch in iOS production code.',
+      code: 'HEURISTICS_IOS_CONCURRENCY_MAINACTOR_RUN_PATCH_AST',
+    },
+  },
   {
     id: 'heuristics.ios.naming.non-pascal-case-type.ast',
     description: 'Detects Swift type declarations that are not PascalCase.',
@@ -1920,6 +1992,24 @@ export const iosRules: RuleSet = [
       code: 'HEURISTICS_IOS_NAVIGATION_VIEW_AST',
     },
   },
+  {
+    id: 'heuristics.ios.navigation.path-without-restoration.ast',
+    description: 'Detects SwiftUI NavigationPath state without an explicit restoration contract.',
+    severity: 'WARN',
+    platform: 'ios',
+    locked: true,
+    when: {
+      kind: 'Heuristic',
+      where: {
+        ruleId: 'heuristics.ios.navigation.path-without-restoration.ast',
+      },
+    },
+    then: {
+      kind: 'Finding',
+      message: 'AST heuristic detected NavigationPath without an explicit restoration contract.',
+      code: 'HEURISTICS_IOS_NAVIGATION_PATH_WITHOUT_RESTORATION_AST',
+    },
+  },
   {
     id: 'heuristics.ios.swiftui.untyped-navigation-link-destination.ast',
     description: 'Detects untyped SwiftUI NavigationLink destination usage.',

package/integrations/config/skillsDetectorRegistry.ts

@@ -63,16 +63,19 @@ const registryByRuleId: Record<string, SkillsDetectorBinding> = {
   'skills.ios.guideline.ios.mainactor-para-co-digo-que-debe-ejecutarse-en-el-hilo-principal':
     heuristicDetector('ios.concurrency.mainactor-dispatchqueue', [
       'heuristics.ios.dispatchqueue.ast',
+      'heuristics.ios.concurrency.ui-state-without-mainactor.ast',
     ]),
   'skills.ios.guideline.ios.actor-para-estado-compartido-thread-safe':
     heuristicDetector('ios.concurrency.shared-state-actor-boundary', [
       'heuristics.ios.dispatchqueue.ast',
       'heuristics.ios.dispatchsemaphore.ast',
+      'heuristics.ios.concurrency.shared-mutable-state-without-actor.ast',
     ]),
   'skills.ios.guideline.ios.sincronizacio-n-nativa-actors-para-estado-compartido-osallocatedunfair':
     heuristicDetector('ios.concurrency.shared-state-actor-boundary', [
       'heuristics.ios.dispatchqueue.ast',
       'heuristics.ios.dispatchsemaphore.ast',
+      'heuristics.ios.concurrency.shared-mutable-state-without-actor.ast',
     ]),
   'skills.ios.no-dispatchgroup': heuristicDetector('ios.dispatchgroup', [
     'heuristics.ios.dispatchgroup.ast',
@@ -467,6 +470,7 @@ const registryByRuleId: Record<string, SkillsDetectorBinding> = {
     heuristicDetector('ios.concurrency.project-settings', [
       'heuristics.ios.concurrency.strict-concurrency-below-complete.ast',
       'heuristics.ios.concurrency.default-actor-isolation-not-mainactor.ast',
+      'heuristics.ios.concurrency.upcoming-feature-disabled.ast',
       'heuristics.ios.concurrency.swiftpm-default-isolation-not-mainactor.ast',
       'heuristics.ios.concurrency.swiftpm-strict-concurrency-below-complete.ast',
     ]),
@@ -474,6 +478,7 @@ const registryByRuleId: Record<string, SkillsDetectorBinding> = {
     heuristicDetector('ios.concurrency.project-settings', [
       'heuristics.ios.concurrency.strict-concurrency-below-complete.ast',
       'heuristics.ios.concurrency.default-actor-isolation-not-mainactor.ast',
+      'heuristics.ios.concurrency.upcoming-feature-disabled.ast',
       'heuristics.ios.concurrency.swiftpm-default-isolation-not-mainactor.ast',
       'heuristics.ios.concurrency.swiftpm-strict-concurrency-below-complete.ast',
     ]),
@@ -519,7 +524,10 @@ const registryByRuleId: Record<string, SkillsDetectorBinding> = {
     'heuristics.ios.assume-isolated.ast',
   ]),
   'skills.ios.guideline.ios.no-usar-mainactor-como-parche-justificar-el-aislamiento':
-    heuristicDetector('ios.assume-isolated', ['heuristics.ios.assume-isolated.ast']),
+    heuristicDetector('ios.assume-isolated', [
+      'heuristics.ios.assume-isolated.ast',
+      'heuristics.ios.concurrency.mainactor-run-patch.ast',
+    ]),
   'skills.ios.no-observable-object': heuristicDetector('ios.observable-object', [
     'heuristics.ios.observable-object.ast',
   ]),
@@ -607,6 +615,14 @@ const registryByRuleId: Record<string, SkillsDetectorBinding> = {
   'skills.ios.no-navigation-view': heuristicDetector('ios.navigation-view', [
     'heuristics.ios.navigation-view.ast',
   ]),
+  'skills.ios.guideline.ios.deep-links-deben-mapear-a-rutas-del-path':
+    heuristicDetector('ios.navigation.path-restoration', [
+      'heuristics.ios.navigation.path-without-restoration.ast',
+    ]),
+  'skills.ios.guideline.ios.state-restoration-rehidratar-path-desde-estado-persistido-si-aplica':
+    heuristicDetector('ios.navigation.path-restoration', [
+      'heuristics.ios.navigation.path-without-restoration.ast',
+    ]),
   'skills.ios.guideline.ios-swiftui-expert.use-modern-apis-no-deprecated-modifiers-or-patterns-see-references-mod':
     heuristicDetector('ios.swiftui.modern-api-replacements', [
       'heuristics.ios.navigation-view.ast',

package/integrations/evidence/buildEvidence.ts

@@ -265,16 +265,33 @@ const equivalentRuleFamilies: ReadonlyArray<ReadonlyArray<string>> = [
     'heuristics.ios.callback-style.ast',
   ],
   ['ios.no-gcd', 'skills.ios.no-dispatchqueue', 'heuristics.ios.dispatchqueue.ast'],
+  [
+    'skills.ios.guideline.ios.mainactor-para-co-digo-que-debe-ejecutarse-en-el-hilo-principal',
+    'heuristics.ios.concurrency.ui-state-without-mainactor.ast',
+  ],
+  [
+    'skills.ios.guideline.ios.actor-para-estado-compartido-thread-safe',
+    'heuristics.ios.concurrency.shared-mutable-state-without-actor.ast',
+  ],
+  [
+    'skills.ios.guideline.ios.sincronizacio-n-nativa-actors-para-estado-compartido-osallocatedunfair',
+    'heuristics.ios.concurrency.shared-mutable-state-without-actor.ast',
+  ],
   ['ios.no-gcd', 'skills.ios.no-dispatchgroup', 'heuristics.ios.dispatchgroup.ast'],
   ['ios.no-gcd', 'skills.ios.no-dispatchsemaphore', 'heuristics.ios.dispatchsemaphore.ast'],
   ['ios.no-gcd', 'skills.ios.no-operation-queue', 'heuristics.ios.operation-queue.ast'],
   ['skills.ios.no-task-detached', 'heuristics.ios.task-detached.ast'],
   ['skills.ios.no-unchecked-sendable', 'heuristics.ios.unchecked-sendable.ast'],
   ['skills.ios.no-preconcurrency', 'heuristics.ios.preconcurrency.ast'],
+  [
+    'skills.ios.guideline.ios.no-usar-mainactor-como-parche-justificar-el-aislamiento',
+    'heuristics.ios.concurrency.mainactor-run-patch.ast',
+  ],
   [
     'skills.ios.guideline.ios-concurrency.use-grep-for-swiftstrictconcurrency-or-swiftdefaultactorisolation-in-p',
     'heuristics.ios.concurrency.strict-concurrency-below-complete.ast',
     'heuristics.ios.concurrency.default-actor-isolation-not-mainactor.ast',
+    'heuristics.ios.concurrency.upcoming-feature-disabled.ast',
     'heuristics.ios.concurrency.swiftpm-default-isolation-not-mainactor.ast',
     'heuristics.ios.concurrency.swiftpm-strict-concurrency-below-complete.ast',
   ],
@@ -282,6 +299,7 @@ const equivalentRuleFamilies: ReadonlyArray<ReadonlyArray<string>> = [
     'skills.ios.guideline.ios.validar-configuracio-n-de-concurrencia-swiftstrictconcurrency-swiftdef',
     'heuristics.ios.concurrency.strict-concurrency-below-complete.ast',
     'heuristics.ios.concurrency.default-actor-isolation-not-mainactor.ast',
+    'heuristics.ios.concurrency.upcoming-feature-disabled.ast',
     'heuristics.ios.concurrency.swiftpm-default-isolation-not-mainactor.ast',
     'heuristics.ios.concurrency.swiftpm-strict-concurrency-below-complete.ast',
   ],
@@ -325,6 +343,14 @@ const equivalentRuleFamilies: ReadonlyArray<ReadonlyArray<string>> = [
     'heuristics.ios.passed-value-state-wrapper.ast',
   ],
   ['skills.ios.no-navigation-view', 'heuristics.ios.navigation-view.ast'],
+  [
+    'skills.ios.guideline.ios.deep-links-deben-mapear-a-rutas-del-path',
+    'heuristics.ios.navigation.path-without-restoration.ast',
+  ],
+  [
+    'skills.ios.guideline.ios.state-restoration-rehidratar-path-desde-estado-persistido-si-aplica',
+    'heuristics.ios.navigation.path-without-restoration.ast',
+  ],
   ['skills.ios.no-foreground-color', 'heuristics.ios.foreground-color.ast'],
   ['skills.ios.no-corner-radius', 'heuristics.ios.corner-radius.ast'],
   ['skills.ios.no-tab-item', 'heuristics.ios.tab-item.ast'],

package/integrations/git/aiGateRepoPolicyFindings.ts

@@ -93,7 +93,7 @@ export const appendTrackingActionableContext = (params: {
   return params.message;
 };
 
-const toRepoPolicyFinding = (params: {
+export const toRepoPolicyFinding = (params: {
   code: string;
   message: string;
   severity: 'ERROR' | 'WARN';
@@ -104,6 +104,7 @@ const toRepoPolicyFinding = (params: {
   message: params.message,
   matchedBy: 'RepoPolicy',
   source: 'ai_gate:repo_policy',
+  ...(params.code === 'EVIDENCE_PREWRITE_WORKTREE_WARN' ? { blocking: false } : {}),
 });
 
 export const collectAiGateRepoPolicyFindings = (params: {

package/integrations/lifecycle/cli.ts

@@ -2019,8 +2019,11 @@ export const prioritizePreWriteAiGateViolations = (
     const rightMatches = right.code === nextAction.reason ? 0 : 1;
     return leftMatches - rightMatches;
   });
+  const blocked = violations.some((violation) => violation.severity === 'ERROR');
   return {
     ...aiGate,
+    status: blocked ? 'BLOCKED' : 'ALLOWED',
+    allowed: !blocked,
     violations,
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pumuki",
-  "version": "6.3.308",
+  "version": "6.3.310",
   "description": "Enterprise-grade AST Intelligence System with multi-platform support (iOS, Android, Backend, Frontend) and Feature-First + DDD + Clean Architecture enforcement. Includes dynamic violations API for intelligent querying.",
   "main": "index.js",
   "bin": {

package/scripts/framework-menu-system-notifications-macos-dialog-payload.ts

@@ -61,15 +61,35 @@ const formatLocation = (cause: NonNullable<Extract<PumukiCriticalNotificationEve
   return line ? `${cause.file}:${line}` : cause.file;
 };
 
+const isWorktreeHygieneCause = (
+  cause: NonNullable<Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>['blockingCauses']>[number]
+): boolean =>
+  cause.code === 'EVIDENCE_PREWRITE_WORKTREE_WARN' ||
+  cause.code === 'EVIDENCE_PREWRITE_WORKTREE_OVER_LIMIT' ||
+  (cause.ruleId ?? '').includes('EVIDENCE_PREWRITE_WORKTREE');
+
+const WORKTREE_HYGIENE_REMEDIATION =
+  'Reduce el worktree pendiente a un slice atómico: stagea solo la tarea activa o guarda el resto en stash nombrado, y reejecuta PRE_WRITE.';
+
 const formatBlockingCauseForDialog = (
   cause: NonNullable<Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>['blockingCauses']>[number],
   index: number
 ): readonly string[] => {
   const rule = cause.ruleId ?? cause.code;
   const problem = stripTechnicalFieldsFromMessage(cause.message) || cause.code;
-  const remediation = cause.remediation
+  const remediation = isWorktreeHygieneCause(cause)
+    ? WORKTREE_HYGIENE_REMEDIATION
+    : cause.remediation
     ? normalizeNotificationText(cause.remediation)
     : 'Corrige la violación indicada y vuelve a intentar el commit.';
+  if (isWorktreeHygieneCause(cause)) {
+    return [
+      `${index + 1}. Aviso: higiene de worktree PRE_WRITE`,
+      '   Alcance: repo/worktree',
+      `   Detalle: ${truncateNotificationText(problem, 160)}`,
+      `   Solución: ${truncateNotificationText(WORKTREE_HYGIENE_REMEDIATION, 180)}`,
+    ];
+  }
 
   return [
     `${index + 1}. Regla: ${truncateNotificationText(rule, 96)}`,
@@ -79,6 +99,11 @@ const formatBlockingCauseForDialog = (
   ];
 };
 
+const hasOnlyWorktreeHygieneCauses = (
+  causes: Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>['blockingCauses']
+): boolean =>
+  Boolean(causes?.length) && causes!.every(isWorktreeHygieneCause);
+
 export const buildBlockedDialogPayload = (params: {
   event: Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>;
   repoRoot: string;
@@ -87,7 +112,9 @@ export const buildBlockedDialogPayload = (params: {
   const causeCode = params.event.causeCode ?? 'GATE_BLOCKED';
   const cause = buildBlockingCausesDetails(params.event.blockingCauses)
     ?? resolveBlockedCauseSummary(params.event, causeCode);
-  const remediation = params.event.blockingCauses && params.event.blockingCauses.length > 0
+  const remediation = hasOnlyWorktreeHygieneCauses(params.event.blockingCauses)
+    ? WORKTREE_HYGIENE_REMEDIATION
+    : params.event.blockingCauses && params.event.blockingCauses.length > 0
     ? 'Corrige las violaciones listadas y vuelve a intentar el commit.'
     : resolveBlockedRemediation(params.event, causeCode);
   const projectLabel = resolveProjectLabel({

package/scripts/framework-menu-system-notifications-remediation.ts

@@ -20,8 +20,10 @@ const BLOCKED_REMEDIATION_BY_CODE: Readonly<Record<string, string>> = {
   EVIDENCE_BRANCH_MISMATCH: 'La evidencia no corresponde a esta rama. Regenera el receipt/evidencia y vuelve a validar.',
   EVIDENCE_REPO_ROOT_MISMATCH: 'Regenera la evidencia desde este repositorio y vuelve a validar.',
   PRE_PUSH_UPSTREAM_MISSING: 'Configura upstream con `git push --set-upstream origin <branch>` y repite PRE_PUSH.',
-  SDD_SESSION_MISSING: 'Abre la sesión SDD del change activo y repite la validación.',
-  SDD_SESSION_INVALID: 'Refresca la sesión SDD activa y vuelve a validar esta fase.',
+  SDD_SESSION_MISSING:
+    'Abre una sesión SDD válida para el change activo (`pumuki sdd session --open --change=<id>`) y reejecuta PRE_WRITE. Agente IA: STOP hasta que exista esa sesión.',
+  SDD_SESSION_INVALID:
+    'Refresca la sesión SDD activa (`pumuki sdd session --refresh --ttl-minutes=90`) y reejecuta PRE_WRITE. Agente IA: STOP hasta que sea válida.',
   OPENSPEC_MISSING: 'Instala OpenSpec en este repositorio y vuelve a validar el gate.',
   MCP_ENTERPRISE_RECEIPT_MISSING: 'Genera el receipt enterprise de MCP y vuelve a validar.',
   BACKEND_AVOID_EXPLICIT_ANY: 'Sustituye `any` por tipos concretos en backend y relanza el gate.',
@@ -31,6 +33,10 @@ const BLOCKED_REMEDIATION_BY_CODE: Readonly<Record<string, string>> = {
   TRACKING_CANONICAL_SOURCE_CONFLICT: TRACKING_BLOCKED_REMEDIATION,
   ACTIVE_RULE_IDS_EMPTY_FOR_CODE_CHANGES_HIGH:
     'Ejecuta `pumuki policy reconcile --strict --json` y revalida antes de continuar.',
+  EVIDENCE_PREWRITE_WORKTREE_WARN:
+    'Reduce el worktree pendiente a un slice atómico antes del commit: stagea solo la tarea activa o guarda el resto en stash nombrado, y reejecuta PRE_WRITE.',
+  EVIDENCE_PREWRITE_WORKTREE_OVER_LIMIT:
+    'El worktree supera el límite permitido: divide cambios por scope en commits atómicos o stashes nombrados antes de continuar.',
 };
 
 const BLOCKED_REMEDIATION_MAX_LENGTH_BY_VARIANT: Readonly<Record<BlockedRemediationVariant, number>> = {
@@ -54,6 +60,81 @@ const normalizeBlockedRemediation = (value: string): string =>
 const resolveFallbackRemediation = (causeCode: string): string =>
   BLOCKED_REMEDIATION_BY_CODE[causeCode] ?? GENERIC_BLOCKED_REMEDIATION;
 
+const resolveSddSessionCauseCode = (
+  event: Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>,
+  causeCode: string
+): 'SDD_SESSION_MISSING' | 'SDD_SESSION_INVALID' | null => {
+  if (causeCode === 'SDD_SESSION_MISSING' || causeCode === 'SDD_SESSION_INVALID') {
+    return causeCode;
+  }
+  const searchable = [
+    event.causeMessage,
+    event.remediation,
+    ...(event.blockingCauses ?? []).flatMap((cause) => [
+      cause.code,
+      cause.ruleId,
+      cause.message,
+      cause.remediation,
+    ]),
+  ]
+    .filter((value): value is string => typeof value === 'string')
+    .join(' ')
+    .toLowerCase();
+  if (
+    searchable.includes('sdd_session_missing') ||
+    searchable.includes('no hay sesión sdd activa') ||
+    searchable.includes('no hay sesion sdd activa') ||
+    searchable.includes('no active sdd session')
+  ) {
+    return 'SDD_SESSION_MISSING';
+  }
+  if (
+    searchable.includes('sdd_session_invalid') ||
+    searchable.includes('sesión sdd actual no es válida') ||
+    searchable.includes('sesion sdd actual no es valida') ||
+    searchable.includes('invalid sdd session')
+  ) {
+    return 'SDD_SESSION_INVALID';
+  }
+  return null;
+};
+
+const resolveWorktreeHygieneCauseCode = (
+  event: Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>,
+  causeCode: string
+): 'EVIDENCE_PREWRITE_WORKTREE_WARN' | 'EVIDENCE_PREWRITE_WORKTREE_OVER_LIMIT' | null => {
+  if (
+    causeCode === 'EVIDENCE_PREWRITE_WORKTREE_WARN' ||
+    causeCode === 'EVIDENCE_PREWRITE_WORKTREE_OVER_LIMIT'
+  ) {
+    return causeCode;
+  }
+  const searchable = [
+    event.causeMessage,
+    event.remediation,
+    ...(event.blockingCauses ?? []).flatMap((cause) => [
+      cause.code,
+      cause.ruleId,
+      cause.message,
+      cause.remediation,
+    ]),
+  ]
+    .filter((value): value is string => typeof value === 'string')
+    .join(' ')
+    .toLowerCase();
+  if (searchable.includes('evidence_prewrite_worktree_over_limit')) {
+    return 'EVIDENCE_PREWRITE_WORKTREE_OVER_LIMIT';
+  }
+  if (
+    searchable.includes('evidence_prewrite_worktree_warn') ||
+    searchable.includes('worktree hygiene warning') ||
+    searchable.includes('warn_threshold=')
+  ) {
+    return 'EVIDENCE_PREWRITE_WORKTREE_WARN';
+  }
+  return null;
+};
+
 const isGenericPolicyReconcileRemediation = (message: string): boolean => {
   const normalized = message.toLowerCase();
   return normalized.includes('policy reconcile') && normalized.includes('sdd validate');
@@ -105,6 +186,20 @@ export const resolveBlockedRemediation = (
 ): string => {
   const variant = options?.variant ?? 'dialog';
   const maxLength = BLOCKED_REMEDIATION_MAX_LENGTH_BY_VARIANT[variant];
+  const sddSessionCauseCode = resolveSddSessionCauseCode(event, causeCode);
+  if (sddSessionCauseCode) {
+    return truncateNotificationText(
+      resolveFallbackRemediation(sddSessionCauseCode),
+      maxLength
+    );
+  }
+  const worktreeHygieneCauseCode = resolveWorktreeHygieneCauseCode(event, causeCode);
+  if (worktreeHygieneCauseCode) {
+    return truncateNotificationText(
+      resolveFallbackRemediation(worktreeHygieneCauseCode),
+      maxLength
+    );
+  }
   const blockingCausesCount = event.blockingCauses?.length ?? 0;
   if (blockingCausesCount > 1) {
     return truncateNotificationText(