devcouncil 0.1.1 → 0.2.1

package/src/devcouncil/execution/prompt_builder.py

@@ -1,59 +0,0 @@
-from pathlib import Path
-from typing import List
-
-from devcouncil.domain.requirement import Requirement
-from devcouncil.domain.task import Task
-from devcouncil.integrations.code_review_graph import CodeReviewGraphAdapter
-
-class PromptBuilder:
-    def __init__(self, project_root: Path = Path(".")):
-        self.project_root = project_root
-
-    def build_task_prompt(self, task: Task, requirements: List[Requirement]) -> str:
-        req_map = {r.id: r for r in requirements}
-        task_reqs = [req_map[rid] for rid in task.requirement_ids if rid in req_map]
-        
-        prompt = f"""# Implement {task.id}: {task.title}
-
-## Goal
-{task.description}
-
-## Requirements
-"""
-        for req in task_reqs:
-            prompt += f"- {req.id}: {req.title}\n"
-            for ac in req.acceptance_criteria:
-                prompt += f"  - [ ] {ac.description} ({ac.verification_method})\n"
-
-        prompt += "\n## Allowed files\n"
-        for pf in task.planned_files:
-            prompt += f"- `{pf.path}` ({pf.allowed_change}): {pf.reason}\n"
-
-        if task.forbidden_changes:
-            prompt += "\n## Forbidden changes\n"
-            for fc in task.forbidden_changes:
-                prompt += f"- `{fc}`\n"
-
-        prompt += "\n## Expected tests\n"
-        for et in task.expected_tests:
-            prompt += f"- `{et}`\n"
-
-        prompt += "\n## Allowed commands\n"
-        for cmd in task.allowed_commands:
-            prompt += f"- `{cmd}`\n"
-
-        graph_context = CodeReviewGraphAdapter(self.project_root).prompt_section(
-            [planned.path for planned in task.planned_files]
-        )
-        if graph_context:
-            prompt += f"\n{graph_context}"
-
-        prompt += """
-## Instructions
-1. Implement the goal described above.
-2. Ensure all acceptance criteria are met.
-3. Only modify the allowed files.
-4. Run the allowed commands to verify your work.
-5. Provide evidence of passing tests.
-"""
-        return prompt

package/src/devcouncil/execution/task_runner.py

@@ -1,166 +0,0 @@
-import hashlib
-import subprocess
-import logging
-import re
-import shlex
-from pathlib import Path
-from typing import Literal, Optional
-from devcouncil.domain.task import Task
-from devcouncil.execution.permissions import PermissionManager
-from devcouncil.domain.evidence import CommandResult
-from devcouncil.app.errors import ExecutionError
-
-from devcouncil.execution.patch import PatchEngine
-from devcouncil.execution.paths import resolve_project_path
-from devcouncil.telemetry.traces import TraceLogger
-from devcouncil.utils.redaction import redact_string
-
-logger = logging.getLogger(__name__)
-
-class TaskRunner:
-    """Safely executes task actions while enforcing permission boundaries."""
-    
-    def __init__(self, project_root: Path, permission_manager: PermissionManager):
-        self.project_root = project_root
-        self.permissions = permission_manager
-        self.patch_engine = PatchEngine(project_root)
-
-    def _validate_path_within_root(self, path: str) -> None:
-        """Ensure a path resolves to a location within the project root."""
-        resolve_project_path(self.project_root, path)
-
-    def apply_patch(self, patch: str, task: Task) -> bool:
-        """Apply a patch if permissions allow (all affected files must be in planned_files)."""
-        changes = self._extract_patch_changes(patch)
-        for path, operation in changes.items():
-            self._validate_path_within_root(path)
-            self.permissions.validate_action("file_write", path, task, operation=operation)
-        applied = self.patch_engine.apply_patch(patch)
-        TraceLogger(self.project_root).log_event(
-            "tool_patch_applied",
-            {"paths": sorted(changes), "success": applied},
-            task_id=task.id,
-            summary=f"Patch {'applied' if applied else 'failed'} for {task.id}",
-        )
-        return applied
-
-    def _extract_patch_paths(self, patch: str) -> set[str]:
-        return set(self._extract_patch_changes(patch))
-
-    def _extract_patch_changes(self, patch: str) -> dict[str, Literal["create", "modify", "delete"]]:
-        """Extract repository-relative file paths touched by a unified git patch."""
-        changes: dict[str, Literal["create", "modify", "delete"]] = {}
-        old_path: Optional[str] = None
-        old_is_null = False
-        for line in patch.splitlines():
-            if line.startswith("diff --git "):
-                parts = line.split()
-                cleaned = self._normalize_patch_path(parts[3]) if len(parts) > 3 else None
-                if cleaned:
-                    changes.setdefault(cleaned, "modify")
-                old_path = self._normalize_patch_path(parts[2]) if len(parts) > 2 else None
-                old_is_null = False
-                continue
-
-            if line.startswith("--- "):
-                raw = line[4:].split("\t", 1)[0].strip()
-                old_is_null = raw == "/dev/null"
-                old_path = self._normalize_patch_path(raw)
-                continue
-
-            if line.startswith("+++ "):
-                raw = line[4:].split("\t", 1)[0].strip()
-                if raw == "/dev/null":
-                    if old_path:
-                        changes[old_path] = "delete"
-                    continue
-                new_path = self._normalize_patch_path(raw)
-                if new_path:
-                    changes[new_path] = "create" if old_is_null else "modify"
-
-        if not changes:
-            raise ExecutionError("Patch does not declare any affected files.")
-        return changes
-
-    def _normalize_patch_path(self, raw_path: str) -> Optional[str]:
-        raw_path = raw_path.strip().strip('"')
-        if raw_path == "/dev/null":
-            return None
-        raw_path = re.sub(r"^[ab]/", "", raw_path)
-        return raw_path.replace("\\", "/")
-
-    def _save_command_log(self, task_id: str, command: str, stream: str, content: str) -> str:
-        """Save command output to a log file and return the path."""
-        log_dir = self.project_root / ".devcouncil" / "logs"
-        log_dir.mkdir(parents=True, exist_ok=True)
-        cmd_hash = hashlib.sha256(command.encode()).hexdigest()[:8]
-        filename = f"{task_id}-{cmd_hash}-{stream}.log"
-        log_path = log_dir / filename
-        log_path.write_text(redact_string(content), encoding="utf-8")
-        return str(log_path)
-
-    def run_command(self, command: str, task: Task) -> CommandResult:
-        """Execute a shell command if allowed by permissions."""
-        self.permissions.validate_action("shell", command, task)
-        
-        logger.info(f"Executing authorized command: {command}")
-        
-        try:
-            from devcouncil.app.config import load_config
-            config = load_config(self.project_root)
-            timeout = config.execution.command_timeout
-        except Exception:
-            timeout = 300
-
-        try:
-            result = subprocess.run(
-                shlex.split(command, posix=False),
-                shell=False,
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-                errors="replace",
-                cwd=self.project_root,
-                timeout=timeout
-            )
-            stdout = result.stdout or ""
-            stderr = result.stderr or ""
-            stdout_path = self._save_command_log(task.id, command, "stdout", stdout)
-            stderr_path = self._save_command_log(task.id, command, "stderr", stderr)
-            stdout_summary = redact_string(stdout[-500:])
-            stderr_summary = redact_string(stderr[-500:])
-            TraceLogger(self.project_root).log_event(
-                "command_executed",
-                {"command": command, "exit_code": result.returncode},
-                task_id=task.id,
-                summary=f"{command} exited {result.returncode}",
-            )
-            return CommandResult(
-                command=command,
-                exit_code=result.returncode,
-                stdout_path=stdout_path,
-                stderr_path=stderr_path,
-                summary=f"Exit code {result.returncode}. stdout: {stdout_summary}. stderr: {stderr_summary}"
-            )
-        except Exception as e:
-            raise ExecutionError(f"Command execution failed: {e}")
-
-    def write_file(self, path: str, content: str, task: Task):
-        """Write content to a file if allowed by permissions."""
-        self._validate_path_within_root(path)
-        full_path = resolve_project_path(self.project_root, path)
-        operation = "modify" if full_path.exists() else "create"
-        self.permissions.validate_action("file_write", path, task, operation=operation)
-
-        logger.info(f"Writing authorized file: {path}")
-        try:
-            full_path.parent.mkdir(parents=True, exist_ok=True)
-            full_path.write_text(content, encoding="utf-8")
-            TraceLogger(self.project_root).log_event(
-                "file_written",
-                {"path": path},
-                task_id=task.id,
-                summary=f"Wrote {path}",
-            )
-        except Exception as e:
-            raise ExecutionError(f"Failed to write file {path}: {e}")

package/src/devcouncil/executors/__init__.py

@@ -1 +0,0 @@
-

package/src/devcouncil/executors/coding_cli.py

@@ -1,112 +0,0 @@
-import shutil
-import subprocess
-import os
-from pathlib import Path
-
-from rich.console import Console
-
-from devcouncil.domain.requirement import Requirement
-from devcouncil.domain.task import Task
-from devcouncil.execution.executor import Executor, ExecutionResult
-from devcouncil.execution.prompt_builder import PromptBuilder
-
-console = Console()
-
-
-class CodingCliExecutor(Executor):
-    """Execute a DevCouncil task by handing it off to an external coding CLI."""
-
-    _ALIASES = {
-        "codex-cli": "codex",
-        "gemini-cli": "gemini",
-        "claude-cli": "claude",
-        "claude-code": "claude",
-    }
-
-    def __init__(self, project_root: Path, client: str, timeout_seconds: int = 1800):
-        self.client = self._normalize_client(client)
-        self.project_root = project_root
-        self.timeout_seconds = timeout_seconds
-
-    def _normalize_client(self, client: str) -> str:
-        normalized = (client or "").strip().lower().replace("_", "-")
-        return self._ALIASES.get(normalized, normalized)
-
-    def _command(self) -> list[str]:
-        if self.client == "codex":
-            return ["codex", "exec", "-"]
-        if self.client == "gemini":
-            return ["gemini"]
-        if self.client == "claude":
-            return ["claude", "-p"]
-        raise ValueError(f"Unsupported coding CLI client: {self.client}")
-
-    def run_task(self, task: Task, requirements: list[Requirement]) -> ExecutionResult:
-        try:
-            command = self._command()
-        except ValueError as exc:
-            return ExecutionResult(success=False, message=str(exc))
-
-        executable = command[0]
-        if not shutil.which(executable):
-            return ExecutionResult(
-                success=False,
-                message=f"{self.client} CLI is not installed or not on PATH.",
-            )
-
-        prompt = PromptBuilder(self.project_root).build_task_prompt(task, requirements)
-        instruction_file = self.project_root / ".devcouncil" / f"{task.id}-{self.client}-task.md"
-        instruction_file.parent.mkdir(parents=True, exist_ok=True)
-        instruction_file.write_text(prompt, encoding="utf-8")
-
-        env = {**dict(os.environ), "DEVCOUNCIL_PROJECT_ROOT": str(self.project_root)}
-        log_prefix = f"{task.id}-{self.client}"
-
-        console.print(f"Starting [bold]{self.client.upper()}[/bold] for task [bold]{task.id}[/bold]...")
-        console.print(f"Task prompt: [dim]{instruction_file}[/dim]")
-        console.print(f"Command: [dim]{' '.join(command)}[/dim]")
-
-        try:
-            result = subprocess.run(
-                command,
-                input=prompt,
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-                errors="replace",
-                cwd=self.project_root,
-                env=env,
-                timeout=self.timeout_seconds,
-            )
-            self._write_log(log_prefix, result)
-            if result.returncode != 0:
-                stderr_preview = (result.stderr or result.stdout or "").strip().splitlines()[:5]
-                detail = stderr_preview[0] if stderr_preview else "No diagnostics were produced."
-                return ExecutionResult(
-                    success=False,
-                    message=f"{self.client} exited with code {result.returncode}: {detail}",
-                )
-            return ExecutionResult(success=True, message=f"{self.client} execution finished.")
-        except subprocess.TimeoutExpired as exc:
-            _ = exc
-            return ExecutionResult(
-                success=False,
-                message=f"{self.client} execution timed out after {self.timeout_seconds}s.",
-            )
-        except Exception as exc:
-            return ExecutionResult(success=False, message=str(exc))
-
-    def _write_log(self, task_client: str, result: subprocess.CompletedProcess[str]) -> None:
-        log_dir = self.project_root / ".devcouncil" / "logs"
-        log_dir.mkdir(parents=True, exist_ok=True)
-        log_path = log_dir / f"{task_client}.log"
-        log_path.write_text(
-            "\n".join([
-                f"command_returncode={result.returncode}",
-                "=== stdout ===",
-                result.stdout or "",
-                "=== stderr ===",
-                result.stderr or "",
-            ]),
-            encoding="utf-8",
-        )

package/src/devcouncil/executors/mini_swe.py

@@ -1,73 +0,0 @@
-import subprocess
-import sys
-from pathlib import Path
-from rich.console import Console
-from devcouncil.domain.task import Task
-from devcouncil.domain.requirement import Requirement
-from devcouncil.execution.executor import Executor, ExecutionResult
-from devcouncil.execution.prompt_builder import PromptBuilder
-
-console = Console()
-
-class MiniSWEExecutor(Executor):
-    def __init__(self, project_root: Path):
-        self.project_root = project_root
-
-    def run_task(self, task: Task, requirements: list[Requirement]) -> ExecutionResult:
-        builder = PromptBuilder(self.project_root)
-        task_prompt = builder.build_task_prompt(task, requirements)
-        
-        # Write temporary instruction file for mini-SWE-agent
-        instruction_file = self.project_root / ".devcouncil" / f"{task.id}-mini-swe-task.md"
-        instruction_file.parent.mkdir(parents=True, exist_ok=True)
-        instruction_file.write_text(task_prompt, encoding="utf-8")
-        
-        console.print(f"Starting [bold]mini-SWE-agent[/bold] for task {task.id}...")
-        
-        # In a real implementation, we'd invoke the agent CLI
-        # For now, we simulate the command call
-        cmd = [
-            sys.executable, "-m", "mini_swe_agent.main",
-            "--instruction-file", str(instruction_file),
-            "--repo-path", str(self.project_root)
-        ]
-        
-        console.print(f"Command: [dim]{' '.join(cmd)}[/dim]")
-        
-        # Since I might not have mini_swe_agent installed here, 
-        # I'll just explain what it would do.
-        console.print("[yellow]Note: mini_swe_agent must be installed in the environment.[/yellow]")
-        
-        try:
-            result = subprocess.run(
-                cmd,
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-                errors="replace",
-                cwd=self.project_root,
-                timeout=1800,
-            )
-            self._write_log(task.id, result)
-            if result.returncode != 0:
-                console.print(f"[red]mini-SWE-agent exited with {result.returncode}.[/red]")
-                return ExecutionResult(success=False, message='Execution failed')
-            return ExecutionResult(success=True, message='Execution successful')
-        except Exception as e:
-            console.print(f"[red]Error running mini-SWE-agent: {e}[/red]")
-            return ExecutionResult(success=False, message='Execution failed')
-
-    def _write_log(self, task_id: str, result: subprocess.CompletedProcess[str]) -> None:
-        log_dir = self.project_root / ".devcouncil" / "logs"
-        log_dir.mkdir(parents=True, exist_ok=True)
-        log_path = log_dir / f"{task_id}-mini-swe.log"
-        log_path.write_text(
-            "\n".join([
-                f"command_returncode={result.returncode}",
-                "=== stdout ===",
-                result.stdout or "",
-                "=== stderr ===",
-                result.stderr or "",
-            ]),
-            encoding="utf-8",
-        )

package/src/devcouncil/executors/native/agent.py

@@ -1,107 +0,0 @@
-from typing import List, Dict, Any
-from rich.console import Console
-from pydantic import BaseModel
-from devcouncil.domain.task import Task
-from devcouncil.domain.requirement import Requirement
-from devcouncil.execution.executor import Executor, ExecutionResult
-from devcouncil.llm.router import ModelRouter
-from devcouncil.execution.task_runner import TaskRunner
-from devcouncil.execution.context_builder import ContextBuilder
-from devcouncil.execution.paths import resolve_project_path
-
-console = Console()
-
-class ToolCall(BaseModel):
-    tool: str
-    args: Dict[str, Any]
-
-class AgentAction(BaseModel):
-    thought: str
-    tool_calls: List[ToolCall] = []
-    finish: bool = False
-
-class NativeAgent(Executor):
-    def __init__(self, router: ModelRouter, task_runner: TaskRunner):
-        self.router = router
-        self.task_runner = task_runner
-        self.context_builder = ContextBuilder(task_runner.project_root)
-
-    async def run_task(self, task: Task, requirements: List[Requirement]) -> ExecutionResult:
-        console.print(f"Starting [bold]Native Executor[/bold] for task {task.id}...")
-        
-        # 1. Gather rich context
-        context_json = self.context_builder.build_task_context(task, requirements)
-        
-        system_prompt = f"""
-You are the DevCouncil Native Agent. Your goal is to implement the provided task.
-Current Project Context:
-{context_json}
-
-You have access to the following tools:
-- read_file(path: str)
-- list_files()
-- apply_patch(patch: str)
-- run_command(command: str)
-
-Rules:
-1. You can only write to files or apply patches to files listed in the task's 'planned_files'.
-2. You can only run commands listed in the task's 'allowed_commands'.
-3. Use 'thought' to explain your reasoning.
-4. Set 'finish' to true when you believe the task is complete and verified.
-"""
-        messages = [{"role": "system", "content": system_prompt}]
-        
-        # Initial task prompt
-        messages.append({"role": "user", "content": f"Begin implementing task {task.id} based on the context provided."})
-
-        # Basic tool loop (Max 10 steps for safety in MVP)
-        for step in range(10):
-            action = await self.router.complete_structured(
-                role="native_agent", 
-                messages=messages,
-                schema=AgentAction
-            )
-            
-            console.print(f"\n[bold]Step {step+1}:[/bold] {action.thought}")
-            
-            if action.finish:
-                console.print("[green]Native agent signaled completion.[/green]")
-                return ExecutionResult(success=True, message="Agent signaled completion")
-
-            for tool_call in action.tool_calls:
-                result_summary = ""
-                try:
-                    if tool_call.tool == "read_file":
-                        path = tool_call.args["path"]
-                        resolved = resolve_project_path(self.task_runner.project_root, path)
-                        # Security: block reading sensitive files
-                        sensitive_patterns = {".env", ".pem", ".key", "credentials", "secrets"}
-                        path_lower = path.lower()
-                        if any(s in path_lower for s in sensitive_patterns):
-                            raise PermissionError(f"Reading sensitive file blocked: {path}")
-                        content = resolved.read_text(encoding="utf-8")
-                        if len(content) > 8000:
-                            content = content[:8000] + "\n[truncated]"
-                        result_summary = f"File content of {path}:\n{content}"
-                    elif tool_call.tool == "list_files":
-                        # We use the internal helper but return limited list
-                        files = self.context_builder.get_structure_summary()
-                        result_summary = f"Found {len(files)} files in repository."
-                    elif tool_call.tool == "write_file":
-                        raise PermissionError("write_file is disabled for the native executor; use apply_patch.")
-                    elif tool_call.tool == "apply_patch":
-                        self.task_runner.apply_patch(tool_call.args["patch"], task)
-                        result_summary = "Successfully applied patch."
-                    elif tool_call.tool == "run_command":
-                        cmd_result = self.task_runner.run_command(tool_call.args["command"], task)
-                        result_summary = f"Command finished with exit code {cmd_result.exit_code}."
-                    else:
-                        raise ValueError(f"Unknown tool: {tool_call.tool}")
-                    
-                    messages.append({"role": "user", "content": f"[Tool Result] '{tool_call.tool}': {result_summary}"})
-                except Exception as e:
-                    console.print(f"[red]Error executing tool {tool_call.tool}: {e}[/red]")
-                    messages.append({"role": "user", "content": f"[Tool Error] '{tool_call.tool}' failed: {e}"})
-
-        console.print("[red]Native agent reached maximum step limit.[/red]")
-        return ExecutionResult(success=False, message="Reached maximum step limit")

package/src/devcouncil/executors/openhands.py

@@ -1,71 +0,0 @@
-import subprocess
-from pathlib import Path
-from rich.console import Console
-from devcouncil.domain.task import Task
-from devcouncil.domain.requirement import Requirement
-from devcouncil.execution.executor import Executor, ExecutionResult
-from devcouncil.execution.prompt_builder import PromptBuilder
-
-console = Console()
-
-class OpenHandsExecutor(Executor):
-    def __init__(self, project_root: Path):
-        self.project_root = project_root
-
-    def run_task(self, task: Task, requirements: list[Requirement]) -> ExecutionResult:
-        builder = PromptBuilder(self.project_root)
-        task_prompt = builder.build_task_prompt(task, requirements)
-        
-        console.print(f"Starting [bold]OpenHands[/bold] for task {task.id}...")
-        
-        # OpenHands often expects a workspace mount and an instruction.
-        # Keep the full prompt out of argv so Windows command-line limits and
-        # terminal logs do not become part of the execution boundary.
-        # Reference: https://github.com/All-Hands-AI/OpenHands
-        instruction_file = self.project_root / ".devcouncil" / f"{task.id}-openhands-task.md"
-        instruction_file.parent.mkdir(parents=True, exist_ok=True)
-        instruction_file.write_text(task_prompt, encoding="utf-8")
-        
-        cmd = [
-            "openhands", "run",
-            "--workspace-base", str(self.project_root),
-            "--task-file", str(instruction_file),
-            "--headless"
-        ]
-        
-        console.print(f"Command: [dim]{' '.join(cmd)}[/dim]")
-        console.print("[yellow]Note: OpenHands must be installed and configured in the environment.[/yellow]")
-        
-        try:
-            result = subprocess.run(
-                cmd,
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-                errors="replace",
-                cwd=self.project_root,
-                timeout=1800,
-            )
-            self._write_log(task.id, result)
-            if result.returncode != 0:
-                console.print(f"[red]OpenHands exited with {result.returncode}.[/red]")
-                return ExecutionResult(success=False, message=f"Exited with code {result.returncode}")
-            return ExecutionResult(success=True, message="Completed successfully")
-        except Exception as e:
-            console.print(f"[red]Error running OpenHands: {e}[/red]")
-            return ExecutionResult(success=False, message=str(e))
-
-    def _write_log(self, task_id: str, result: subprocess.CompletedProcess[str]) -> None:
-        log_dir = self.project_root / ".devcouncil" / "logs"
-        log_dir.mkdir(parents=True, exist_ok=True)
-        log_path = log_dir / f"{task_id}-openhands.log"
-        log_path.write_text(
-            "\n".join([
-                f"command_returncode={result.returncode}",
-                "=== stdout ===",
-                result.stdout or "",
-                "=== stderr ===",
-                result.stderr or "",
-            ]),
-            encoding="utf-8",
-        )

package/src/devcouncil/gating/__init__.py

@@ -1 +0,0 @@
-

package/src/devcouncil/gating/checks/clean_git.py

@@ -1,50 +0,0 @@
-import subprocess
-import logging
-from devcouncil.domain.gap import Gap
-
-logger = logging.getLogger(__name__)
-
-class CleanGitCheck:
-    """Ensures the working tree is clean before a task starts."""
-
-    def _is_runtime_state(self, line: str) -> bool:
-        path = line[3:].strip().replace("\\", "/")
-        return path.startswith(".devcouncil/")
-    
-    def check(self, project_root, task_id: str) -> list[Gap]:
-        try:
-            status = subprocess.check_output(["git", "status", "--porcelain"], cwd=project_root).decode()
-            dirty_lines = [line for line in status.splitlines() if line.strip() and not self._is_runtime_state(line)]
-            if dirty_lines:
-                return [Gap(
-                    id=f"GAP-{task_id}-DIRTY-GIT",
-                    severity="high",
-                    gap_type="architecture_drift",
-                    task_id=task_id,
-                    description="Git working tree is dirty. Execution requires a clean state for checkpointing.",
-                    recommended_fix="Commit or stash your current changes before running the task.",
-                    blocking=True
-                )]
-        except FileNotFoundError:
-            logger.error("Git is not installed or not in PATH.")
-            return [Gap(
-                id=f"GAP-{task_id}-NO-GIT",
-                severity="high",
-                gap_type="architecture_drift",
-                task_id=task_id,
-                description="Git is not available. Cannot verify working tree cleanliness.",
-                recommended_fix="Install git and ensure it is in your PATH.",
-                blocking=True
-            )]
-        except subprocess.CalledProcessError as e:
-            logger.warning("Git status check failed: %s", e)
-            return [Gap(
-                id=f"GAP-{task_id}-GIT-ERROR",
-                severity="medium",
-                gap_type="architecture_drift",
-                task_id=task_id,
-                description=f"Git status check failed: {e}. Directory may not be a git repository.",
-                recommended_fix="Initialize a git repository with 'git init' before running tasks.",
-                blocking=True
-            )]
-        return []