pumuki 6.3.122 → 6.3.124

package/CHANGELOG.md

@@ -6,6 +6,14 @@ This project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [6.3.123] - 2026-04-28
+
+### Fixed
+
+- **Detectores SOLID sin contadores arbitrarios:** `SRP`, `DIP`, `OCP` e `ISP` en iOS/Android/TypeScript dejan de depender de mínimos tipo `relatedNodes.length < N`, `typedCaseCount >= N` o cortes `slice(0, N)` y pasan a usar categorías semánticas explícitas.
+- **ISP iOS/Android por familias de contrato:** los protocolos/interfaces anchos se detectan por mezcla real de `query`/`command` y uso de una sola familia por consumidor, no por número de miembros.
+- **Cierre de `PUMUKI-INC-116`:** se añade regresión negativa para clases/protocolos grandes pero cohesionados y auditoría textual para impedir que los detectores estructurales vuelvan a degradarse a `N señales => bloqueo`.
+
 ## [6.3.122] - 2026-04-28
 
 ### Fixed

package/VERSION

@@ -1 +1 @@
-v6.3.122
+v6.3.123

package/core/facts/detectors/astRuleThresholdAudit.test.ts

@@ -0,0 +1,33 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import test from 'node:test';
+
+const detectorFiles = [
+  'core/facts/detectors/text/ios.ts',
+  'core/facts/detectors/text/android.ts',
+  'core/facts/detectors/typescript/index.ts',
+  'core/facts/detectors/security/securityCredentials.ts',
+];
+
+const forbiddenDecisionThresholds = [
+  /typeDeclarations\.length\s*<\s*\d+/,
+  /conformingTypes\.length\s*<\s*\d+/,
+  /trim\(\)\.length\s*>=\s*\d+/,
+  /relatedNodes\.length\s*<\s*\d+/,
+  /typedCaseCount\s*>=\s*\d+/,
+  /caseNodes\.length\s*<\s*\d+/,
+  /branchNodes\.length\s*<\s*\d+/,
+  /slice\(0,\s*\d+\)/,
+];
+
+test('detectores AST estructurales no usan umbrales internos para decidir skills', () => {
+  const violations = detectorFiles.flatMap((filePath) => {
+    const content = readFileSync(join(process.cwd(), filePath), 'utf8');
+    return forbiddenDecisionThresholds
+      .filter((pattern) => pattern.test(content))
+      .map((pattern) => `${filePath}: ${pattern.source}`);
+  });
+
+  assert.deepEqual(violations, []);
+});

package/core/facts/detectors/security/index.test.ts

@@ -15,7 +15,7 @@ import {
   hasWeakTokenGenerationWithCryptoRandomUuid,
 } from './index';
 
-test('hasHardcodedSecretTokenLiteral detecta literales fuertes en identificadores sensibles', () => {
+test('hasHardcodedSecretTokenLiteral detecta literales reales en identificadores sensibles', () => {
   const ast = {
     type: 'VariableDeclarator',
     id: { type: 'Identifier', name: 'apiToken' },
@@ -24,11 +24,17 @@ test('hasHardcodedSecretTokenLiteral detecta literales fuertes en identificadore
   const safeAst = {
     type: 'VariableDeclarator',
     id: { type: 'Identifier', name: 'apiToken' },
-    init: { type: 'StringLiteral', value: 'short' },
+    init: { type: 'StringLiteral', value: 'example' },
+  };
+  const shortRealSecretAst = {
+    type: 'VariableDeclarator',
+    id: { type: 'Identifier', name: 'apiToken' },
+    init: { type: 'StringLiteral', value: 'prod' },
   };
 
   assert.equal(hasHardcodedSecretTokenLiteral(ast), true);
   assert.equal(hasHardcodedSecretTokenLiteral(safeAst), false);
+  assert.equal(hasHardcodedSecretTokenLiteral(shortRealSecretAst), true);
 });
 
 test('hasInsecureTokenGenerationWithMathRandom detecta Math.random en asignacion sensible', () => {

package/core/facts/detectors/security/securityCredentials.test.ts

@@ -11,16 +11,21 @@ import {
   hasWeakTokenGenerationWithCryptoRandomUuid,
 } from './securityCredentials';
 
-test('hasHardcodedSecretTokenLiteral detecta literal largo en identificador sensible', () => {
+test('hasHardcodedSecretTokenLiteral detecta literal real en identificador sensible', () => {
   const hardcodedSecretAst = {
     type: 'VariableDeclarator',
     id: { type: 'Identifier', name: 'apiKey' },
     init: { type: 'StringLiteral', value: 'super-secret-key-123' },
   };
-  const safeLengthAst = {
+  const placeholderAst = {
     type: 'VariableDeclarator',
     id: { type: 'Identifier', name: 'apiKey' },
-    init: { type: 'StringLiteral', value: 'short' },
+    init: { type: 'StringLiteral', value: 'replace-me' },
+  };
+  const shortRealSecretAst = {
+    type: 'VariableDeclarator',
+    id: { type: 'Identifier', name: 'apiKey' },
+    init: { type: 'StringLiteral', value: 'prod' },
   };
   const nonSensitiveIdentifierAst = {
     type: 'VariableDeclarator',
@@ -29,7 +34,8 @@ test('hasHardcodedSecretTokenLiteral detecta literal largo en identificador sens
   };
 
   assert.equal(hasHardcodedSecretTokenLiteral(hardcodedSecretAst), true);
-  assert.equal(hasHardcodedSecretTokenLiteral(safeLengthAst), false);
+  assert.equal(hasHardcodedSecretTokenLiteral(placeholderAst), false);
+  assert.equal(hasHardcodedSecretTokenLiteral(shortRealSecretAst), true);
   assert.equal(hasHardcodedSecretTokenLiteral(nonSensitiveIdentifierAst), false);
 });
 

package/core/facts/detectors/security/securityCredentials.ts

@@ -1,13 +1,15 @@
 import { collectNodeLineMatches, hasNode, isObject } from '../utils/astHelpers';
 
 const sensitiveIdentifierPattern = /(secret|token|password|api[_-]?key)/i;
+const placeholderSecretLiteralPattern =
+  /^(?:changeme|change-me|change_me|replace-me|replace_me|todo|tbd|example|sample|dummy|test|testing|placeholder|your[_-]?(?:secret|token|password|api[_-]?key)|xxx+)$/i;
 
-const hasStrongLiteralValue = (value: unknown): boolean => {
+const hasCredentialLiteralValue = (value: unknown): boolean => {
   if (!isObject(value)) {
     return false;
   }
   if (value.type === 'StringLiteral') {
-    return typeof value.value === 'string' && value.value.trim().length >= 12;
+    return typeof value.value === 'string' && isCredentialLiteral(value.value);
   }
   if (
     value.type === 'TemplateLiteral' &&
@@ -17,11 +19,16 @@ const hasStrongLiteralValue = (value: unknown): boolean => {
     value.quasis.length === 1
   ) {
     const cooked = value.quasis[0]?.value?.cooked;
-    return typeof cooked === 'string' && cooked.trim().length >= 12;
+    return typeof cooked === 'string' && isCredentialLiteral(cooked);
   }
   return false;
 };
 
+const isCredentialLiteral = (value: string): boolean => {
+  const normalized = value.trim();
+  return normalized.length > 0 && !placeholderSecretLiteralPattern.test(normalized);
+};
+
 const containsMathRandomCall = (candidate: unknown): boolean => {
   return hasNode(candidate, (value) => {
     if (value.type !== 'CallExpression') {
@@ -109,7 +116,7 @@ const isHardcodedSecretTokenLiteralNode = (value: Record<string, string | number
   if (!sensitiveIdentifierPattern.test(idNode.name as string)) {
     return false;
   }
-  return hasStrongLiteralValue(value.init);
+  return hasCredentialLiteralValue(value.init);
 };
 
 const isInsecureTokenGenerationWithMathRandomNode = (value: Record<string, string | number | boolean | bigint | symbol | null | Date | object>): boolean => {

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

@@ -254,6 +254,46 @@ class PumukiIspAndroidCanaryUseCase(
   assert.match(match.expected_fix, /interfaces pequeñas|puerto mínimo/i);
 });
 
+test('detectores SOLID Android no convierten tamaño o cardinalidad en violacion', () => {
+  const presentationWithoutMixedResponsibilities = `
+class CatalogViewModel {
+  fun restoreSessionSnapshot() {}
+  fun refreshSessionToken() {}
+  fun resumeSessionIfNeeded() {}
+  fun signOut() {}
+}
+`;
+  const dipWithPortOnly = `
+interface CatalogFetching {
+  suspend fun fetchCatalog(): List<String>
+}
+
+class CatalogUseCase(
+  private val catalog: CatalogFetching,
+)
+`;
+  const cohesiveInterface = `
+interface CatalogReading {
+  suspend fun fetchCatalog(): List<String>
+  suspend fun loadCachedCatalog(): List<String>
+  suspend fun readCatalogVersion(): String
+  suspend fun getFeaturedCatalog(): List<String>
+}
+
+class CatalogUseCase(
+  private val catalog: CatalogReading,
+) {
+  suspend fun execute() {
+    catalog.fetchCatalog()
+  }
+}
+`;
+
+  assert.equal(findKotlinPresentationSrpMatch(presentationWithoutMixedResponsibilities), undefined);
+  assert.equal(findKotlinConcreteDependencyDipMatch(dipWithPortOnly), undefined);
+  assert.equal(findKotlinInterfaceSegregationMatch(cohesiveInterface), undefined);
+});
+
 test('findKotlinLiskovSubstitutionMatch devuelve payload semantico para LSP-Android en application', () => {
   const source = `
 interface PumukiLspAndroidCanaryDiscountPolicy {

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

@@ -70,6 +70,40 @@ type KotlinTypeDeclaration = {
   bodyEndLine: number;
 };
 
+type KotlinResponsibilityMatch = {
+  key: string;
+  node: KotlinSemanticNodeMatch;
+};
+
+const kotlinQueryMemberNamePattern = /^(get|find|list|fetch|read|load|restore|refresh|is|has|can)/i;
+const kotlinCommandMemberNamePattern =
+  /^(create|update|delete|remove|save|insert|upsert|set|write|persist|clear|reset|sync|store)/i;
+
+const registerKotlinResponsibility = (
+  nodes: KotlinResponsibilityMatch[],
+  key: string,
+  kind: KotlinSemanticNodeMatch['kind'],
+  name: string,
+  lines: readonly number[]
+): void => {
+  if (lines.length === 0) {
+    return;
+  }
+  nodes.push({ key, node: { kind, name, lines } });
+};
+
+const hasKotlinResponsibilityKeys = (
+  nodes: readonly KotlinResponsibilityMatch[],
+  keys: readonly string[]
+): boolean => {
+  const observedKeys = new Set(nodes.map((node) => node.key));
+  return keys.every((key) => observedKeys.has(key));
+};
+
+const isKotlinQueryMemberName = (name: string): boolean => kotlinQueryMemberNamePattern.test(name);
+const isKotlinCommandMemberName = (name: string): boolean =>
+  kotlinCommandMemberNamePattern.test(name);
+
 const stripKotlinLineForSemanticScan = (line: string): string => {
   return line
     .replace(/\/\/.*$/, '')
@@ -274,44 +308,46 @@ export const findKotlinPresentationSrpMatch = (
     return undefined;
   }
 
-  const relatedNodes: KotlinSemanticNodeMatch[] = [];
+  const responsibilities: KotlinResponsibilityMatch[] = [];
   const registerNode = (
+    key: string,
     kind: KotlinSemanticNodeMatch['kind'],
     name: string,
     regex: RegExp
   ): void => {
-    const lines = collectKotlinRegexLines(source, regex);
-    if (lines.length === 0) {
-      return;
-    }
-    relatedNodes.push({ kind, name, lines });
+    registerKotlinResponsibility(responsibilities, key, kind, name, collectKotlinRegexLines(source, regex));
   };
 
   registerNode(
+    'session',
     'member',
     'session/auth flow',
     /\b(?:restore|bootstrap|refresh|resume|signIn|signOut|authenticate|session)\w*\s*\(/
   );
   registerNode(
+    'networking',
     'call',
     'remote networking',
     /\b(?:OkHttpClient\s*\(|Retrofit\.Builder\s*\(|HttpURLConnection\b)/
   );
   registerNode(
+    'persistence',
     'call',
     'local persistence',
     /\b(?:SharedPreferences\b.*\)|PreferenceDataStoreFactory\.create|preferencesDataStore|DataStore<|RoomDatabase\b)/
   );
   registerNode(
+    'navigation',
     'member',
     'navigation flow',
     /\b(?:findNavController\s*\(|\.\s*navigate\s*\()/
   );
 
-  if (relatedNodes.length < 4) {
+  if (!hasKotlinResponsibilityKeys(responsibilities, ['session', 'networking', 'persistence', 'navigation'])) {
     return undefined;
   }
 
+  const relatedNodes = responsibilities.map((entry) => entry.node);
   const allLines = sortedUniqueLines([
     ...classLines,
     ...relatedNodes.flatMap((node) => [...node.lines]),
@@ -396,7 +432,7 @@ export const findKotlinConcreteDependencyDipMatch = (
   );
   registerNode('call', 'Room.databaseBuilder', /\bRoom\.databaseBuilder\s*\(/);
 
-  if (relatedNodes.length < 2) {
+  if (relatedNodes.length === 0) {
     return undefined;
   }
 
@@ -473,7 +509,8 @@ export const findKotlinOpenClosedWhenMatch = (
       }
     }
 
-    if (branchNodes.length < 2) {
+    const [firstBranchNode, secondBranchNode] = branchNodes;
+    if (!firstBranchNode || !secondBranchNode) {
       continue;
     }
 
@@ -483,7 +520,7 @@ export const findKotlinOpenClosedWhenMatch = (
         name: `discriminator switch: ${discriminatorName}`,
         lines: [index + 1],
       },
-      ...branchNodes.slice(0, 3),
+      ...branchNodes,
     ];
 
     const allLines = sortedUniqueLines([
@@ -492,7 +529,6 @@ export const findKotlinOpenClosedWhenMatch = (
       ...branchNodes.flatMap((node) => [...node.lines]),
     ]);
     const branchSummary = branchNodes
-      .slice(0, 3)
       .map((node) => node.name.replace(/^branch /, ''))
       .join(', ');
 
@@ -541,7 +577,13 @@ export const findKotlinInterfaceSegregationMatch = (
   const sourceLines = source.split(/\r?\n/);
 
   for (const interfaceDeclaration of interfaceDeclarations) {
-    if (interfaceDeclaration.members.length < 4) {
+    const queryMembers = interfaceDeclaration.members.filter((member) =>
+      isKotlinQueryMemberName(member.name)
+    );
+    const commandMembers = interfaceDeclaration.members.filter((member) =>
+      isKotlinCommandMemberName(member.name)
+    );
+    if (queryMembers.length === 0 || commandMembers.length === 0) {
       continue;
     }
 
@@ -579,14 +621,21 @@ export const findKotlinInterfaceSegregationMatch = (
       }
     });
 
-    if (usedMembers.size === 0 || usedMembers.size > 2) {
+    const usedMemberNames = [...usedMembers.keys()];
+    if (usedMemberNames.length === 0) {
       continue;
     }
 
-    const unusedMembers = interfaceDeclaration.members.filter(
-      (member) => !usedMembers.has(member.name)
-    );
-    if (unusedMembers.length < 2) {
+    const usesQueryContract = usedMemberNames.some(isKotlinQueryMemberName);
+    const usesCommandContract = usedMemberNames.some(isKotlinCommandMemberName);
+    if (usesQueryContract === usesCommandContract) {
+      continue;
+    }
+
+    const oppositeFamilyMembers = usesQueryContract ? commandMembers : queryMembers;
+    const unusedMembers = oppositeFamilyMembers.filter((member) => !usedMembers.has(member.name));
+    const firstUnusedMember = unusedMembers[0];
+    if (!firstUnusedMember) {
       continue;
     }
 
@@ -603,7 +652,7 @@ export const findKotlinInterfaceSegregationMatch = (
         lines: [interfaceDeclaration.line],
       },
       ...usedDescriptors,
-      ...unusedMembers.slice(0, 2).map((member) => ({
+      ...unusedMembers.map((member) => ({
         kind: 'member' as const,
         name: `unused contract member: ${member.name}`,
         lines: [member.line],
@@ -611,7 +660,7 @@ export const findKotlinInterfaceSegregationMatch = (
     ];
 
     const usedMemberSummary = usedDescriptors.map((member) => member.name.replace('used member: ', ''));
-    const unusedSummary = unusedMembers.slice(0, 2).map((member) => member.name);
+    const unusedSummary = unusedMembers.map((member) => member.name);
     const allLines = sortedUniqueLines([
       ...typeLines,
       interfaceDeclaration.line,
@@ -650,9 +699,6 @@ export const findKotlinLiskovSubstitutionMatch = (
   }
 
   const typeDeclarations = parseKotlinTypeDeclarations(source);
-  if (typeDeclarations.length < 2) {
-    return undefined;
-  }
 
   const sourceLines = source.split(/\r?\n/);
 
@@ -665,9 +711,6 @@ export const findKotlinLiskovSubstitutionMatch = (
     const conformingTypes = typeDeclarations.filter((typeDeclaration) =>
       typeDeclaration.conformances.includes(interfaceDeclaration.name)
     );
-    if (conformingTypes.length < 2) {
-      continue;
-    }
 
     for (const memberName of memberNames) {
       let safeType: KotlinTypeDeclaration | undefined;

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

@@ -807,6 +807,54 @@ final class PumukiIspIosCanaryUseCase {
   assert.match(match.expected_fix, /protocolos pequeños|puerto mínimo/i);
 });
 
+test('detectores SOLID iOS no convierten tamaño o cardinalidad en violacion', () => {
+  const presentationWithoutMixedResponsibilities = `
+final class CatalogViewModel {
+  func restoreSessionSnapshot() async {}
+  func refreshSessionToken() async {}
+  func resumeSessionIfNeeded() async {}
+  func signOut() async {}
+}
+`;
+  const dipWithPortOnly = `
+protocol CatalogFetching {
+  func fetchCatalog() async throws -> [String]
+}
+
+final class CatalogUseCase {
+  private let catalog: CatalogFetching
+
+  init(catalog: CatalogFetching) {
+    self.catalog = catalog
+  }
+}
+`;
+  const cohesiveProtocol = `
+protocol CatalogReading {
+  func fetchCatalog() async throws -> [String]
+  func loadCachedCatalog() async throws -> [String]
+  func readCatalogVersion() async throws -> String
+  func getFeaturedCatalog() async throws -> [String]
+}
+
+final class CatalogUseCase {
+  private let catalog: CatalogReading
+
+  init(catalog: CatalogReading) {
+    self.catalog = catalog
+  }
+
+  func execute() async throws {
+    _ = try await catalog.fetchCatalog()
+  }
+}
+`;
+
+  assert.equal(findSwiftPresentationSrpMatch(presentationWithoutMixedResponsibilities), undefined);
+  assert.equal(findSwiftConcreteDependencyDipMatch(dipWithPortOnly), undefined);
+  assert.equal(findSwiftInterfaceSegregationMatch(cohesiveProtocol), undefined);
+});
+
 test('findSwiftLiskovSubstitutionMatch devuelve payload semantico para LSP-iOS en application', () => {
   const source = `
 protocol PumukiLspIosCanaryDiscountApplying {

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

@@ -144,6 +144,39 @@ type SwiftTypeDeclaration = {
   bodyEndLine: number;
 };
 
+type SwiftResponsibilityMatch = {
+  key: string;
+  node: SwiftSemanticNodeMatch;
+};
+
+const swiftQueryMemberNamePattern = /^(get|find|list|fetch|read|load|restore|refresh|is|has|can)/i;
+const swiftCommandMemberNamePattern =
+  /^(create|update|delete|remove|save|insert|upsert|set|write|persist|clear|reset|sync|store)/i;
+
+const registerSwiftResponsibility = (
+  nodes: SwiftResponsibilityMatch[],
+  key: string,
+  kind: SwiftSemanticNodeMatch['kind'],
+  name: string,
+  lines: readonly number[]
+): void => {
+  if (lines.length === 0) {
+    return;
+  }
+  nodes.push({ key, node: { kind, name, lines } });
+};
+
+const hasSwiftResponsibilityKeys = (
+  nodes: readonly SwiftResponsibilityMatch[],
+  keys: readonly string[]
+): boolean => {
+  const observedKeys = new Set(nodes.map((node) => node.key));
+  return keys.every((key) => observedKeys.has(key));
+};
+
+const isSwiftQueryMemberName = (name: string): boolean => swiftQueryMemberNamePattern.test(name);
+const isSwiftCommandMemberName = (name: string): boolean => swiftCommandMemberNamePattern.test(name);
+
 const parseSwiftProtocolDeclarations = (source: string): readonly SwiftProtocolDeclaration[] => {
   const lines = source.split(/\r?\n/);
   const declarations: SwiftProtocolDeclaration[] = [];
@@ -874,31 +907,41 @@ export const findSwiftIOSCanary001Match = (source: string): SwiftIOSCanary001Mat
     return undefined;
   }
 
-  const registerNode = (
-    nodes: SwiftSemanticNodeMatch[],
-    kind: SwiftSemanticNodeMatch['kind'],
-    name: string,
-    regex: RegExp
-  ): void => {
-    const lines = collectSwiftRegexLines(source, regex);
-    if (lines.length === 0) {
-      return;
-    }
-    nodes.push({ kind, name, lines });
-  };
-
-  const explicitInfraNodes: SwiftSemanticNodeMatch[] = [];
-  registerNode(explicitInfraNodes, 'property', 'shared singleton', /\bstatic\s+let\s+shared\b/);
-  registerNode(explicitInfraNodes, 'call', 'URLSession.shared', /\bURLSession\.shared\b/);
-  registerNode(explicitInfraNodes, 'call', 'FileManager.default', /\bFileManager\.default\b/);
-  registerNode(
-    explicitInfraNodes,
+  const explicitInfraResponsibilities: SwiftResponsibilityMatch[] = [];
+  registerSwiftResponsibility(
+    explicitInfraResponsibilities,
+    'shared-state',
+    'property',
+    'shared singleton',
+    collectSwiftRegexLines(source, /\bstatic\s+let\s+shared\b/)
+  );
+  registerSwiftResponsibility(
+    explicitInfraResponsibilities,
+    'networking',
+    'call',
+    'URLSession.shared',
+    collectSwiftRegexLines(source, /\bURLSession\.shared\b/)
+  );
+  registerSwiftResponsibility(
+    explicitInfraResponsibilities,
+    'persistence',
+    'call',
+    'FileManager.default',
+    collectSwiftRegexLines(source, /\bFileManager\.default\b/)
+  );
+  registerSwiftResponsibility(
+    explicitInfraResponsibilities,
+    'navigation',
     'member',
     'navigation flow',
-    /\b(?:router|route|coordinator|navigationPath|navigationDestination)\b|\b(?:navigate|dismiss|present)\s*\(/i
+    collectSwiftRegexLines(
+      source,
+      /\b(?:router|route|coordinator|navigationPath|navigationDestination)\b|\b(?:navigate|dismiss|present)\s*\(/i
+    )
   );
 
-  if (explicitInfraNodes.length >= 3) {
+  if (hasSwiftResponsibilityKeys(explicitInfraResponsibilities, ['networking', 'persistence', 'navigation'])) {
+    const explicitInfraNodes = explicitInfraResponsibilities.map((entry) => entry.node);
     const relatedNodeNames = explicitInfraNodes.map((node) => node.name).join(', ');
     const allLines = sortedUniqueLines([
       ...classLines,
@@ -921,33 +964,55 @@ export const findSwiftIOSCanary001Match = (source: string): SwiftIOSCanary001Mat
     };
   }
 
-  const appShellNodes: SwiftSemanticNodeMatch[] = [];
-  registerNode(
-    appShellNodes,
+  const appShellResponsibilities: SwiftResponsibilityMatch[] = [];
+  registerSwiftResponsibility(
+    appShellResponsibilities,
+    'session',
     'member',
     'session bootstrap/restoration',
-    /\b(?:restorePersistedSessionIfNeeded|continueAsGuest|bootstrapAuthenticatedSession)\s*\(/
+    collectSwiftRegexLines(source, /\b(?:restorePersistedSessionIfNeeded|continueAsGuest|bootstrapAuthenticatedSession)\s*\(/)
   );
-  registerNode(appShellNodes, 'member', 'store selection orchestration', /\bselectStore\s*\(/);
-  registerNode(appShellNodes, 'member', 'shopping list synchronization', /\bsyncShoppingList\s*\(/);
-  registerNode(
-    appShellNodes,
+  registerSwiftResponsibility(
+    appShellResponsibilities,
+    'store',
+    'member',
+    'store selection orchestration',
+    collectSwiftRegexLines(source, /\bselectStore\s*\(/)
+  );
+  registerSwiftResponsibility(
+    appShellResponsibilities,
+    'shopping-list',
+    'member',
+    'shopping list synchronization',
+    collectSwiftRegexLines(source, /\bsyncShoppingList\s*\(/)
+  );
+  registerSwiftResponsibility(
+    appShellResponsibilities,
+    'route',
     'member',
     'route progression',
-    /\b(?:markNextStopCompleted|scanCheckpoint|rebuildRouteStatus)\s*\(/
+    collectSwiftRegexLines(source, /\b(?:markNextStopCompleted|scanCheckpoint|rebuildRouteStatus)\s*\(/)
   );
-  registerNode(
-    appShellNodes,
+  registerSwiftResponsibility(
+    appShellResponsibilities,
+    'offline-queue',
     'member',
     'offline queue coordination',
-    /\b(?:flushOfflineQueue|enqueueOfflineCheckpoint)\s*\(/
+    collectSwiftRegexLines(source, /\b(?:flushOfflineQueue|enqueueOfflineCheckpoint)\s*\(/)
+  );
+  registerSwiftResponsibility(
+    appShellResponsibilities,
+    'navigation',
+    'member',
+    'deep link/navigation flow',
+    collectSwiftRegexLines(source, /\bopenDeepLink\s*\(/)
   );
-  registerNode(appShellNodes, 'member', 'deep link/navigation flow', /\bopenDeepLink\s*\(/);
 
-  if (appShellNodes.length < 4) {
+  if (!hasSwiftResponsibilityKeys(appShellResponsibilities, ['session', 'store', 'route', 'navigation'])) {
     return undefined;
   }
 
+  const appShellNodes = appShellResponsibilities.map((entry) => entry.node);
   const relatedNodeNames = appShellNodes.map((node) => node.name).join(', ');
   const allLines = sortedUniqueLines([
     ...classLines,
@@ -985,44 +1050,46 @@ export const findSwiftPresentationSrpMatch = (
     return undefined;
   }
 
-  const relatedNodes: SwiftSemanticNodeMatch[] = [];
+  const responsibilities: SwiftResponsibilityMatch[] = [];
   const registerNode = (
+    key: string,
     kind: SwiftSemanticNodeMatch['kind'],
     name: string,
     regex: RegExp
   ): void => {
-    const lines = collectSwiftRegexLines(source, regex);
-    if (lines.length === 0) {
-      return;
-    }
-    relatedNodes.push({ kind, name, lines });
+    registerSwiftResponsibility(responsibilities, key, kind, name, collectSwiftRegexLines(source, regex));
   };
 
   registerNode(
+    'session',
     'member',
     'session/auth flow',
     /\b(?:restore|bootstrap|refresh|resume|signIn|signOut|authenticate|session)\w*\s*\(/
   );
   registerNode(
+    'networking',
     'call',
     'remote networking',
     /\b(?:URLSession\.shared|URLRequest\b|dataTask\s*\(|uploadTask\s*\(|downloadTask\s*\()/
   );
   registerNode(
+    'persistence',
     'call',
     'local persistence',
     /\b(?:UserDefaults\.standard|FileManager\.default|Keychain|NSPersistentContainer|CoreData)\b/
   );
   registerNode(
+    'navigation',
     'member',
     'navigation flow',
     /\b(?:navigationPath|navigationDestination)\b|(?:\.\s*(?:navigate|present|dismiss|push|open)\s*\()/
   );
 
-  if (relatedNodes.length < 4) {
+  if (!hasSwiftResponsibilityKeys(responsibilities, ['session', 'networking', 'persistence', 'navigation'])) {
     return undefined;
   }
 
+  const relatedNodes = responsibilities.map((entry) => entry.node);
   const allLines = sortedUniqueLines([
     ...classLines,
     ...relatedNodes.flatMap((node) => [...node.lines]),
@@ -1092,7 +1159,7 @@ export const findSwiftConcreteDependencyDipMatch = (
   );
   registerNode('call', 'FileManager.default', /\bFileManager\.default\b/);
 
-  if (relatedNodes.length < 2) {
+  if (relatedNodes.length === 0) {
     return undefined;
   }
 
@@ -1178,7 +1245,8 @@ export const findSwiftOpenClosedSwitchMatch = (
       }
     }
 
-    if (caseNodes.length < 2) {
+    const [firstCaseNode, secondCaseNode] = caseNodes;
+    if (!firstCaseNode || !secondCaseNode) {
       continue;
     }
 
@@ -1188,7 +1256,7 @@ export const findSwiftOpenClosedSwitchMatch = (
         name: `discriminator switch: ${discriminatorName}`,
         lines: [index + 1],
       },
-      ...caseNodes.slice(0, 3),
+      ...caseNodes,
     ];
 
     const allLines = sortedUniqueLines([
@@ -1197,7 +1265,6 @@ export const findSwiftOpenClosedSwitchMatch = (
       ...caseNodes.flatMap((node) => [...node.lines]),
     ]);
     const caseSummary = caseNodes
-      .slice(0, 3)
       .map((node) => node.name.replace(/^case\s+/, ''))
       .join(', ');
 
@@ -1246,7 +1313,13 @@ export const findSwiftInterfaceSegregationMatch = (
   const sourceLines = source.split(/\r?\n/);
 
   for (const protocolDeclaration of protocolDeclarations) {
-    if (protocolDeclaration.members.length < 4) {
+    const queryMembers = protocolDeclaration.members.filter((member) =>
+      isSwiftQueryMemberName(member.name)
+    );
+    const commandMembers = protocolDeclaration.members.filter((member) =>
+      isSwiftCommandMemberName(member.name)
+    );
+    if (queryMembers.length === 0 || commandMembers.length === 0) {
       continue;
     }
 
@@ -1283,14 +1356,21 @@ export const findSwiftInterfaceSegregationMatch = (
       }
     });
 
-    if (usedMembers.size === 0 || usedMembers.size > 2) {
+    const usedMemberNames = [...usedMembers.keys()];
+    if (usedMemberNames.length === 0) {
       continue;
     }
 
-    const unusedMembers = protocolDeclaration.members.filter(
-      (member) => !usedMembers.has(member.name)
-    );
-    if (unusedMembers.length < 2) {
+    const usesQueryContract = usedMemberNames.some(isSwiftQueryMemberName);
+    const usesCommandContract = usedMemberNames.some(isSwiftCommandMemberName);
+    if (usesQueryContract === usesCommandContract) {
+      continue;
+    }
+
+    const oppositeFamilyMembers = usesQueryContract ? commandMembers : queryMembers;
+    const unusedMembers = oppositeFamilyMembers.filter((member) => !usedMembers.has(member.name));
+    const firstUnusedMember = unusedMembers[0];
+    if (!firstUnusedMember) {
       continue;
     }
 
@@ -1311,7 +1391,7 @@ export const findSwiftInterfaceSegregationMatch = (
         name: `used member: ${usedMemberName}`,
         lines: sortedUniqueLines(usedMemberLines),
       },
-      ...unusedMembers.slice(0, 2).map((member) => ({
+      ...unusedMembers.map((member) => ({
         kind: 'member' as const,
         name: `unused contract member: ${member.name}`,
         lines: [member.line],
@@ -1322,7 +1402,7 @@ export const findSwiftInterfaceSegregationMatch = (
       ...typeLines,
       protocolDeclaration.line,
       ...usedMemberLines,
-      ...unusedMembers.slice(0, 2).map((member) => member.line),
+      ...unusedMembers.map((member) => member.line),
     ]);
 
     return {
@@ -1355,9 +1435,6 @@ export const findSwiftLiskovSubstitutionMatch = (
   }
 
   const typeDeclarations = parseSwiftTypeDeclarations(source);
-  if (typeDeclarations.length < 2) {
-    return undefined;
-  }
 
   const sourceLines = source.split(/\r?\n/);
 
@@ -1370,9 +1447,6 @@ export const findSwiftLiskovSubstitutionMatch = (
     const conformingTypes = typeDeclarations.filter((typeDeclaration) =>
       typeDeclaration.conformances.includes(protocolDeclaration.name)
     );
-    if (conformingTypes.length < 2) {
-      continue;
-    }
 
     for (const memberName of memberNames) {
       let safeType: SwiftTypeDeclaration | undefined;

package/core/facts/detectors/typescript/index.ts

@@ -893,14 +893,15 @@ const findTypeDiscriminatorSwitchInfo = (
       return false;
     }
 
-    const typedCaseCount = value.cases.filter((entry) => {
+    const typedCases = value.cases.filter((entry) => {
       if (!isObject(entry) || entry.type !== 'SwitchCase' || !isObject(entry.test)) {
         return false;
       }
       return typeof switchCaseLabelFromNode(entry.test) === 'string';
-    }).length;
+    });
 
-    return typedCaseCount >= 2;
+    const [firstTypedCase, secondTypedCase] = typedCases;
+    return firstTypedCase !== undefined && secondTypedCase !== undefined;
   });
 
   if (!match) {
@@ -934,7 +935,8 @@ const findTypeDiscriminatorSwitchInfo = (
       })
     : [];
 
-  if (caseNodes.length < 2) {
+  const [firstCaseNode, secondCaseNode] = caseNodes;
+  if (!firstCaseNode || !secondCaseNode) {
     return undefined;
   }
 
@@ -1657,7 +1659,7 @@ export const hasTypeDiscriminatorSwitch = (node: unknown): boolean => {
       return false;
     }
 
-    const typedCaseCount = value.cases.filter((entry) => {
+    const typedCases = value.cases.filter((entry) => {
       if (!isObject(entry) || entry.type !== 'SwitchCase' || !isObject(entry.test)) {
         return false;
       }
@@ -1667,9 +1669,10 @@ export const hasTypeDiscriminatorSwitch = (node: unknown): boolean => {
         testNode.type === 'NumericLiteral' ||
         testNode.type === 'BooleanLiteral'
       );
-    }).length;
+    });
 
-    return typedCaseCount >= 2;
+    const [firstTypedCase, secondTypedCase] = typedCases;
+    return firstTypedCase !== undefined && secondTypedCase !== undefined;
   });
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pumuki",
-  "version": "6.3.122",
+  "version": "6.3.124",
   "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": {