devcouncil 0.2.0 → 0.2.1

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

@@ -1,20 +0,0 @@
-import json
-from pathlib import Path
-
-import typer
-
-from devcouncil.indexing.lsp import LspInspector
-
-app = typer.Typer(help="Inspect optional LSP integration readiness.")
-
-
-@app.command("inspect")
-def inspect(
-    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root."),
-):
-    """Print detected language servers and initialize payloads."""
-    root = project_root.expanduser().resolve()
-    if not root.exists():
-        typer.echo(json.dumps({"languages": [], "servers": [], "initialize_requests": {}, "error": f"{root} does not exist"}, indent=2))
-        raise typer.Exit(code=1)
-    typer.echo(LspInspector(root).summary_json())

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

@@ -1,112 +0,0 @@
-import json
-from pathlib import Path
-
-import typer
-from rich.console import Console
-
-from devcouncil.cli.commands.init import initialize_project
-from devcouncil.indexing.repo_mapper import RepoMap, RepoMapper
-from devcouncil.integrations.code_review_graph import CodeReviewGraphAdapter
-from devcouncil.storage.db import get_db
-
-console = Console()
-status_console = Console(stderr=True)
-
-AGENT_GUIDE_MARKER = "<!-- Managed by dev map: keep this file in sync with .devcouncil/repo_map.json. -->"
-
-
-def _important_surfaces(repo_map: RepoMap) -> list[str]:
-    """Derive the 'important surfaces' list from the computed map, so the guide points
-    at THIS repo's real subsystems instead of hardcoded DevCouncil paths."""
-    lines: list[str] = []
-    for index, subsystem in enumerate(repo_map.subsystems[:6], start=1):
-        lines.append(f"{index}. `{subsystem.area}/` — {subsystem.summary}")
-    if not lines:
-        for index, path in enumerate(repo_map.important_files[:6], start=1):
-            lines.append(f"{index}. `{path}`")
-    return lines or ["1. See `.devcouncil/repo_map.json` for the file index."]
-
-
-def _agent_guide_text(repo_map_path: Path, repo_root: Path, repo_map: RepoMap) -> str:
-    return "\n".join(
-        [
-            AGENT_GUIDE_MARKER,
-            "",
-            "# Agent Workspace Guide",
-            "",
-            "Use `.devcouncil/repo_map.json` as the primary file index for this workspace.",
-            f"Repo map: `{repo_map_path.relative_to(repo_root).as_posix() if repo_map_path.is_relative_to(repo_root) else repo_map_path}`",
-            "",
-            "Workflow for agents:",
-            "1. Open `.devcouncil/repo_map.json` before guessing at file locations.",
-            "2. Use the `files` list to resolve module ownership and nearby siblings.",
-            "3. Use `subsystems` for subsystem-level navigation.",
-            "4. In `subsystems`, use `entry_points` + `critical_files` for entry points and starting context.",
-            "5. Use `role_files` in `subsystems` for subsystem role buckets (entry, runtime, policy, adapters, etc.).",
-            "6. Use `neighbors` and `handoff_paths` in `subsystems` to follow cross-subsystem flow.",
-            "7. Run `dev map` again after large refactors to refresh the map.",
-            "",
-            "Important surfaces:",
-            *_important_surfaces(repo_map),
-            "",
-            "If the map and source disagree, trust the source and regenerate the map.",
-        ]
-    )
-
-
-def _write_agent_guides(repo_root: Path, repo_map_path: Path, repo_map: RepoMap) -> None:
-    for filename in ("AGENTS.md", "CLAUDE.md"):
-        path = repo_root / filename
-        if path.exists():
-            existing = path.read_text(encoding="utf-8")
-            if AGENT_GUIDE_MARKER not in existing:
-                continue
-        path.write_text(_agent_guide_text(repo_map_path, repo_root, repo_map) + "\n", encoding="utf-8")
-
-
-def generate_map_artifacts(root: Path, output: Path, goal: str = "", *, scan_dependencies: bool = False) -> RepoMap:
-    """Build the repo map and write repo_map.json + agent guides (no LLM, no re-init).
-
-    Assumes ``.devcouncil/`` already exists. Shared by the ``dev map`` command and
-    by project initialization so a freshly set-up repo is immediately navigable.
-    ``scan_dependencies`` is opt-in (off for init and default mapping) because it can
-    shell out to dependency auditors.
-    """
-    repo_map = RepoMapper(root).map_repo(goal, scan_dependencies=scan_dependencies)
-    graph_context = CodeReviewGraphAdapter(root).get_context()
-    output = output if output.is_absolute() else root / output
-    output.parent.mkdir(parents=True, exist_ok=True)
-    output.write_text(repo_map.model_dump_json(indent=2), encoding="utf-8")
-    _write_agent_guides(root, output, repo_map)
-    if graph_context.available:
-        graph_output = output.with_name("code_review_graph_context.json")
-        graph_output.write_text(graph_context.model_dump_json(indent=2), encoding="utf-8")
-        status_console.print(f"[green]Wrote code-review-graph context to {graph_output}[/green]")
-    return repo_map
-
-
-def map_repo(
-    goal: str = typer.Argument("", help="Goal text used for candidate-file ranking."),
-    output: Path = typer.Option(
-        Path(".devcouncil/repo_map.json"),
-        "--output",
-        "-o",
-        help="Path to write repo_map.json.",
-    ),
-    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
-    scan_deps: bool = typer.Option(
-        False,
-        "--scan-deps",
-        help="Run available dependency auditors (pip-audit/npm audit/osv-scanner) and record dependency_risks in the map. Off by default.",
-    ),
-):
-    """Build the deterministic repository map without calling an LLM."""
-    root = project_root.expanduser().resolve()
-    initialize_project(root, quiet=True, with_map=False)
-    if not get_db(root):
-        raise typer.Exit(code=1)
-
-    output = output if output.is_absolute() else root / output
-    repo_map = generate_map_artifacts(root, output, goal, scan_dependencies=scan_deps)
-    typer.echo(json.dumps(repo_map.model_dump(), indent=2))
-    status_console.print(f"[green]Wrote repository map to {output}[/green]")

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

@@ -1,18 +0,0 @@
-import asyncio
-
-import typer
-
-from devcouncil.integrations.mcp.server import run
-
-app = typer.Typer()
-
-
-@app.callback(invoke_without_command=True)
-def mcp_server(ctx: typer.Context):
-    """
-    Start the DevCouncil MCP server over stdio.
-    """
-    if ctx.invoked_subcommand is not None:
-        return
-
-    asyncio.run(run())

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

@@ -1,488 +0,0 @@
-import typer
-import asyncio
-import json
-import datetime
-from typing import Any
-from rich.console import Console
-from rich.panel import Panel
-from rich.progress import Progress, SpinnerColumn, TextColumn
-from pathlib import Path
-
-from devcouncil.storage.db import get_db
-from devcouncil.storage.repositories import (
-    GapRepository,
-    PlanningStateRepository,
-)
-from devcouncil.indexing.repo_mapper import RepoMapper
-from devcouncil.integrations.code_review_graph import CodeReviewGraphAdapter
-from devcouncil.llm.provider import Provider, MockProvider, ProviderRequestError, build_role_model_config, create_provider, validate_model_provider
-from devcouncil.llm.router import ModelRouter, StructuredOutputError
-from devcouncil.planning.spec_service import SpecService
-from devcouncil.planning.prompt_enhancer_service import PromptEnhancerService
-from devcouncil.planning.plan_service import PlanService
-from devcouncil.planning.critique_service import CritiqueService
-from devcouncil.planning.arbiter_service import ArbiterDecision, ArbiterService
-from devcouncil.gating.policy import GatePolicy
-from devcouncil.app.orchestrator import Orchestrator
-from devcouncil.app.state_machine import ProjectPhase
-from devcouncil.app.config import ModelRoleConfig, load_config, get_api_key
-from devcouncil.cli.commands.init import initialize_project
-from devcouncil.telemetry.traces import TraceLogger
-
-app = typer.Typer()
-console = Console()
-
-REQUIRED_PLANNING_ROLES = (
-    "prompt_enhancer",
-    "spec_writer",
-    "planner_a",
-    "planner_b",
-    "critic_a",
-    "critic_b",
-    "arbiter",
-)
-
-
-def _decision_ids(items: list[Any]) -> set[str]:
-    ids: set[str] = set()
-    for item in items:
-        if isinstance(item, str):
-            ids.add(item)
-        elif isinstance(item, dict):
-            value = item.get("id") or item.get("finding_id")
-            if value:
-                ids.add(str(value))
-    return ids
-
-
-def _reconcile_findings(findings, decision):
-    accepted_ids = set(decision.accepted_finding_ids)
-    rejected_ids = _decision_ids(decision.rejected_finding_ids)
-    reconciled = []
-    for finding in findings:
-        if finding.id in accepted_ids:
-            reconciled.append(finding.model_copy(update={"status": "converted"}))
-        elif finding.id in rejected_ids:
-            reconciled.append(finding.model_copy(update={"status": "rejected"}))
-        else:
-            reconciled.append(finding)
-    return reconciled
-
-
-def _ensure_planning_roles(config) -> None:
-    fallback = config.models.roles.get("spec_writer")
-    if fallback is None and config.models.roles:
-        fallback = next(iter(config.models.roles.values()))
-    if fallback is None:
-        try:
-            provider_roles = build_role_model_config(config.models.provider)
-            fallback = ModelRoleConfig(model=provider_roles["spec_writer"]["model"])
-        except ValueError:
-            fallback = ModelRoleConfig(model="unconfigured")
-
-    for role in REQUIRED_PLANNING_ROLES:
-        config.models.roles.setdefault(role, fallback.model_copy())
-
-async def run_plan_flow(
-    goal: str,
-    requirements_only: bool = False,
-    dry_run: bool = False,
-    persist: bool = True,
-    project_root: Path = Path("."),
-    quick: bool = False,
-):
-    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 []
-
-    # Load validated config
-    config = load_config(root)
-    _ensure_planning_roles(config)
-
-    api_key = None
-    if not dry_run:
-        try:
-            validate_model_provider(config.models.provider)
-            api_key = get_api_key(config.models.provider, root)
-        except ValueError as e:
-            console.print(f"[red]{e}[/red]")
-            return []
-
-    orchestrator = Orchestrator(root, persist_state=persist)
-    orchestrator.reset_state_machine(ProjectPhase.NEW)
-    run_id = datetime.datetime.now(datetime.timezone.utc).strftime("%Y%m%dT%H%M%SZ") + "-plan"
-    await orchestrator.start_run(run_id, goal)
-
-    provider: Provider
-    if dry_run:
-        # Override config models to be unique roles for mock mapping
-        for role in REQUIRED_PLANNING_ROLES:
-            config.models.roles[role].model = f"mock/{role}"
-
-        provider = MockProvider()
-        provider.responses = {
-            "mock/prompt_enhancer": json.dumps({
-                "original_goal": goal,
-                "enhanced_goal": (
-                    f"Plan and implement {goal} using the mapped repository's "
-                    "existing patterns, tests, and verification gates."
-                ),
-                "codebase_context": ["Use the repository map to target existing application and test structure."],
-                "debate_focus": ["Compare minimal implementation scope against production-readiness concerns."],
-                "constraints": [f"Do not broaden beyond: {goal}."]
-            }),
-            "mock/spec_writer": json.dumps({
-                "requirements": [{"id": "REQ-001", "title": "Mock Req", "description": "Desc", "priority": "high", "source": "user", "acceptance_criteria": []}],
-                "assumptions": [],
-                "blocking_questions": []
-            }),
-            "mock/planner_a": [
-                json.dumps({
-                    "id": "PLAN-A", "rationale": "Simple", "tasks": [{"id": "TASK-001", "title": "Mock Task", "description": "Desc", "requirement_ids": ["REQ-001"], "acceptance_criterion_ids": [], "planned_files": [], "expected_tests": [], "allowed_commands": [], "status": "planned"}]
-                }),
-                json.dumps({"rebuttals": []})
-            ],
-            "mock/planner_b": [
-                json.dumps({
-                    "id": "PLAN-B", "rationale": "Robust", "tasks": [{"id": "TASK-001", "title": "Mock Task", "description": "Desc", "requirement_ids": ["REQ-001"], "acceptance_criterion_ids": [], "planned_files": [], "expected_tests": [], "allowed_commands": [], "status": "planned"}]
-                }),
-                json.dumps({"rebuttals": []})
-            ],
-            "mock/critic_a": '{"findings": []}',
-            "mock/critic_b": '{"findings": []}',
-            "mock/arbiter": json.dumps({
-                "accepted_finding_ids": [], "rejected_finding_ids": [], 
-                "final_requirements": [{"id": "REQ-001", "title": "Mock Req", "description": "Desc", "priority": "high", "source": "user", "acceptance_criteria": [{"id": "AC-1", "description": "Test it", "verification_method": "unit_test"}]}],
-                "final_tasks": [{"id": "TASK-001", "title": "Mock Task", "description": "Desc", "requirement_ids": ["REQ-001"], "acceptance_criterion_ids": ["AC-1"], "planned_files": [{"path": "test.py", "reason": "logic", "allowed_change": "modify"}], "expected_tests": [], "allowed_commands": [], "status": "planned"}]
-            }),
-        }
-        # Special case: PlanService calls use the same model names. 
-        # I'll modify PlanService to use a slightly different role string if needed, 
-        # but for Dry Run, let's just make the MockProvider return based on the schema requested.
-    else:
-        if api_key is None:
-            console.print("[red]Missing API key for configured model provider.[/red]")
-            return []
-        provider = create_provider(config.models.provider, api_key, project_root=root)
-
-    # Build role config after dry-run overrides so mocks are routed correctly.
-    role_config = {name: role.model_dump() for name, role in config.models.roles.items()}
-    router = ModelRouter(provider, role_config, project_root=root)
-    
-    prompt_enhancer = PromptEnhancerService(router)
-    spec_service = SpecService(router)
-    plan_service = PlanService(router)
-    critique_service = CritiqueService(router)
-    arbiter_service = ArbiterService(router)
-    mapper = RepoMapper(root)
-
-    with Progress(
-        SpinnerColumn(),
-        TextColumn("[progress.description]{task.description}"),
-        transient=True,
-    ) as progress:
-        # 1. Repo Map
-        progress.add_task(description="Mapping repository...", total=None)
-        repo_map = mapper.map_repo(goal)
-        repo_map_json = repo_map.model_dump_json(indent=2)
-        orchestrator.save_run_artifact("repo_map.json", json.loads(repo_map_json))
-        graph_context = CodeReviewGraphAdapter(root).get_context()
-        if graph_context.available:
-            orchestrator.save_run_artifact("code_review_graph_context.json", graph_context.model_dump())
-        await orchestrator.transition_to(ProjectPhase.REPO_MAPPED)
-
-        # 2. Codebase-specific prompt enhancement
-        progress.add_task(description="Enhancing prompt for codebase debate...", total=None)
-        prompt_enhancement = await prompt_enhancer.enhance_prompt(
-            goal,
-            repo_map_json,
-            graph_context.model_dump_json() if graph_context.available else None,
-            project_root=root,
-        )
-        debate_goal = prompt_enhancement.debate_prompt()
-        orchestrator.save_run_artifact("prompt_enhancement.json", prompt_enhancement.model_dump())
-        if prompt_enhancement.applied_skills:
-            console.print(
-                "[dim]Domain skills applied:[/dim] "
-                + ", ".join(prompt_enhancement.applied_skills)
-            )
-        TraceLogger(root).log_event(
-            "prompt_enhanced",
-            {
-                "original_goal": goal,
-                "enhanced_goal": prompt_enhancement.enhanced_goal,
-                "codebase_context_count": len(prompt_enhancement.codebase_context),
-                "constraint_count": len(prompt_enhancement.constraints),
-                "debate_focus_count": len(prompt_enhancement.debate_focus),
-                "applied_skills": prompt_enhancement.applied_skills,
-                "artifact": f".devcouncil/runs/{run_id}/prompt_enhancement.json",
-            },
-            run_id=run_id,
-            summary="Prompt enhanced for codebase-specific debate.",
-        )
-
-        # 3. Spec / Requirements
-        progress.add_task(description="Generating requirements...", total=None)
-        spec_output = await spec_service.generate_spec(debate_goal, repo_map_json)
-        orchestrator.save_run_artifact("requirements.json", spec_output.model_dump())
-        await orchestrator.transition_to(ProjectPhase.REQUIREMENTS_DRAFTED)
-        
-        if requirements_only:
-            console.print(Panel(f"Found {len(spec_output.requirements)} requirements.", title="Requirements Generated"))
-            return []
-
-        requirements_json = json.dumps([r.model_dump() for r in spec_output.requirements])
-
-        if quick:
-            # Rigor dial: single pragmatic plan, no A/B debate, critique, rebuttal,
-            # or arbitration. Spec requirements (with their acceptance criteria)
-            # become the final requirements verbatim. This trades the council's
-            # adversarial robustness for ~5 fewer model calls — the right setting
-            # for small, well-scoped changes where verification (which still gates
-            # every diff) is the real safety net, not planning debate.
-            progress.add_task(description="Generating single plan (quick mode)...", total=None)
-            plan_a = await plan_service.generate_plan(
-                "planner_a", debate_goal, requirements_json, repo_map_json
-            )
-            orchestrator.save_run_artifact("plan_a.json", plan_a.model_dump())
-            await orchestrator.transition_to(ProjectPhase.PLANS_GENERATED)
-
-            decision = ArbiterDecision(
-                accepted_finding_ids=[],
-                rejected_finding_ids=[],
-                final_requirements=spec_output.requirements,
-                final_tasks=plan_a.tasks,
-            )
-            orchestrator.save_run_artifact("decision.json", decision.model_dump())
-            # Walk through CRITIQUES_GENERATED (the only path to ARBITRATED) without
-            # actually critiquing, so the rest of the lifecycle (approval, gates,
-            # status, the report's phase) is identical to the full council flow.
-            await orchestrator.transition_to(ProjectPhase.CRITIQUES_GENERATED)
-            await orchestrator.transition_to(ProjectPhase.ARBITRATED)
-            reconciled_findings = []
-            final_tasks = [task.model_copy(update={"status": "planned"}) for task in decision.final_tasks]
-        else:
-            # 4. Independent Plans (run concurrently — they don't depend on each other)
-            progress.add_task(description="Generating Plans A (Pragmatic) and B (Robust)...", total=None)
-            plan_a, plan_b = await asyncio.gather(
-                plan_service.generate_plan("planner_a", debate_goal, requirements_json, repo_map_json),
-                plan_service.generate_plan("planner_b", debate_goal, requirements_json, repo_map_json),
-            )
-            orchestrator.save_run_artifact("plan_a.json", plan_a.model_dump())
-            orchestrator.save_run_artifact("plan_b.json", plan_b.model_dump())
-            await orchestrator.transition_to(ProjectPhase.PLANS_GENERATED)
-
-            # 5. Cross-Critique (independent — run concurrently)
-            progress.add_task(description="Critiquing Plans A and B...", total=None)
-            critique_a, critique_b = await asyncio.gather(
-                critique_service.generate_critique("critic_a", plan_b.model_dump_json(), requirements_json),
-                critique_service.generate_critique("critic_b", plan_a.model_dump_json(), requirements_json),
-            )
-            orchestrator.save_run_artifact("critique_a.json", critique_a.model_dump())
-            orchestrator.save_run_artifact("critique_b.json", critique_b.model_dump())
-            await orchestrator.transition_to(ProjectPhase.CRITIQUES_GENERATED)
-
-            # 6. Rebuttals (independent — run concurrently)
-            progress.add_task(description="Generating rebuttals...", total=None)
-            rebuttal_a, rebuttal_b = await asyncio.gather(
-                critique_service.generate_rebuttal("planner_a", plan_a.model_dump_json(), critique_b.model_dump_json()),
-                critique_service.generate_rebuttal("planner_b", plan_b.model_dump_json(), critique_a.model_dump_json()),
-            )
-            orchestrator.save_run_artifact("rebuttal_a.json", rebuttal_a.model_dump())
-            orchestrator.save_run_artifact("rebuttal_b.json", rebuttal_b.model_dump())
-
-            # 7. Arbitration
-            progress.add_task(description="Arbitrating final plan...", total=None)
-            decision = await arbiter_service.arbitrate(
-                debate_goal,
-                json.dumps([r.model_dump() for r in spec_output.requirements]),
-                plan_a.model_dump_json(),
-                plan_b.model_dump_json(),
-                critique_a.model_dump_json(),
-                critique_b.model_dump_json(),
-                rebuttal_a.model_dump_json(),
-                rebuttal_b.model_dump_json()
-            )
-            orchestrator.save_run_artifact("decision.json", decision.model_dump())
-            await orchestrator.transition_to(ProjectPhase.ARBITRATED)
-            reconciled_findings = _reconcile_findings([*critique_a.findings, *critique_b.findings], decision)
-            final_tasks = [task.model_copy(update={"status": "planned"}) for task in decision.final_tasks]
-
-    console.print("[green]Planning complete![/green]")
-    console.print(f"[blue]Prompt enhancement:[/blue] .devcouncil/runs/{run_id}/prompt_enhancement.json")
-    if dry_run:
-        console.print("[blue](DRY RUN: No actual LLM calls were made)[/blue]")
-        if not persist:
-            console.print("[blue](DRY RUN: Final requirements/tasks were not persisted)[/blue]")
-    console.print(f"Final Requirements: [bold]{len(decision.final_requirements)}[/bold]")
-    console.print(f"Final Tasks: [bold]{len(final_tasks)}[/bold]")
-    
-    # 8. Check Gates
-    policy = GatePolicy()
-    result = policy.check_plan_approval(
-        decision.final_requirements,
-        final_tasks,
-        assumptions=spec_output.assumptions,
-        findings=reconciled_findings,
-        blocking_questions=spec_output.blocking_questions,
-    )
-    if persist:
-        with db.get_session() as session:
-            GapRepository(session).delete_plan_gaps()
-
-    if result.passed:
-        if persist:
-            with db.get_session() as session:
-                PlanningStateRepository(session).replace_active_plan(
-                    decision.final_requirements,
-                    spec_output.assumptions,
-                    final_tasks,
-                    reconciled_findings,
-                )
-
-        console.print("[green]Plan approved by gates.[/green]")
-        await orchestrator.transition_to(ProjectPhase.PLAN_APPROVED)
-        return [task.id for task in final_tasks]
-    else:
-        if persist:
-            with db.get_session() as session:
-                gap_repo = GapRepository(session)
-                for gap in result.gaps:
-                    gap_repo.save(gap)
-        console.print("[yellow]Plan generated but failed gates. See status for gaps.[/yellow]")
-        await orchestrator.transition_to(ProjectPhase.AWAITING_USER_DECISIONS)
-        return []
-
-def _latest_run_with_decision(root: Path, run_id: str | None) -> Path | None:
-    runs_dir = root / ".devcouncil" / "runs"
-    if run_id:
-        candidate = runs_dir / run_id
-        return candidate if (candidate / "decision.json").exists() else None
-    if not runs_dir.exists():
-        return None
-    candidates = [d for d in runs_dir.iterdir() if (d / "decision.json").exists()]
-    if not candidates:
-        return None
-    return max(candidates, key=lambda d: (d / "decision.json").stat().st_mtime)
-
-
-def approve(
-    run_id: str | None = typer.Option(None, "--run-id", help="Run whose generated plan to approve (defaults to the most recent run with a decision)."),
-    force: bool = typer.Option(False, "--force", help="Approve even if blocking gate gaps remain."),
-    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
-):
-    """
-    Approve a generated plan after reviewing gate gaps (AWAITING_USER_DECISIONS -> PLAN_APPROVED).
-    """
-    from devcouncil.planning.arbiter_service import ArbiterDecision
-    from devcouncil.planning.critique_service import CritiqueOutput
-    from devcouncil.planning.spec_service import SpecOutput
-
-    root = project_root.expanduser().resolve()
-    db = get_db(root)
-    if not db:
-        console.print("[red]DevCouncil state is unavailable in this directory.[/red]")
-        raise typer.Exit(code=1)
-
-    run_dir = _latest_run_with_decision(root, run_id)
-    if run_dir is None:
-        console.print("[red]No planning run with a decision was found. Run 'dev plan' first.[/red]")
-        raise typer.Exit(code=1)
-
-    decision = ArbiterDecision.model_validate_json((run_dir / "decision.json").read_text(encoding="utf-8"))
-    spec_path = run_dir / "requirements.json"
-    spec_output = (
-        SpecOutput.model_validate_json(spec_path.read_text(encoding="utf-8")) if spec_path.exists() else None
-    )
-
-    findings = []
-    for name in ("critique_a.json", "critique_b.json"):
-        critique_path = run_dir / name
-        if critique_path.exists():
-            findings.extend(CritiqueOutput.model_validate_json(critique_path.read_text(encoding="utf-8")).findings)
-    reconciled_findings = _reconcile_findings(findings, decision)
-    final_tasks = [task.model_copy(update={"status": "planned"}) for task in decision.final_tasks]
-    assumptions = spec_output.assumptions if spec_output else []
-
-    policy = GatePolicy()
-    result = policy.check_plan_approval(
-        decision.final_requirements,
-        final_tasks,
-        assumptions=assumptions,
-        findings=reconciled_findings,
-        blocking_questions=spec_output.blocking_questions if spec_output else [],
-    )
-    if not result.passed and not force:
-        console.print("[yellow]Plan still fails approval gates:[/yellow]")
-        for gap in result.gaps:
-            marker = "[red][BLOCKING][/red] " if gap.blocking else ""
-            console.print(f" - {marker}{gap.description} (Fix: {gap.recommended_fix})")
-        console.print("Resolve the gaps and re-run 'dev plan', or use --force to approve anyway.")
-        raise typer.Exit(code=1)
-
-    with db.get_session() as session:
-        GapRepository(session).delete_plan_gaps()
-        PlanningStateRepository(session).replace_active_plan(
-            decision.final_requirements,
-            assumptions,
-            final_tasks,
-            reconciled_findings,
-        )
-
-    orchestrator = Orchestrator(root)
-    try:
-        asyncio.run(orchestrator.transition_to(ProjectPhase.PLAN_APPROVED))
-    except ValueError as exc:
-        console.print(f"[red]Cannot approve from the current project phase: {exc}[/red]")
-        raise typer.Exit(code=1)
-    console.print(f"[green]Plan from run {run_dir.name} approved ({len(final_tasks)} tasks).[/green]")
-    console.print("Use 'dev tasks list' to see the planned tasks and 'dev run TASK-ID' to execute one.")
-
-
-@app.command()
-def plan(
-    goal: str = typer.Argument(..., help="The goal of the implementation"),
-    requirements_only: bool = typer.Option(False, "--requirements-only", help="Only generate requirements"),
-    dry_run: bool = typer.Option(False, "--dry-run", help="Simulate planning without LLM calls"),
-    quick: bool = typer.Option(
-        False,
-        "--quick",
-        help="Rigor dial: skip the A/B debate, critique, rebuttal, and arbitration. "
-        "One spec + one plan (~5 fewer model calls). Verification still gates every diff.",
-    ),
-    persist: bool = typer.Option(
-        False,
-        "--persist/--no-persist",
-        help="Persist dry-run planning artifacts into the main state database.",
-    ),
-    project_root: Path = typer.Option(Path("."), "--project-root", help="Repository root containing .devcouncil/."),
-):
-    """
-    Run the full planning cycle (Repo map -> Spec -> Plan A/B -> Critique -> Arbiter).
-    """
-    should_persist = persist or not dry_run
-    try:
-        asyncio.run(run_plan_flow(goal, requirements_only, dry_run, should_persist, project_root, quick=quick))
-    except (ProviderRequestError, StructuredOutputError) as exc:
-        print_planning_error(exc)
-        raise typer.Exit(code=1)
-
-
-def print_planning_error(exc: Exception) -> None:
-    """Render a planning/model failure as an actionable message instead of a traceback."""
-    console.print(f"\n[red]Planning could not complete:[/red] {exc}")
-    if isinstance(exc, StructuredOutputError):
-        console.print(
-            "[yellow]Tip:[/yellow] this role's model could not return valid structured JSON. "
-            "Free/very small models often can't. Set a more capable model, e.g.\n"
-            f"  [bold]dev config models --role {exc.role} --model anthropic/claude-sonnet-4.6[/bold]\n"
-            "  (or set all roles: [bold]dev config models --model <model>[/bold])"
-        )
-    elif isinstance(exc, ProviderRequestError) and exc.status_code == 402:
-        console.print(
-            "[yellow]Tip:[/yellow] add credits at https://openrouter.ai/settings/credits, "
-            "or switch to a free/cheaper model with [bold]dev config models --model <model>[/bold]."
-        )