devcouncil 0.1.1 → 0.3.0

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

@@ -12,14 +12,16 @@ 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)
 
-    initialize_project(Path("."), quiet=True)
-    db = get_db()
+    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)

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

@@ -1,8 +1,9 @@
 import typer
-import subprocess
 from pathlib import Path
 from rich.console import Console
 
+from devcouncil.execution.checkpoints import CheckpointService
+
 app = typer.Typer()
 console = Console()
 
@@ -19,42 +20,40 @@ def rollback(
         return
 
     root = project_root.expanduser().resolve()
-    checkpoint_file = root / ".devcouncil" / "checkpoints" / f"{task_id}-before.patch"
-    after_patch = root / ".devcouncil" / "checkpoints" / f"{task_id}-after.patch"
+    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():
-        console.print(
-            f"[red]No checkpoint found for task {task_id}. Expected {after_patch} "
-            f"or {checkpoint_file}.[/red]"
-        )
-        raise typer.Exit(code=1)
+        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]...")
-    
-    try:
-        if after_patch.exists():
-            # Reverse-apply the task's changes only
-            console.print(f"Applying reverse patch from [bold]{after_patch}[/bold]...")
-            subprocess.check_call(
-                ["git", "apply", "-R", str(after_patch)],
-                cwd=root,
-            )
-            console.print(f"[green]Successfully rolled back task {task_id} changes.[/green]")
-        else:
-            # No after-patch, but we have the before-patch — warn and offer manual reset
+    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"[yellow]No after-patch found at {after_patch}.[/yellow]\n"
                 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)"
             )
-    except subprocess.CalledProcessError as e:
-        console.print(f"[red]Failed to apply reverse patch: {e}[/red]")
-        console.print("[yellow]The patch may conflict with current changes. Try resolving manually:[/yellow]")
-        console.print(f"  git apply -R --3way {after_patch}")
-        raise typer.Exit(code=1)
-    except Exception as e:
-        console.print(f"[red]Failed to rollback: {e}[/red]")
+        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,5 +1,5 @@
+import logging
 import typer
-import json
 from rich.console import Console
 from pathlib import Path
 from devcouncil.storage.db import get_db
@@ -7,6 +7,11 @@ from devcouncil.storage.repositories import TaskRepository, RequirementRepositor
 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
@@ -16,20 +21,19 @@ from devcouncil.storage.repositories import GapRepository, EvidenceRepository, S
 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 = {
-    "codex": "codex",
-    "codex-cli": "codex",
-    "gemini": "gemini",
-    "gemini-cli": "gemini",
-    "claude": "claude",
-    "claude-code": "claude",
-    "claude-cli": "claude",
-}
+logger = logging.getLogger(__name__)
+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
 
@@ -38,28 +42,16 @@ def _current_changed_files(project_root: Path = Path(".")) -> list[str]:
 def _capture_after_patch(task_id: str, project_root: Path = Path(".")):
     """Capture the diff after task execution for use by rollback."""
     try:
-        from devcouncil.verification.verifier import Verifier
-
-        checkpoint_dir = project_root / ".devcouncil" / "checkpoints"
-        checkpoint_dir.mkdir(exist_ok=True)
-        diff = Verifier(project_root).get_diff()
-        if diff:
-            with open(checkpoint_dir / f"{task_id}-after.patch", "w", encoding="utf-8") as f:
-                f.write(diff)
+        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(".")):
-    checkpoint_dir = project_root / ".devcouncil" / "checkpoints"
-    checkpoint_dir.mkdir(exist_ok=True)
-    snapshot = {
-        "task_id": task_id,
-        "changed_files": _current_changed_files(project_root),
-    }
-    (checkpoint_dir / f"{task_id}-before.json").write_text(
-        json.dumps(snapshot, indent=2),
-        encoding="utf-8",
-    )
+    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)
@@ -68,8 +60,14 @@ def _verify_after_execution(session, task, reqs, router=None, project_root: Path
     """Run deterministic verification after an automated executor finishes."""
     import asyncio
 
+    logger.info("Verifying task %s (router=%s)", task.id, "yes" if router else "no")
     verifier = Verifier(project_root, router=router)
     gaps, evidence = asyncio.run(verifier.verify_task(task, reqs))
+    blocking = [g for g in gaps if g.blocking]
+    logger.info(
+        "Verification of %s: %d gap(s) (%d blocking), %d evidence item(s)",
+        task.id, len(gaps), len(blocking), len(evidence),
+    )
 
     gap_repo = GapRepository(session)
     evidence_repo = EvidenceRepository(session)
@@ -90,13 +88,116 @@ def _verify_after_execution(session, task, reqs, router=None, project_root: Path
     task.status = "blocked" if any(g.blocking for g in gaps) else "verified"
     return task.status == "verified"
 
+
+def _build_verification_router(project_root: Path):
+    """Best-effort ``ModelRouter`` for LLM-backed verification after a coding-agent run.
+
+    Without a router the ``Verifier`` runs deterministic checks only (no
+    ``implementation_reviewer`` review, no acceptance-criterion compilation). The native
+    executor already builds a router to *run* the agent and reuses it for verification;
+    CLI coding agents (claude, codex, …) don't need one to execute, so they previously
+    verified without the LLM review at all. Build one here so the review gate guides and
+    monitors execution for those agents too. Per-role provider config means these review
+    roles can run on a different provider than planning (e.g. local Ollama).
+
+    Returns ``None`` when no provider/API key is configured so verification degrades to
+    deterministic-only instead of erroring — the LLM review is an enhancement, not a
+    hard requirement of running a task.
+    """
+    try:
+        config = load_config(project_root)
+        validate_model_provider(config.models.provider)
+        api_key = get_api_key(config.models.provider, project_root)
+        provider = create_provider(
+            config.models.provider, api_key, project_root=project_root, provider_prefs=config.provider
+        )
+        role_config = {name: role.model_dump() for name, role in config.models.roles.items()}
+        return ModelRouter(provider, role_config, project_root=project_root)
+    except Exception:
+        return None
+
+
+def _run_live_review_after_execution(project_root: Path, client: str, task_id: str | None) -> None:
+    """Critique the coding agent's latest turn with the ``live_reviewer`` role.
+
+    This is what makes live review actually fire during ``dev e2e``/``dev run`` (previously
+    it only ran via ``dev watch``). It produces an advisory critique card — it does NOT
+    gate the task; the deterministic/LLM verifier already does that. The card feeds the
+    final report's live-review summary and is routed by per-role config (e.g. a local
+    Ollama ``live_reviewer`` while planning runs on OpenRouter).
+
+    The transcript is resolved the same way ``dev watch`` does — the client's NATIVE
+    session log (e.g. claude's projects JSONL), discovered for this project root — not the
+    executor's streamed ``transcript.txt`` (which only exists with --stream and isn't the
+    structured turn format ``latest_assistant_turn`` parses).
+
+    Best-effort and opt-outable: skipped when ``integrations.live_review.enabled`` is
+    false, when no transcript is found, or on any error — a live-review hiccup must never
+    fail the run.
+    """
+    import asyncio
+
+    try:
+        if not load_config(project_root).integrations.live_review.enabled:
+            return
+        from devcouncil.cli.commands.watch import (
+            _resolve_transcript,
+            _review_turn,
+            _save_card_once,
+            _log_card_reviewed,
+        )
+        from devcouncil.live.transcripts import latest_assistant_turn
+
+        transcript = _resolve_transcript(project_root, client, latest=True)
+        if transcript is None or not transcript.exists():
+            return
+        turn = latest_assistant_turn(transcript, client=client)
+        if turn is None:
+            return
+        card = asyncio.run(_review_turn(turn, project_root, client, use_llm=True, task_id=task_id))
+        saved_path, duplicate = _save_card_once(project_root, card, persist=True, force=False)
+        if saved_path:
+            _log_card_reviewed(project_root, card, saved_path, duplicate=duplicate, source="e2e")
+            console.print(f"[dim]Live review ({card.verdict}): {saved_path}[/dim]")
+    except Exception as exc:  # noqa: BLE001 - advisory; never fail the run on a review hiccup
+        console.print(f"[yellow]Live review skipped: {exc}[/yellow]")
+
+
+def _log_exec_outcome(executor: str, task_id: str, *, verified: bool) -> None:
+    """Log a non-coding-CLI executor's post-verification outcome (verified vs blocked),
+    so standalone ``dev run`` has the same flow-decision trail as ``dev go``."""
+    if verified:
+        logger.info("%s finished and %s verified", executor, task_id)
+    else:
+        logger.warning("%s finished but %s blocked by verification gaps", executor, task_id)
+
+
+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, codex, codex-cli, gemini, gemini-cli, claude, claude-code, claude-cli)",
+        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/."),
 ):
@@ -104,6 +205,9 @@ def run(
     Execute a specific task.
     """
     root = project_root.expanduser().resolve()
+    from devcouncil.telemetry.logging_setup import set_log_dir
+    set_log_dir(root)
+    logger.info("dev run: task=%s executor=%s profile=%s stream=%s", task_id, executor, profile, stream)
     initialize_project(root, quiet=True)
     db = get_db(root)
     if not db:
@@ -118,9 +222,13 @@ def run(
             return
 
         from devcouncil.gating.policy import GatePolicy
-        policy = GatePolicy()
-        gate_result = policy.check_task_ready(task, root)
+        gate_policy = GatePolicy()
+        gate_result = gate_policy.check_task_ready(task, root)
         if not gate_result.passed:
+            logger.warning(
+                "Task %s failed readiness gate: %s",
+                task_id, "; ".join(g.description for g in gate_result.gaps if g.blocking),
+            )
             console.print(f"[red]Task {task_id} is not ready for execution.[/red]")
             for gap in gate_result.gaps:
                 if gap.blocking:
@@ -131,48 +239,70 @@ def run(
 
         # 1. Create Git checkpoint
         try:
-            from devcouncil.verification.verifier import Verifier
-
-            checkpoint_dir = root / ".devcouncil" / "checkpoints"
-            checkpoint_dir.mkdir(exist_ok=True)
-            _capture_before_snapshot(task_id, root)
-            diff = Verifier(root).get_diff()
-            if diff:
-                with open(checkpoint_dir / f"{task_id}-before.patch", "w", encoding="utf-8") as f:
-                    f.write(diff)
-                console.print(f"Created git checkpoint at {checkpoint_dir}/{task_id}-before.patch")
+            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("_", "-")
+        custom_agents = _custom_cli_agents(root)
+        if executor not in CODING_EXECUTORS and executor not in custom_agents:
+            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)
+            logger.info("%s marked RUNNING for manual sidecar execution", task_id)
             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:
+        elif executor in CODING_EXECUTORS or executor in custom_agents:
             _record_project_phase(session, ProjectPhase.TASK_EXECUTING)
             req_repo = RequirementRepository(session)
             reqs = req_repo.get_all()
-            cli_client = CODING_EXECUTOR_ALIASES[executor]
-            cli_executor = CodingCliExecutor(root, cli_client)
+            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)
+                verified = _verify_after_execution(
+                    session, task, reqs, router=_build_verification_router(root), 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)
+                transcript_path = getattr(cli_executor, "last_transcript_path", None)
+                if run_id:
+                    run_dir = root / ".devcouncil" / "runs" / run_id
+                    console.print(f"Run artifacts: [dim]{run_dir}[/dim]")
+                    if (run_dir / "run.log").exists():
+                        console.print(f"Run log: [dim]dev logs tail --run {run_id}[/dim]")
+                    if transcript_path:
+                        console.print(f"Transcript: [dim]{transcript_path}[/dim]")
+                # Live review (advisory): critique the agent's turn with the live_reviewer
+                # role so monitoring actually happens during execution, not only via watch.
+                _run_live_review_after_execution(root, cli_client, task.id)
+                _log_exec_outcome(executor, task_id, verified=verified)
                 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:
+                logger.error("%s failed to start or execute for %s: %s", executor, task_id, exec_result.message)
                 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)
@@ -183,17 +313,21 @@ def run(
             _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)
+                verified = _verify_after_execution(
+                    session, task, reqs, router=_build_verification_router(root), project_root=root
+                )
                 _record_project_phase(
                     session,
                     ProjectPhase.TASK_VERIFIED if verified else ProjectPhase.TASK_BLOCKED,
                 )
                 task_repo.save(task)
+                _log_exec_outcome("mini-SWE-agent", task_id, verified=verified)
                 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:
+                logger.error("mini-SWE-agent failed to start or execute for %s", task_id)
                 console.print("\n[red]mini-SWE-agent failed to start or execute.[/red]")
         elif executor == "openhands":
             _record_project_phase(session, ProjectPhase.TASK_EXECUTING)
@@ -204,31 +338,36 @@ def run(
             _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)
+                verified = _verify_after_execution(
+                    session, task, reqs, router=_build_verification_router(root), project_root=root
+                )
                 _record_project_phase(
                     session,
                     ProjectPhase.TASK_VERIFIED if verified else ProjectPhase.TASK_BLOCKED,
                 )
                 task_repo.save(task)
+                _log_exec_outcome("OpenHands", task_id, verified=verified)
                 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:
+                logger.error("OpenHands failed to start or execute for %s", task_id)
                 console.print("\n[red]OpenHands failed to start or execute.[/red]")
-        elif executor == "native":
+        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:
+                logger.error("Native executor cannot start for %s: %s", task_id, e)
                 console.print(f"[red]{e}[/red]")
                 return
             
-            provider = create_provider(config.models.provider, api_key)
+            provider = create_provider(config.models.provider, api_key, project_root=root, provider_prefs=config.provider)
             role_config = {name: role.model_dump() for name, role in config.models.roles.items()}
-            router = ModelRouter(provider, role_config)
+            router = ModelRouter(provider, role_config, project_root=root)
             
             # Setup Permission System
             from devcouncil.execution.permissions import PermissionPolicy, PermissionManager
@@ -236,19 +375,18 @@ def run(
             
             # Populate policy from config commands
             allowed_cmds = config.commands.test + config.commands.lint + config.commands.typecheck
-            policy = PermissionPolicy(
+            permission_policy = PermissionPolicy(
                 allowed_shell_commands=allowed_cmds,
             )
-            perm_manager = PermissionManager(policy, root)
+            perm_manager = PermissionManager(permission_policy, root)
             task_runner = TaskRunner(root, perm_manager)
             
             req_repo = RequirementRepository(session)
             reqs = req_repo.get_all()
             
-            import asyncio
             _record_project_phase(session, ProjectPhase.TASK_EXECUTING)
             agent = NativeAgent(router, task_runner)
-            exec_result = asyncio.run(agent.run_task(task, reqs))
+            exec_result = agent.run_task(task, reqs)
             _capture_after_patch(task_id, root)
             
             if exec_result.success:
@@ -259,11 +397,14 @@ def run(
                     ProjectPhase.TASK_VERIFIED if verified else ProjectPhase.TASK_BLOCKED,
                 )
                 task_repo.save(task)
+                _log_exec_outcome("Native agent", task_id, verified=verified)
                 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:
+                logger.error("Native agent failed during execution for %s", task_id)
                 console.print("\n[red]Native agent failed during execution.[/red]")
         else:
+            logger.error("Executor %r not implemented", executor)
             console.print(f"[red]Executor {executor} not yet implemented.[/red]")