empathy-framework 4.6.6__py3-none-any.whl → 4.7.0__py3-none-any.whl

empathy_os/workflows/progressive/telemetry.py

@@ -8,11 +8,7 @@ from datetime import datetime
 from typing import Any
 
 from empathy_os.telemetry.usage_tracker import UsageTracker
-from empathy_os.workflows.progressive.core import (
-    ProgressiveWorkflowResult,
-    Tier,
-    TierResult,
-)
+from empathy_os.workflows.progressive.core import ProgressiveWorkflowResult, Tier, TierResult
 
 logger = logging.getLogger(__name__)
 
@@ -135,9 +131,11 @@ class ProgressiveTelemetry:
                     "all_premium_cost": all_premium_cost,
                     "tier_breakdown": tier_breakdown,
                     "success": result.success,
-                    "final_cqs": result.final_result.failure_analysis.calculate_quality_score()
-                    if result.final_result.failure_analysis
-                    else None,
+                    "final_cqs": (
+                        result.final_result.failure_analysis.calculate_quality_score()
+                        if result.final_result.failure_analysis
+                        else None
+                    ),
                 },
             )
 
@@ -206,9 +204,7 @@ class ProgressiveTelemetry:
                 },
             )
 
-            logger.warning(
-                f"Budget exceeded: ${current_cost:.3f} > ${max_budget:.3f} ({action})"
-            )
+            logger.warning(f"Budget exceeded: ${current_cost:.3f} > ${max_budget:.3f} ({action})")
 
         except Exception as e:
             logger.warning(f"Failed to track budget exceeded: {e}")
@@ -234,9 +230,7 @@ class ProgressiveTelemetry:
             event = {
                 "timestamp": datetime.now().isoformat(),
                 "event_type": event_type,
-                "user_id_hash": (
-                    self._hash_user_id(self.user_id) if self.user_id else "anonymous"
-                ),
+                "user_id_hash": (self._hash_user_id(self.user_id) if self.user_id else "anonymous"),
                 **data,
             }
 

empathy_os/workflows/progressive/test_gen.py

@@ -90,11 +90,7 @@ class ProgressiveTestGenWorkflow(ProgressiveWorkflow):
         logger.info(f"Found {len(functions)} functions to test")
 
         # Execute with progressive escalation
-        return self._execute_progressive(
-            items=functions,
-            workflow_name="test-gen",
-            **kwargs
-        )
+        return self._execute_progressive(items=functions, workflow_name="test-gen", **kwargs)
 
     def _parse_functions(self, file_path: Path) -> list[dict[str, Any]]:
         """Parse Python file to extract function definitions.
@@ -133,18 +129,14 @@ class ProgressiveTestGenWorkflow(ProgressiveWorkflow):
                     "args": [arg.arg for arg in node.args.args],
                     "docstring": ast.get_docstring(node) or "",
                     "code": ast.unparse(node),  # Python 3.9+
-                    "file": str(file_path)
+                    "file": str(file_path),
                 }
                 functions.append(func_info)
 
         return functions
 
     def _execute_tier_impl(
-        self,
-        tier: Tier,
-        items: list[Any],
-        context: dict[str, Any] | None,
-        **kwargs
+        self, tier: Tier, items: list[Any], context: dict[str, Any] | None, **kwargs
     ) -> list[dict[str, Any]]:
         """Execute test generation at specific tier.
 
@@ -165,11 +157,7 @@ class ProgressiveTestGenWorkflow(ProgressiveWorkflow):
 
         # Build prompt for this tier (prepared for future LLM integration)
         base_task = self._build_test_gen_task(items)
-        _prompt = self.meta_orchestrator.build_tier_prompt(  # noqa: F841
-            tier,
-            base_task,
-            context
-        )
+        _prompt = self.meta_orchestrator.build_tier_prompt(tier, base_task, context)  # noqa: F841
 
         # TODO: Call LLM API with _prompt
         # For now, simulate test generation
@@ -202,9 +190,7 @@ class ProgressiveTestGenWorkflow(ProgressiveWorkflow):
         return task
 
     def _simulate_test_generation(
-        self,
-        tier: Tier,
-        functions: list[dict[str, Any]]
+        self, tier: Tier, functions: list[dict[str, Any]]
     ) -> list[dict[str, Any]]:
         """Simulate test generation (placeholder for LLM integration).
 
@@ -232,7 +218,7 @@ class ProgressiveTestGenWorkflow(ProgressiveWorkflow):
         _base_quality = {  # noqa: F841
             Tier.CHEAP: 70,
             Tier.CAPABLE: 85,
-            Tier.PREMIUM: 95
+            Tier.PREMIUM: 95,
         }[tier]
 
         for func in functions:
@@ -245,17 +231,19 @@ class ProgressiveTestGenWorkflow(ProgressiveWorkflow):
             # Calculate quality score
             quality_score = analysis.calculate_quality_score()
 
-            generated_tests.append({
-                "function_name": func["name"],
-                "test_code": test_code,
-                "quality_score": quality_score,
-                "passed": analysis.test_pass_rate > 0.5,
-                "coverage": analysis.coverage_percent,
-                "assertions": analysis.assertion_depth,
-                "confidence": analysis.confidence_score,
-                "syntax_errors": [str(e) for e in analysis.syntax_errors],
-                "error": "" if not analysis.syntax_errors else str(analysis.syntax_errors[0])
-            })
+            generated_tests.append(
+                {
+                    "function_name": func["name"],
+                    "test_code": test_code,
+                    "quality_score": quality_score,
+                    "passed": analysis.test_pass_rate > 0.5,
+                    "coverage": analysis.coverage_percent,
+                    "assertions": analysis.assertion_depth,
+                    "confidence": analysis.confidence_score,
+                    "syntax_errors": [str(e) for e in analysis.syntax_errors],
+                    "error": "" if not analysis.syntax_errors else str(analysis.syntax_errors[0]),
+                }
+            )
 
         return generated_tests
 
@@ -312,11 +300,7 @@ class ProgressiveTestGenWorkflow(ProgressiveWorkflow):
 
         return "\n    ".join(setup_lines)
 
-    def _analyze_generated_test(
-        self,
-        test_code: str,
-        func: dict[str, Any]
-    ) -> FailureAnalysis:
+    def _analyze_generated_test(self, test_code: str, func: dict[str, Any]) -> FailureAnalysis:
         """Analyze quality of generated test.
 
         Args:
@@ -338,10 +322,7 @@ class ProgressiveTestGenWorkflow(ProgressiveWorkflow):
         # 2. Count assertions
         try:
             tree = ast.parse(test_code)
-            assertion_count = sum(
-                1 for node in ast.walk(tree)
-                if isinstance(node, ast.Assert)
-            )
+            assertion_count = sum(1 for node in ast.walk(tree) if isinstance(node, ast.Assert))
             analysis.assertion_depth = assertion_count
         except Exception as e:
             logger.warning(f"Failed to count assertions: {e}")
@@ -378,7 +359,7 @@ class ProgressiveTestGenWorkflow(ProgressiveWorkflow):
             generated_items=[],
             failure_analysis=FailureAnalysis(),
             cost=0.0,
-            duration=0.0
+            duration=0.0,
         )
 
         task_id = f"{workflow_name}-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
@@ -390,7 +371,7 @@ class ProgressiveTestGenWorkflow(ProgressiveWorkflow):
             final_result=empty_result,
             total_cost=0.0,
             total_duration=0.0,
-            success=False
+            success=False,
         )
 
 
@@ -416,7 +397,7 @@ def execute_test_file(test_file: Path) -> dict[str, Any]:
             ["pytest", str(test_file), "-v", "--tb=short"],
             capture_output=True,
             text=True,
-            timeout=60
+            timeout=60,
         )
 
         # Parse pytest output to get pass/fail counts
@@ -435,7 +416,7 @@ def execute_test_file(test_file: Path) -> dict[str, Any]:
             "total": total,
             "pass_rate": pass_rate,
             "output": output,
-            "returncode": result.returncode
+            "returncode": result.returncode,
         }
 
     except subprocess.TimeoutExpired:
@@ -445,7 +426,7 @@ def execute_test_file(test_file: Path) -> dict[str, Any]:
             "total": 0,
             "pass_rate": 0.0,
             "output": "Test execution timed out",
-            "returncode": -1
+            "returncode": -1,
         }
     except Exception as e:
         logger.error(f"Failed to execute tests: {e}")
@@ -455,7 +436,7 @@ def execute_test_file(test_file: Path) -> dict[str, Any]:
             "total": 0,
             "pass_rate": 0.0,
             "output": str(e),
-            "returncode": -1
+            "returncode": -1,
         }
 
 
@@ -484,12 +465,12 @@ def calculate_coverage(test_file: Path, source_file: Path) -> float:
                 str(test_file),
                 f"--cov={source_file.stem}",
                 "--cov-report=term-missing",
-                "--no-cov-on-fail"
+                "--no-cov-on-fail",
             ],
             capture_output=True,
             text=True,
             timeout=60,
-            cwd=source_file.parent
+            cwd=source_file.parent,
         )
 
         output = result.stdout + result.stderr

empathy_os/workflows/progressive/workflow.py

@@ -24,11 +24,13 @@ logger = logging.getLogger(__name__)
 
 class BudgetExceededError(Exception):
     """Raised when execution cost exceeds configured budget."""
+
     pass
 
 
 class UserCancelledError(Exception):
     """Raised when user cancels execution during approval prompt."""
+
     pass
 
 
@@ -96,10 +98,7 @@ class ProgressiveWorkflow:
         raise NotImplementedError("Subclasses must implement execute()")
 
     def _execute_progressive(
-        self,
-        items: list[Any],
-        workflow_name: str,
-        **kwargs
+        self, items: list[Any], workflow_name: str, **kwargs
     ) -> ProgressiveWorkflowResult:
         """Execute items with progressive tier escalation.
 
@@ -129,8 +128,7 @@ class ProgressiveWorkflow:
         # Estimate cost and request approval
         estimated_cost = self._estimate_total_cost(len(items))
         if not self._request_approval(
-            f"Execute {workflow_name} on {len(items)} items",
-            estimated_cost
+            f"Execute {workflow_name} on {len(items)} items", estimated_cost
         ):
             raise UserCancelledError("User declined to proceed")
 
@@ -140,17 +138,10 @@ class ProgressiveWorkflow:
         context: dict[str, Any] | None = None
 
         while remaining_items and current_tier:
-            logger.info(
-                f"Executing {len(remaining_items)} items at {current_tier.value} tier"
-            )
+            logger.info(f"Executing {len(remaining_items)} items at {current_tier.value} tier")
 
             # Execute at current tier
-            tier_result = self._execute_tier(
-                current_tier,
-                remaining_items,
-                context,
-                **kwargs
-            )
+            tier_result = self._execute_tier(current_tier, remaining_items, context, **kwargs)
 
             self.tier_results.append(tier_result)
 
@@ -167,12 +158,10 @@ class ProgressiveWorkflow:
 
             # Separate successful and failed items
             successful = [
-                item for item in tier_result.generated_items
-                if item.get("quality_score", 0) >= 80
+                item for item in tier_result.generated_items if item.get("quality_score", 0) >= 80
             ]
             failed = [
-                item for item in tier_result.generated_items
-                if item.get("quality_score", 0) < 80
+                item for item in tier_result.generated_items if item.get("quality_score", 0) < 80
             ]
 
             logger.info(
@@ -189,9 +178,7 @@ class ProgressiveWorkflow:
                 break
 
             should_escalate, reason = self._should_escalate(
-                current_tier,
-                tier_result,
-                attempt=tier_result.attempt
+                current_tier, tier_result, attempt=tier_result.attempt
             )
 
             if should_escalate:
@@ -230,16 +217,13 @@ class ProgressiveWorkflow:
                     "previous_cqs": tier_result.quality_score,
                     "failures": failed,
                     "examples": tier_result.generated_items[-3:],  # Last 3 attempts
-                    "reason": reason
+                    "reason": reason,
                 }
 
                 # Request approval for escalation
                 escalation_cost = self._estimate_tier_cost(next_tier, len(remaining_items))
                 if not self._request_escalation_approval(
-                    current_tier,
-                    next_tier,
-                    len(remaining_items),
-                    escalation_cost
+                    current_tier, next_tier, len(remaining_items), escalation_cost
                 ):
                     logger.info("User declined escalation, stopping")
                     break
@@ -265,7 +249,7 @@ class ProgressiveWorkflow:
             final_result=self.tier_results[-1],
             total_cost=sum(r.cost for r in self.tier_results),
             total_duration=sum(r.duration for r in self.tier_results),
-            success=len(remaining_items) == 0
+            success=len(remaining_items) == 0,
         )
 
         # Track workflow completion in telemetry
@@ -275,10 +259,7 @@ class ProgressiveWorkflow:
         return result
 
     def _execute_single_tier(
-        self,
-        items: list[Any],
-        workflow_name: str,
-        **kwargs
+        self, items: list[Any], workflow_name: str, **kwargs
     ) -> ProgressiveWorkflowResult:
         """Execute without progressive escalation (single tier).
 
@@ -307,15 +288,11 @@ class ProgressiveWorkflow:
             final_result=tier_result,
             total_cost=tier_result.cost,
             total_duration=tier_result.duration,
-            success=tier_result.quality_score >= 80
+            success=tier_result.quality_score >= 80,
         )
 
     def _execute_tier(
-        self,
-        tier: Tier,
-        items: list[Any],
-        context: dict[str, Any] | None,
-        **kwargs
+        self, tier: Tier, items: list[Any], context: dict[str, Any] | None, **kwargs
     ) -> TierResult:
         """Execute items at a specific tier.
 
@@ -353,7 +330,7 @@ class ProgressiveWorkflow:
                 generated_items=generated_items,
                 failure_analysis=failure_analysis,
                 cost=cost,
-                duration=duration
+                duration=duration,
             )
 
         except Exception as e:
@@ -370,15 +347,11 @@ class ProgressiveWorkflow:
                 cost=0.0,
                 duration=duration,
                 escalated=True,
-                escalation_reason=f"Execution error: {str(e)}"
+                escalation_reason=f"Execution error: {str(e)}",
             )
 
     def _execute_tier_impl(
-        self,
-        tier: Tier,
-        items: list[Any],
-        context: dict[str, Any] | None,
-        **kwargs
+        self, tier: Tier, items: list[Any], context: dict[str, Any] | None, **kwargs
     ) -> list[dict[str, Any]]:
         """Execute items at specific tier (to be implemented by subclasses).
 
@@ -419,15 +392,10 @@ class ProgressiveWorkflow:
             test_pass_rate=passed / total_items if total_items > 0 else 0.0,
             coverage_percent=avg_coverage,
             assertion_depth=avg_assertions,
-            confidence_score=avg_confidence
+            confidence_score=avg_confidence,
         )
 
-    def _should_escalate(
-        self,
-        tier: Tier,
-        result: TierResult,
-        attempt: int
-    ) -> tuple[bool, str]:
+    def _should_escalate(self, tier: Tier, result: TierResult, attempt: int) -> tuple[bool, str]:
         """Determine if escalation is needed.
 
         Uses meta-orchestrator to make intelligent escalation decisions
@@ -441,12 +409,7 @@ class ProgressiveWorkflow:
         Returns:
             Tuple of (should_escalate, reason)
         """
-        return self.meta_orchestrator.should_escalate(
-            tier,
-            result,
-            attempt,
-            self.config
-        )
+        return self.meta_orchestrator.should_escalate(tier, result, attempt, self.config)
 
     def _get_next_tier(self, current_tier: Tier) -> Tier | None:
         """Get the next tier in the progression.
@@ -496,9 +459,9 @@ class ProgressiveWorkflow:
         """
         # Cost per item (approximate, based on typical token usage)
         COST_PER_ITEM = {
-            Tier.CHEAP: 0.003,     # ~$0.003 per item (gpt-4o-mini)
-            Tier.CAPABLE: 0.015,   # ~$0.015 per item (claude-3-5-sonnet)
-            Tier.PREMIUM: 0.05     # ~$0.05 per item (claude-opus-4)
+            Tier.CHEAP: 0.003,  # ~$0.003 per item (gpt-4o-mini)
+            Tier.CAPABLE: 0.015,  # ~$0.015 per item (claude-3-5-sonnet)
+            Tier.PREMIUM: 0.05,  # ~$0.05 per item (claude-opus-4)
         }
 
         return COST_PER_ITEM[tier] * item_count
@@ -530,7 +493,9 @@ class ProgressiveWorkflow:
         """
         # Check auto-approve threshold
         if self.config.auto_approve_under and estimated_cost <= self.config.auto_approve_under:
-            logger.info(f"Auto-approved: ${estimated_cost:.2f} <= ${self.config.auto_approve_under:.2f}")
+            logger.info(
+                f"Auto-approved: ${estimated_cost:.2f} <= ${self.config.auto_approve_under:.2f}"
+            )
             return True
 
         # Check if under default threshold ($1.00)
@@ -546,14 +511,10 @@ class ProgressiveWorkflow:
         print()
 
         response = input("Proceed? [y/N]: ").strip().lower()
-        return response == 'y'
+        return response == "y"
 
     def _request_escalation_approval(
-        self,
-        from_tier: Tier,
-        to_tier: Tier,
-        item_count: int,
-        additional_cost: float
+        self, from_tier: Tier, to_tier: Tier, item_count: int, additional_cost: float
     ) -> bool:
         """Request approval for tier escalation.
 
@@ -580,7 +541,7 @@ class ProgressiveWorkflow:
         print()
 
         response = input("Proceed? [Y/n]: ").strip().lower()
-        return response != 'n'
+        return response != "n"
 
     def _check_budget(self) -> None:
         """Check if budget has been exceeded.
@@ -622,7 +583,7 @@ class ProgressiveWorkflow:
         MODEL_MAP = {
             Tier.CHEAP: "gpt-4o-mini",
             Tier.CAPABLE: "claude-3-5-sonnet",
-            Tier.PREMIUM: "claude-opus-4"
+            Tier.PREMIUM: "claude-opus-4",
         }
 
         return MODEL_MAP.get(tier, "claude-3-5-sonnet")

empathy_os/workflows/release_prep.py

@@ -321,12 +321,27 @@ class ReleasePreparationWorkflow(BaseWorkflow):
 
         Falls back gracefully if SecurityAuditCrew is not available.
         """
-        from .security_adapters import (
-            _check_crew_available,
-            _get_crew_audit,
-            crew_report_to_workflow_format,
-            merge_security_results,
-        )
+        try:
+            from .security_adapters import (
+                _check_crew_available,
+                _get_crew_audit,
+                crew_report_to_workflow_format,
+                merge_security_results,
+            )
+        except ImportError:
+            # Security adapters removed - return fallback
+            return (
+                {
+                    "crew_security": {
+                        "available": False,
+                        "fallback": True,
+                        "reason": "Security adapters not installed",
+                    },
+                    **input_data,
+                },
+                0,
+                0,
+            )
 
         target_path = input_data.get("path", ".")
         existing_security = input_data.get("security", {})

empathy_os/workflows/release_prep_crew.py

@@ -21,6 +21,7 @@ Agents:
 Copyright 2025 Smart-AI-Memory
 Licensed under Fair Source License 0.9
 """
+
 import asyncio
 import os
 import warnings

empathy_os/workflows/secure_release.py

@@ -160,11 +160,18 @@ class SecureReleasePipeline:
             SecureReleaseResult with combined analysis
 
         """
-        from .security_adapters import (
-            _check_crew_available,
-            _get_crew_audit,
-            crew_report_to_workflow_format,
-        )
+        try:
+            from .security_adapters import (
+                _check_crew_available,
+                _get_crew_audit,
+                crew_report_to_workflow_format,
+            )
+            adapters_available = True
+        except ImportError:
+            adapters_available = False
+            _check_crew_available = lambda: False
+            _get_crew_audit = None
+            crew_report_to_workflow_format = None
 
         started_at = datetime.now()
 
@@ -181,7 +188,7 @@ class SecureReleasePipeline:
         try:
             # Step 1: SecurityAuditCrew (parallel or first)
             crew_task = None
-            crew_enabled = self.use_crew and _check_crew_available()
+            crew_enabled = self.use_crew and adapters_available and _check_crew_available()
 
             if crew_enabled:
                 if self.parallel_crew:

empathy_os/workflows/security_audit.py

@@ -58,7 +58,7 @@ SKIP_DIRECTORIES = {
     ".coverage",  # Coverage data
     "vscode-extension",  # VSCode extension code (separate security review)
     "vscode-memory-panel",  # VSCode panel code
-    "wizard-dashboard",  # Dashboard build
+    "workflow-dashboard",  # Dashboard build
 }
 
 # Patterns that indicate a line is DETECTION code, not vulnerable code
@@ -672,7 +672,12 @@ class SecurityAuditWorkflow(BaseWorkflow):
 
         Supports XML-enhanced prompts when enabled in workflow config.
         """
-        from .security_adapters import _check_crew_available
+        try:
+            from .security_adapters import _check_crew_available
+            adapters_available = True
+        except ImportError:
+            adapters_available = False
+            _check_crew_available = lambda: False
 
         assessment = input_data.get("assessment", {})
         critical = assessment.get("critical_findings", [])
@@ -683,7 +688,7 @@ class SecurityAuditWorkflow(BaseWorkflow):
         crew_enhanced = False
 
         # Try crew-based remediation first if enabled
-        if self.use_crew_for_remediation and _check_crew_available():
+        if self.use_crew_for_remediation and adapters_available and _check_crew_available():
             crew_remediation = await self._get_crew_remediation(target, critical + high, assessment)
             if crew_remediation:
                 crew_enhanced = True

empathy_os/workflows/test_coverage_boost_crew.py

@@ -11,6 +11,7 @@ to analyze coverage gaps, generate tests, and validate improvements.
 Copyright 2025 Smart AI Memory, LLC
 Licensed under Fair Source 0.9
 """
+
 import asyncio
 import json
 import re
@@ -375,7 +376,7 @@ CRITICAL FORMATTING RULES:
 
                 # Limit code size to avoid token bloat (max ~5000 chars per file)
                 if len(code) > 5000:
-                    code = code[:5000] + f"\n... (truncated, {len(code)-5000} more chars)"
+                    code = code[:5000] + f"\n... (truncated, {len(code) - 5000} more chars)"
 
                 result.append(
                     {
@@ -814,7 +815,7 @@ CRITICAL FORMATTING RULES:
         lines.append(f"Tests Passing: {result.tests_passing}")
         lines.append("")
         lines.append(f"Cost: ${result.cost:.4f}")
-        lines.append(f"Duration: {result.duration_ms}ms ({result.duration_ms/1000:.1f}s)")
+        lines.append(f"Duration: {result.duration_ms}ms ({result.duration_ms / 1000:.1f}s)")
         lines.append("")
 
         if result.gaps_analyzed:

empathy_os/workflows/test_maintenance_crew.py

@@ -16,6 +16,7 @@ The crew can operate autonomously on a schedule or be triggered by events.
 Copyright 2025 Smart AI Memory, LLC
 Licensed under Fair Source 0.9
 """
+
 import heapq
 import logging
 import warnings

empathy_os/workflows/test_runner.py

@@ -562,7 +562,7 @@ def _find_test_file(source_file: str) -> str | None:
     if "src" in source_path.parts:
         try:
             src_idx = source_path.parts.index("src")
-            rel_parts = source_path.parts[src_idx + 1:-1]  # Exclude src and filename
+            rel_parts = source_path.parts[src_idx + 1 : -1]  # Exclude src and filename
             if len(rel_parts) >= 2:
                 # e.g., ('empathy_os', 'models') -> module_name = 'models'
                 module_name = rel_parts[-1]
@@ -572,19 +572,23 @@ def _find_test_file(source_file: str) -> str | None:
     # Priority 1: Module-specific test directory
     # e.g., src/empathy_os/models/registry.py -> tests/unit/models/test_registry.py
     if module_name:
-        patterns.extend([
-            Path("tests") / "unit" / module_name / f"test_{filename}.py",
-            Path("tests") / module_name / f"test_{filename}.py",
-            Path("tests") / "integration" / module_name / f"test_{filename}.py",
-        ])
+        patterns.extend(
+            [
+                Path("tests") / "unit" / module_name / f"test_{filename}.py",
+                Path("tests") / module_name / f"test_{filename}.py",
+                Path("tests") / "integration" / module_name / f"test_{filename}.py",
+            ]
+        )
 
     # Priority 2: Standard locations
-    patterns.extend([
-        Path("tests") / "unit" / f"test_{filename}.py",
-        Path("tests") / f"test_{filename}.py",
-        Path("tests") / "integration" / f"test_{filename}.py",
-        parent / f"test_{filename}.py",
-    ])
+    patterns.extend(
+        [
+            Path("tests") / "unit" / f"test_{filename}.py",
+            Path("tests") / f"test_{filename}.py",
+            Path("tests") / "integration" / f"test_{filename}.py",
+            parent / f"test_{filename}.py",
+        ]
+    )
 
     # Check explicit patterns first
     for pattern in patterns: