devcouncil 0.2.0 → 0.2.1

package/src/devcouncil/cli/commands/prompt.py

@@ -1,61 +0,0 @@
-import json
-from typing import NoReturn
-import typer
-from rich.console import Console
-from rich.markdown import Markdown
-from devcouncil.cli.commands.init import initialize_project
-from devcouncil.storage.db import get_db
-from devcouncil.storage.repositories import TaskRepository, RequirementRepository
-from pathlib import Path
-
-from devcouncil.execution.prompt_builder import PromptBuilder
-
-app = typer.Typer()
-console = Console()
-
-@app.callback(invoke_without_command=True)
-def prompt(
-    ctx: typer.Context,
-    task_id: str = typer.Argument(..., help="ID of the task to generate a prompt for"),
-    pretty: bool = typer.Option(False, "--pretty", help="Render the prompt for terminal reading."),
-    json_format: bool = typer.Option(False, "--json", help="Output machine-readable JSON: {ok, task_id, prompt}."),
-    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
-):
-    """
-    Generate a constrained prompt for a specific task.
-    """
-    if ctx.invoked_subcommand is not None:
-        return
-
-    def _fail(message: str) -> NoReturn:
-        if json_format:
-            typer.echo(json.dumps({"ok": False, "task_id": task_id, "error": message}, indent=2))
-        else:
-            console.print(f"[red]{message}[/red]")
-        raise typer.Exit(code=1)
-
-    root = project_root.expanduser().resolve()
-    initialize_project(root, quiet=True)
-    db = get_db(root)
-    if not db:
-        _fail("DevCouncil state is unavailable in this directory.")
-
-    with db.get_session() as session:
-        task_repo = TaskRepository(session)
-        req_repo = RequirementRepository(session)
-
-        task = task_repo.get_by_id(task_id)
-        if not task:
-            _fail(f"Task {task_id} not found.")
-
-        reqs = req_repo.get_all()
-
-        builder = PromptBuilder(root)
-        task_prompt = builder.build_task_prompt(task, reqs)
-
-        if json_format:
-            typer.echo(json.dumps({"ok": True, "task_id": task_id, "prompt": task_prompt}, indent=2))
-        elif pretty:
-            console.print(Markdown(task_prompt))
-        else:
-            typer.echo(task_prompt, nl=not task_prompt.endswith("\n"))

package/src/devcouncil/cli/commands/repair.py

@@ -1,89 +0,0 @@
-import typer
-from rich.console import Console
-from devcouncil.storage.db import get_db
-from devcouncil.storage.repositories import TaskRepository, GapRepository
-from devcouncil.planning.repair_service import RepairService
-from devcouncil.execution.context_builder import ContextBuilder
-from devcouncil.llm.provider import create_provider, validate_model_provider
-from devcouncil.llm.router import ModelRouter
-from devcouncil.app.config import load_config, get_api_key
-from devcouncil.cli.commands.init import initialize_project
-import asyncio
-from pathlib import Path
-
-app = typer.Typer()
-console = Console()
-
-async def run_repair_flow(project_root: Path = Path(".")):
-    root = project_root.expanduser().resolve()
-    initialize_project(root, quiet=True)
-    db = get_db(root)
-    if not db:
-        console.print("[red]DevCouncil state is unavailable in this directory.[/red]")
-        return
-
-    with db.get_session() as session:
-        gap_repo = GapRepository(session)
-        task_repo = TaskRepository(session)
-
-        all_gaps = gap_repo.get_all()
-        blocking_gaps = [g for g in all_gaps if g.blocking]
-        
-        if not blocking_gaps:
-            console.print("[green]No blocking gaps found. Nothing to repair![/green]")
-            return
-
-        console.print(f"Found [bold]{len(blocking_gaps)}[/bold] blocking gaps. Orchestrating repair plan...")
-
-        # Load router when credentials are available. Correction manifests have a
-        # deterministic fallback path, so missing model credentials must not block
-        # repair artifact generation.
-        repair_service = None
-        try:
-            config = load_config(root)
-            validate_model_provider(config.models.provider)
-            api_key = get_api_key(config.models.provider, root)
-        except (FileNotFoundError, ValueError) as e:
-            console.print(f"[yellow]{e}[/yellow]")
-        else:
-            provider = create_provider(config.models.provider, api_key, project_root=root)
-            role_config = {name: role.model_dump() for name, role in config.models.roles.items()}
-            router = ModelRouter(provider, role_config, project_root=root)
-            repair_service = RepairService(router)
-        context_builder = ContextBuilder(root)
-        
-        # Build minimal context for repair.
-        project_context = context_builder.get_structure_summary()
-
-        from devcouncil.planning.correction_manifest import write_correction_manifest
-
-        task_ids = {gap.task_id for gap in blocking_gaps if gap.task_id}
-        for scoped_task_id in task_ids:
-            if scoped_task_id:
-                path = write_correction_manifest(root, scoped_task_id, repair_service=repair_service)
-                if path:
-                    console.print(f"  - Wrote correction manifest [dim]{path}[/dim]")
-
-        repair_count = 0
-        if repair_service is not None:
-            repair_output = await repair_service.generate_repair_plan(blocking_gaps, str(project_context))
-            for task in repair_output.suggested_tasks:
-                task.id = f"REPAIR-{task.id}"
-                task_repo.save(task)
-                repair_count += 1
-                console.print(f"  - Created intelligent repair task [bold]{task.id}[/bold]: {task.title}")
-
-        console.print(f"\n[green]Successfully generated {repair_count} repair tasks.[/green]")
-
-@app.callback(invoke_without_command=True)
-def repair(
-    ctx: typer.Context,
-    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
-):
-    """
-    Convert blocking gaps into intelligent repair tasks using LLM inference.
-    """
-    if ctx.invoked_subcommand is not None:
-        return
-
-    asyncio.run(run_repair_flow(project_root))

package/src/devcouncil/cli/commands/report.py

@@ -1,137 +0,0 @@
-import typer
-from rich.console import Console
-from rich.markdown import Markdown
-from devcouncil.storage.db import get_db
-from devcouncil.storage.repositories import ArtifactGraphRepository
-from devcouncil.reporting.report_builder import ReportBuilder
-from devcouncil.integrations.github import GitHubIntegration
-from devcouncil.integrations.pr_comments import GitHubPRCommenter, GitLabMRCommenter, build_pr_comment_body
-from devcouncil.artifacts.graph import ArtifactGraph
-from devcouncil.telemetry.traces import TraceLogger
-from devcouncil.cli.commands.init import initialize_project
-from devcouncil.live.summary import live_review_summary
-import asyncio
-import os
-import subprocess
-from pathlib import Path
-
-app = typer.Typer()
-console = Console()
-
-async def run_github_report(graph: ArtifactGraph, project_root: Path):
-    token = os.environ.get("GITHUB_TOKEN")
-    repo = os.environ.get("GITHUB_REPOSITORY") # e.g. owner/repo
-    
-    if not token or not repo:
-        console.print("[red]GITHUB_TOKEN and GITHUB_REPOSITORY must be set for GitHub reporting.[/red]")
-        return
-
-    try:
-        # Detect current SHA
-        sha = subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=project_root).decode().strip()
-        integration = GitHubIntegration(token, repo, sha)
-        await integration.report_verification(graph)
-        console.print(f"[green]Successfully reported to GitHub PR Checks for {repo} at {sha[:7]}[/green]")
-    except Exception as e:
-        console.print(f"[red]Failed to report to GitHub: {e}[/red]")
-
-
-async def run_github_pr_comment(graph: ArtifactGraph, live_review: dict | None = None):
-    token = os.environ.get("GITHUB_TOKEN")
-    repo = os.environ.get("GITHUB_REPOSITORY")
-    pull_number = os.environ.get("GITHUB_PR_NUMBER") or os.environ.get("PR_NUMBER")
-    if not token or not repo or not pull_number:
-        console.print("[red]GITHUB_TOKEN, GITHUB_REPOSITORY, and GITHUB_PR_NUMBER must be set for GitHub PR comments.[/red]")
-        return
-    try:
-        pull_number_int = int(pull_number)
-    except ValueError:
-        console.print("[red]GITHUB_PR_NUMBER must be an integer.[/red]")
-        return
-    commenter = GitHubPRCommenter(token, repo, pull_number_int)
-    await commenter.post_comment(build_pr_comment_body(graph, live_review=live_review))
-    console.print(f"[green]Posted DevCouncil PR comment to GitHub PR #{pull_number}.[/green]")
-
-
-async def run_gitlab_mr_comment(graph: ArtifactGraph, live_review: dict | None = None):
-    token = os.environ.get("GITLAB_TOKEN")
-    project_id = os.environ.get("GITLAB_PROJECT_ID")
-    mr_iid = os.environ.get("GITLAB_MR_IID") or os.environ.get("CI_MERGE_REQUEST_IID")
-    base_url = os.environ.get("GITLAB_API_URL", "https://gitlab.com/api/v4")
-    if not token or not project_id or not mr_iid:
-        console.print("[red]GITLAB_TOKEN, GITLAB_PROJECT_ID, and GITLAB_MR_IID must be set for GitLab MR comments.[/red]")
-        return
-    try:
-        mr_iid_int = int(mr_iid)
-    except ValueError:
-        console.print("[red]GITLAB_MR_IID must be an integer.[/red]")
-        return
-    commenter = GitLabMRCommenter(token, project_id, mr_iid_int, base_url=base_url)
-    await commenter.post_comment(build_pr_comment_body(graph, live_review=live_review))
-    console.print(f"[green]Posted DevCouncil MR comment to GitLab MR !{mr_iid}.[/green]")
-
-@app.callback(invoke_without_command=True)
-def report(
-    ctx: typer.Context,
-    planning_only: bool = typer.Option(False, "--planning-only", help="Report only the planning phase status"),
-    json_format: bool = typer.Option(False, "--json", help="Output report in JSON format"),
-    github: bool = typer.Option(False, "--github", help="Post report to GitHub PR Checks"),
-    github_pr_comment: bool = typer.Option(False, "--github-pr-comment", help="Post report as a GitHub PR comment"),
-    gitlab_pr_comment: bool = typer.Option(False, "--gitlab-pr-comment", help="Post report as a GitLab merge request comment"),
-    fail_on_blocking: bool = typer.Option(
-        False,
-        "--fail-on-blocking",
-        help="Exit non-zero when blocking gaps remain, so shell-driven agents can gate on $?.",
-    ),
-    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
-):
-    """
-    Produce final evidence report.
-    """
-    if ctx.invoked_subcommand is not None:
-        return
-
-    root = project_root.expanduser().resolve()
-    initialize_project(root, quiet=True)
-    db = get_db(root)
-    if not db:
-        console.print("[red]DevCouncil state is unavailable in this directory.[/red]")
-        raise typer.Exit(code=1)
-
-    with db.get_session() as session:
-        graph_repo = ArtifactGraphRepository(session)
-        graph = graph_repo.load_graph()
-        live_review = live_review_summary(root)
-        TraceLogger(root).log_event(
-            "report_generated",
-            {
-                "json": json_format,
-                "github": github,
-                "github_pr_comment": github_pr_comment,
-                "gitlab_pr_comment": gitlab_pr_comment,
-                "planning_only": planning_only,
-            },
-            summary="Generated DevCouncil report",
-        )
-        
-        if github:
-            asyncio.run(run_github_report(graph, root))
-            return
-
-        if github_pr_comment:
-            asyncio.run(run_github_pr_comment(graph, live_review=live_review))
-            return
-
-        if gitlab_pr_comment:
-            asyncio.run(run_gitlab_mr_comment(graph, live_review=live_review))
-            return
-
-        if json_format:
-            output = ReportBuilder.build_json(graph, live_review=live_review)
-            typer.echo(output)
-        else:
-            output = ReportBuilder.build_markdown(graph, live_review=live_review)
-            console.print(Markdown(output))
-
-        if fail_on_blocking and graph.blocking_gaps():
-            raise typer.Exit(code=1)

package/src/devcouncil/cli/commands/reset_demo_state.py

@@ -1,33 +0,0 @@
-import typer
-from rich.console import Console
-from sqlmodel import delete
-from pathlib import Path
-
-from devcouncil.storage.db import get_db
-from devcouncil.storage.models import EvidenceModel, GapModel, RequirementModel, TaskModel
-from devcouncil.cli.commands.init import initialize_project
-
-console = Console()
-
-
-def reset_demo_state(
-    yes: bool = typer.Option(False, "--yes", help="Confirm clearing planning/demo artifacts."),
-    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
-):
-    """Clear demo planning artifacts from the local DevCouncil state database."""
-    if not yes:
-        console.print("[red]Refusing to clear state without --yes.[/red]")
-        raise typer.Exit(code=1)
-
-    root = project_root.expanduser().resolve()
-    initialize_project(root, quiet=True)
-    db = get_db(root)
-    if not db:
-        console.print("[red]DevCouncil state is unavailable in this directory.[/red]")
-        raise typer.Exit(code=1)
-
-    with db.get_session() as session:
-        for model in (EvidenceModel, GapModel, TaskModel, RequirementModel):
-            session.exec(delete(model))
-
-    console.print("[green]Cleared requirements, tasks, gaps, and evidence from local state.[/green]")

package/src/devcouncil/cli/commands/rollback.py

@@ -1,59 +0,0 @@
-import typer
-from pathlib import Path
-from rich.console import Console
-
-from devcouncil.execution.checkpoints import CheckpointService
-
-app = typer.Typer()
-console = Console()
-
-@app.callback(invoke_without_command=True)
-def rollback(
-    ctx: typer.Context,
-    task_id: str = typer.Argument(..., help="ID of the task to rollback"),
-    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
-):
-    """
-    Revert changes using a task's git checkpoint.
-    """
-    if ctx.invoked_subcommand is not None:
-        return
-
-    root = project_root.expanduser().resolve()
-    checkpoint_dir = root / ".devcouncil" / "checkpoints"
-    checkpoint_file = checkpoint_dir / f"{task_id}-before.patch"
-    after_patch = checkpoint_dir / f"{task_id}-after.patch"
-    service = CheckpointService(root)
-
-    if not checkpoint_file.exists() and not after_patch.exists():
-        before_ref = CheckpointService.REF_BEFORE.format(task_id=task_id)
-        after_ref = CheckpointService.REF_AFTER.format(task_id=task_id)
-        if not service._ref_exists(before_ref) and not service._ref_exists(after_ref):
-            console.print(
-                f"[red]No checkpoint found for task {task_id}. Expected {after_patch} "
-                f"or {checkpoint_file}.[/red]"
-            )
-            raise typer.Exit(code=1)
-
-    console.print(f"Rolling back task [bold]{task_id}[/bold]...")
-    result = service.rollback(task_id)
-    if "failed" in result.message.lower() or result.message.startswith("No checkpoint"):
-        console.print(f"[yellow]{result.message}[/yellow]")
-        if checkpoint_file.exists():
-            console.print(
-                f"The before-patch at {checkpoint_file} captured the state before the task ran.\n"
-                f"To manually reset:\n"
-                f"  1. [bold]git stash[/bold] (if you want to keep current changes)\n"
-                f"  2. [bold]git checkout -- .[/bold] (discard working tree changes)\n"
-                f"  3. [bold]git apply {checkpoint_file}[/bold] (restore pre-task state)"
-            )
-        elif after_patch.exists():
-            console.print(
-                f"Only the after-patch at {after_patch} exists (it captured the task's changes).\n"
-                f"To manually revert those changes from the working tree:\n"
-                f"  1. [bold]git apply --stat {after_patch}[/bold] (inspect what the task changed)\n"
-                f"  2. [bold]git apply -R {after_patch}[/bold] (reverse-apply the task's changes)"
-            )
-        raise typer.Exit(code=1)
-
-    console.print(f"[green]Successfully rolled back task {task_id}.[/green] {result.message}")

package/src/devcouncil/cli/commands/run.py

@@ -1,289 +0,0 @@
-import typer
-from rich.console import Console
-from pathlib import Path
-from devcouncil.storage.db import get_db
-from devcouncil.storage.repositories import TaskRepository, RequirementRepository
-from devcouncil.executors.mini_swe import MiniSWEExecutor
-from devcouncil.executors.openhands import OpenHandsExecutor
-from devcouncil.executors.coding_cli import CodingCliExecutor
-from devcouncil.executors.agent_registry import (
-    AGENT_ALIASES,
-    BUILTIN_CODING_EXECUTOR_NAMES,
-    load_cli_agent_specs,
-)
-from devcouncil.executors.native.agent import NativeAgent
-from devcouncil.llm.provider import create_provider, validate_model_provider
-from devcouncil.llm.router import ModelRouter
-from devcouncil.app.config import load_config, get_api_key
-from devcouncil.domain.evidence import CommandResult, DiffEvidence, TestEvidence
-from devcouncil.storage.repositories import GapRepository, EvidenceRepository, StateRepository
-from devcouncil.verification.verifier import Verifier
-from devcouncil.app.state_machine import ProjectPhase
-from devcouncil.cli.commands.init import initialize_project
-from devcouncil.telemetry.traces import TraceLogger
-
-console = Console()
-CODING_EXECUTOR_ALIASES = {name: name for name in BUILTIN_CODING_EXECUTOR_NAMES} | AGENT_ALIASES
-
-CODING_EXECUTORS = set(CODING_EXECUTOR_ALIASES.keys())
-
-
-def _custom_cli_agents(project_root: Path) -> set[str]:
-    specs = load_cli_agent_specs(project_root)
-    return {name for name, spec in specs.items() if not spec.built_in}
-
-def _current_changed_files(project_root: Path = Path(".")) -> list[str]:
-    from devcouncil.verification.verifier import Verifier
-
-    return Verifier(project_root).get_changed_files()
-
-def _capture_after_patch(task_id: str, project_root: Path = Path(".")):
-    """Capture the diff after task execution for use by rollback."""
-    try:
-        from devcouncil.execution.checkpoints import CheckpointService
-
-        CheckpointService(project_root).create_after(task_id)
-    except Exception:
-        pass  # Non-critical — don't block execution
-
-def _capture_before_snapshot(task_id: str, project_root: Path = Path(".")):
-    from devcouncil.execution.checkpoints import CheckpointService
-
-    CheckpointService(project_root).create_before(task_id)
-
-def _record_project_phase(session, phase: ProjectPhase):
-    StateRepository(session).record_phase(phase.value)
-
-def _verify_after_execution(session, task, reqs, router=None, project_root: Path = Path(".")) -> bool:
-    """Run deterministic verification after an automated executor finishes."""
-    import asyncio
-
-    verifier = Verifier(project_root, router=router)
-    gaps, evidence = asyncio.run(verifier.verify_task(task, reqs))
-
-    gap_repo = GapRepository(session)
-    evidence_repo = EvidenceRepository(session)
-    gap_repo.delete_for_task(task.id)
-    evidence_repo.delete_for_task(task.id)
-
-    for gap in gaps:
-        gap_repo.save(gap)
-
-    for ev in evidence:
-        if isinstance(ev, CommandResult):
-            evidence_repo.save_command_result(task.id, ev)
-        elif isinstance(ev, DiffEvidence):
-            evidence_repo.save_diff_evidence(ev)
-        elif isinstance(ev, TestEvidence):
-            evidence_repo.save_test_evidence(ev, task.id)
-
-    task.status = "blocked" if any(g.blocking for g in gaps) else "verified"
-    return task.status == "verified"
-
-
-def _record_agent_verification(project_root: Path, task_id: str, executor: str, run_id: str | None, verified: bool) -> None:
-    TraceLogger(project_root).log_event(
-        "agent_run_verified",
-        {"agent": executor, "verified": verified},
-        run_id=run_id,
-        task_id=task_id,
-        summary=f"{executor} verification {'passed' if verified else 'blocked'} for {task_id}",
-    )
-
-def run(
-    task_id: str = typer.Argument(..., help="ID of the task to run"),
-    executor: str = typer.Option(
-        "manual",
-        "--executor",
-        "-e",
-        help=(
-            "Executor to use (manual, mini, openhands, native-preview, "
-            "codex, gemini, claude, opencode, antigravity, warp, cursor, aider, "
-            "copilot, goose, amp, qwen, crush, or a configured agent)"
-        ),
-    ),
-    profile: str | None = typer.Option(None, "--profile", help="CLI-agent execution profile: default, yolo, prod, or a configured profile."),
-    stream: bool = typer.Option(
-        False,
-        "--stream",
-        help="Stream coding CLI stdout/stderr live (also enabled by execution.stream_cli_output).",
-    ),
-    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
-):
-    """
-    Execute a specific task.
-    """
-    root = project_root.expanduser().resolve()
-    initialize_project(root, quiet=True)
-    db = get_db(root)
-    if not db:
-        console.print("[red]DevCouncil state is unavailable in this directory.[/red]")
-        return
-
-    with db.get_session() as session:
-        task_repo = TaskRepository(session)
-        task = task_repo.get_by_id(task_id)
-        if not task:
-            console.print(f"[red]Task {task_id} not found.[/red]")
-            return
-
-        from devcouncil.gating.policy import GatePolicy
-        gate_policy = GatePolicy()
-        gate_result = gate_policy.check_task_ready(task, root)
-        if not gate_result.passed:
-            console.print(f"[red]Task {task_id} is not ready for execution.[/red]")
-            for gap in gate_result.gaps:
-                if gap.blocking:
-                    console.print(f" - [red][BLOCKING][/red] {gap.description} (Fix: {gap.recommended_fix})")
-            return
-
-        console.print(f"Running task [bold]{task_id}[/bold] using [bold]{executor}[/bold] executor...")
-
-        # 1. Create Git checkpoint
-        try:
-            from devcouncil.execution.checkpoints import CheckpointService
-
-            result = CheckpointService(root).create_before(task_id)
-            if result.patch_path:
-                console.print(f"Created git checkpoint at {result.patch_path}")
-            elif result.git_ref_created:
-                console.print(f"Created git checkpoint ref {result.ref}")
-        except Exception as e:
-            console.print(f"[yellow]Warning: Failed to create git checkpoint: {e}[/yellow]")
-
-        executor = executor.strip().lower().replace("_", "-")
-        if executor not in CODING_EXECUTORS and executor not in _custom_cli_agents(root):
-            ignored = [flag for flag, value in (("--profile", profile), ("--stream", stream)) if value]
-            if ignored:
-                console.print(
-                    f"[yellow]{' and '.join(ignored)} only apply to coding CLI executors and are ignored for '{executor}'.[/yellow]"
-                )
-        if executor == "manual":
-            _record_project_phase(session, ProjectPhase.TASK_EXECUTING)
-            task.status = "running"
-            task_repo.save(task)
-            console.print(f"\n[green]Task {task_id} is now marked as RUNNING.[/green]")
-            console.print("Use 'dev prompt TASK-ID' to get the prompt for this task.")
-            console.print("When finished, use 'dev verify TASK-ID' to check the results.")
-        elif executor in CODING_EXECUTORS or executor in _custom_cli_agents(root):
-            _record_project_phase(session, ProjectPhase.TASK_EXECUTING)
-            req_repo = RequirementRepository(session)
-            reqs = req_repo.get_all()
-            cli_client = CODING_EXECUTOR_ALIASES.get(executor, executor)
-            cli_executor = CodingCliExecutor(root, cli_client, profile=profile, stream_output=stream or None)
-            exec_result = cli_executor.run_task(task, reqs)
-            _capture_after_patch(task_id, root)
-            if exec_result.success:
-                _record_project_phase(session, ProjectPhase.TASK_VERIFYING)
-                verified = _verify_after_execution(session, task, reqs, project_root=root)
-                _record_agent_verification(root, task.id, cli_client, getattr(cli_executor, "last_run_id", None), verified)
-                _record_project_phase(
-                    session,
-                    ProjectPhase.TASK_VERIFIED if verified else ProjectPhase.TASK_BLOCKED,
-                )
-                task_repo.save(task)
-                run_id = getattr(cli_executor, "last_run_id", None)
-                if run_id:
-                    run_dir = root / ".devcouncil" / "runs" / run_id
-                    console.print(f"Run artifacts: [dim]{run_dir}[/dim]")
-                    transcript_path = getattr(cli_executor, "last_transcript_path", None)
-                    if transcript_path:
-                        console.print(f"Transcript: [dim]{transcript_path}[/dim]")
-                if verified:
-                    console.print(f"\n[green]{executor.upper()} finished and task {task_id} verified.[/green]")
-                else:
-                    console.print(f"\n[yellow]{executor.upper()} finished, but task {task_id} is blocked by verification gaps.[/yellow]")
-            else:
-                console.print(f"\n[red]{executor.upper()} failed to start or execute: {exec_result.message}[/red]")
-        elif executor == "mini":
-            _record_project_phase(session, ProjectPhase.TASK_EXECUTING)
-            req_repo = RequirementRepository(session)
-            reqs = req_repo.get_all()
-            mini_executor = MiniSWEExecutor(root)
-            exec_result = mini_executor.run_task(task, reqs)
-            _capture_after_patch(task_id, root)
-            if exec_result.success:
-                _record_project_phase(session, ProjectPhase.TASK_VERIFYING)
-                verified = _verify_after_execution(session, task, reqs, project_root=root)
-                _record_project_phase(
-                    session,
-                    ProjectPhase.TASK_VERIFIED if verified else ProjectPhase.TASK_BLOCKED,
-                )
-                task_repo.save(task)
-                if verified:
-                    console.print(f"\n[green]mini-SWE-agent finished and task {task_id} verified.[/green]")
-                else:
-                    console.print(f"\n[yellow]mini-SWE-agent finished, but task {task_id} is blocked by verification gaps.[/yellow]")
-            else:
-                console.print("\n[red]mini-SWE-agent failed to start or execute.[/red]")
-        elif executor == "openhands":
-            _record_project_phase(session, ProjectPhase.TASK_EXECUTING)
-            req_repo = RequirementRepository(session)
-            reqs = req_repo.get_all()
-            oh_executor = OpenHandsExecutor(root)
-            exec_result = oh_executor.run_task(task, reqs)
-            _capture_after_patch(task_id, root)
-            if exec_result.success:
-                _record_project_phase(session, ProjectPhase.TASK_VERIFYING)
-                verified = _verify_after_execution(session, task, reqs, project_root=root)
-                _record_project_phase(
-                    session,
-                    ProjectPhase.TASK_VERIFIED if verified else ProjectPhase.TASK_BLOCKED,
-                )
-                task_repo.save(task)
-                if verified:
-                    console.print(f"\n[green]OpenHands finished and task {task_id} verified.[/green]")
-                else:
-                    console.print(f"\n[yellow]OpenHands finished, but task {task_id} is blocked by verification gaps.[/yellow]")
-            else:
-                console.print("\n[red]OpenHands failed to start or execute.[/red]")
-        elif executor in {"native", "native-preview"}:
-            # Load config for model routing and permissions
-            try:
-                config = load_config(root)
-                validate_model_provider(config.models.provider)
-                api_key = get_api_key(config.models.provider, root)
-            except (FileNotFoundError, ValueError) as e:
-                console.print(f"[red]{e}[/red]")
-                return
-            
-            provider = create_provider(config.models.provider, api_key, project_root=root)
-            role_config = {name: role.model_dump() for name, role in config.models.roles.items()}
-            router = ModelRouter(provider, role_config, project_root=root)
-            
-            # Setup Permission System
-            from devcouncil.execution.permissions import PermissionPolicy, PermissionManager
-            from devcouncil.execution.task_runner import TaskRunner
-            
-            # Populate policy from config commands
-            allowed_cmds = config.commands.test + config.commands.lint + config.commands.typecheck
-            permission_policy = PermissionPolicy(
-                allowed_shell_commands=allowed_cmds,
-            )
-            perm_manager = PermissionManager(permission_policy, root)
-            task_runner = TaskRunner(root, perm_manager)
-            
-            req_repo = RequirementRepository(session)
-            reqs = req_repo.get_all()
-            
-            _record_project_phase(session, ProjectPhase.TASK_EXECUTING)
-            agent = NativeAgent(router, task_runner)
-            exec_result = agent.run_task(task, reqs)
-            _capture_after_patch(task_id, root)
-            
-            if exec_result.success:
-                _record_project_phase(session, ProjectPhase.TASK_VERIFYING)
-                verified = _verify_after_execution(session, task, reqs, router=router, project_root=root)
-                _record_project_phase(
-                    session,
-                    ProjectPhase.TASK_VERIFIED if verified else ProjectPhase.TASK_BLOCKED,
-                )
-                task_repo.save(task)
-                if verified:
-                    console.print(f"\n[green]Native agent finished and task {task_id} verified.[/green]")
-                else:
-                    console.print(f"\n[yellow]Native agent finished, but task {task_id} is blocked by verification gaps.[/yellow]")
-            else:
-                console.print("\n[red]Native agent failed during execution.[/red]")
-        else:
-            console.print(f"[red]Executor {executor} not yet implemented.[/red]")