devcouncil 0.1.0 → 0.2.0

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

@@ -1,47 +1,61 @@
-import typer
-from rich.console import Console
-from rich.markdown import Markdown
-from devcouncil.storage.db import get_db
-from devcouncil.storage.repositories import TaskRepository, RequirementRepository
+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)
+
+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
-
-    db = get_db()
-    if not db:
-        console.print("[red]DevCouncil not initialized. Run 'dev init' first.[/red]")
-        raise typer.Exit(code=1)
-
-    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:
-            console.print(f"[red]Task {task_id} not found.[/red]")
-            raise typer.Exit(code=1)
-        
-        reqs = req_repo.get_all()
-        
-        builder = PromptBuilder(Path("."))
+    """
+    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 pretty:
+        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,69 +1,89 @@
-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 OpenRouterProvider
-from devcouncil.llm.router import ModelRouter
-from devcouncil.app.config import load_config, get_api_key
-import asyncio
-from pathlib import Path
-
-app = typer.Typer()
-console = Console()
-
-async def run_repair_flow():
-    db = get_db()
-    if not db:
-        console.print("[red]DevCouncil not initialized. Run 'dev init' first.[/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
-        try:
-            config = load_config(Path("."))
-            api_key = get_api_key(config.models.provider)
-        except (FileNotFoundError, ValueError) as e:
-            console.print(f"[red]{e}[/red]")
-            return
-        
-        provider = OpenRouterProvider(api_key)
-        role_config = {name: role.model_dump() for name, role in config.models.roles.items()}
-        router = ModelRouter(provider, role_config)
-        repair_service = RepairService(router)
-        context_builder = ContextBuilder(Path("."))
-        
-        # Build minimal context for repair.
-        project_context = context_builder.get_structure_summary()
-
-        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)
-            console.print(f"  - Created intelligent repair task [bold]{task.id}[/bold]: {task.title}")
-
-        console.print(f"\n[green]Successfully generated {len(repair_output.suggested_tasks)} repair tasks.[/green]")
-
-@app.callback(invoke_without_command=True)
-def repair(ctx: typer.Context):
-    """
-    Convert blocking gaps into intelligent repair tasks using LLM inference.
-    """
-    if ctx.invoked_subcommand is not None:
-        return
-
-    asyncio.run(run_repair_flow())
+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,71 +1,137 @@
-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
+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):
-    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"]).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]")
-
-@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"),
-):
-    """
-    Produce final evidence report.
-    """
-    if ctx.invoked_subcommand is not None:
-        return
-
-    db = get_db()
-    if not db:
-        console.print("[red]DevCouncil not initialized. Run 'dev init' first.[/red]")
-        raise typer.Exit(code=1)
-
-    with db.get_session() as session:
+
+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()
-        TraceLogger(Path(".")).log_event(
+        live_review = live_review_summary(root)
+        TraceLogger(root).log_event(
             "report_generated",
-            {"json": json_format, "github": github, "planning_only": planning_only},
+            {
+                "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))
-            return
-
+            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)
+            output = ReportBuilder.build_json(graph, live_review=live_review)
             typer.echo(output)
         else:
-            output = ReportBuilder.build_markdown(graph)
+            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,28 +1,33 @@
-import typer
-from rich.console import Console
-from sqlmodel import delete
-
-from devcouncil.storage.db import get_db
-from devcouncil.storage.models import EvidenceModel, GapModel, RequirementModel, TaskModel
-
-console = Console()
-
-
-def reset_demo_state(
-    yes: bool = typer.Option(False, "--yes", help="Confirm clearing planning/demo artifacts."),
-):
-    """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)
-
-    db = get_db()
-    if not db:
-        console.print("[red]DevCouncil not initialized. Run 'dev init' first.[/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]")
+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,58 +1,59 @@
-import typer
-import subprocess
-from pathlib import Path
-from rich.console import Console
-
-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"),
-):
-    """
-    Revert changes using a task's git checkpoint.
-    """
-    if ctx.invoked_subcommand is not None:
-        return
-
-    checkpoint_file = Path(".devcouncil/checkpoints") / f"{task_id}-before.patch"
-    after_patch = Path(".devcouncil/checkpoints") / f"{task_id}-after.patch"
+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():
-        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=".",
-            )
-            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
-            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]")
-        raise typer.Exit(code=1)
+    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}")