devcouncil 0.3.0 → 0.4.0

package/src/devcouncil/integrations/github.py

@@ -1,10 +1,16 @@
-import httpx
+import asyncio
 import logging
+
+import httpx
+
 from devcouncil.artifacts.graph import ArtifactGraph
 from devcouncil.reporting.github_check import GitHubCheckGenerator
 
 logger = logging.getLogger(__name__)
 
+_RETRYABLE_STATUS = {429, 500, 502, 503, 504}
+
+
 class GitHubIntegration:
     """Manages interactions with GitHub API, specifically PR Checks."""
     
@@ -14,6 +20,66 @@ class GitHubIntegration:
         self.commit_sha = commit_sha
         self.base_url = f"https://api.github.com/repos/{repository}"
 
+    async def _post_with_retry(
+        self,
+        client: httpx.AsyncClient,
+        url: str,
+        *,
+        headers: dict,
+        json: dict,
+        max_attempts: int = 3,
+    ) -> httpx.Response:
+        last_exc: Exception | None = None
+        for attempt in range(1, max_attempts + 1):
+            try:
+                response = await client.post(url, headers=headers, json=json)
+                if response.status_code in _RETRYABLE_STATUS and attempt < max_attempts:
+                    delay = min(30.0, 2.0 ** attempt)
+                    logger.warning(
+                        "GitHub POST %s returned %s; retrying %d/%d in %.0fs",
+                        url,
+                        response.status_code,
+                        attempt,
+                        max_attempts,
+                        delay,
+                    )
+                    await asyncio.sleep(delay)
+                    continue
+                response.raise_for_status()
+                return response
+            except httpx.TimeoutException as exc:
+                last_exc = exc
+                if attempt >= max_attempts:
+                    raise
+                delay = min(30.0, 2.0 ** attempt)
+                logger.warning(
+                    "GitHub POST %s timed out; retrying %d/%d in %.0fs",
+                    url,
+                    attempt,
+                    max_attempts,
+                    delay,
+                )
+                await asyncio.sleep(delay)
+            except httpx.HTTPStatusError:
+                raise
+            except httpx.HTTPError as exc:
+                last_exc = exc
+                if attempt >= max_attempts:
+                    raise
+                delay = min(30.0, 2.0 ** attempt)
+                logger.warning(
+                    "GitHub POST %s failed (%s); retrying %d/%d in %.0fs",
+                    url,
+                    exc,
+                    attempt,
+                    max_attempts,
+                    delay,
+                )
+                await asyncio.sleep(delay)
+        if last_exc is not None:
+            raise last_exc
+        raise RuntimeError("GitHub POST failed without a response")
+
     async def report_verification(self, graph: ArtifactGraph):
         """Creates or updates a GitHub Check Run with the current verification status."""
         payload = GitHubCheckGenerator.generate(graph)
@@ -22,18 +88,18 @@ class GitHubIntegration:
         headers = {
             "Authorization": f"Bearer {self.github_token}",
             "Accept": "application/vnd.github.v3+json",
-            "Content-Type": "application/json"
+            "Content-Type": "application/json",
         }
         
         async with httpx.AsyncClient() as client:
             try:
-                response = await client.post(
+                await self._post_with_retry(
+                    client,
                     f"{self.base_url}/check-runs",
                     headers=headers,
-                    json=payload
+                    json=payload,
                 )
-                response.raise_for_status()
-                logger.info(f"GitHub PR Check updated for {self.repository} at {self.commit_sha}")
+                logger.info("GitHub PR Check updated for %s at %s", self.repository, self.commit_sha)
             except Exception as e:
-                logger.error(f"Failed to report to GitHub: {e}")
+                logger.error("Failed to report to GitHub: %s", e)
                 raise

package/src/devcouncil/integrations/integration_cli.py

@@ -0,0 +1,197 @@
+"""Rich/JSON renderers for dev integrate subcommands."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from devcouncil.executors.agent_registry import (
+    BUILTIN_CODING_EXECUTOR_NAMES,
+    CODING_CLI_INTEGRATION_INFO,
+    detect_available_coding_cli,
+    integration_tier_label,
+    resolve_automated_executor,
+    resolve_coding_cli_executable,
+    resolve_coding_cli_probe_order,
+)
+from devcouncil.integrations.check import build_integration_check_report, integration_status_summary
+from devcouncil.integrations.clients.common import _load_raw_config
+
+PREFERRED_COMMAND = "dev integrate"
+
+
+def print_recommendations(root: Path, console: Console) -> None:
+    probe_order = resolve_coding_cli_probe_order(root)
+    detected = detect_available_coding_cli(root, probe_order=probe_order)
+    resolved = resolve_automated_executor(root, None)
+
+    table = Table(title="DevCouncil Integration Recommendations")
+    table.add_column("Client", style="cyan")
+    table.add_column("PATH")
+    table.add_column("Tier")
+    table.add_column("MCP")
+    table.add_column("Hooks")
+
+    for client in probe_order:
+        info = CODING_CLI_INTEGRATION_INFO.get(client)
+        on_path = resolve_coding_cli_executable(root, client)
+        table.add_row(
+            client,
+            "[green]yes[/green]" if on_path else "[dim]no[/dim]",
+            integration_tier_label(client),
+            "yes" if info and info.mcp else "no",
+            "yes" if info and info.hooks else "no",
+        )
+
+    console.print(table)
+    if summary := integration_status_summary(root):
+        if summary.get("custom_probe_order"):
+            console.print(
+                f"\n[dim]Probe order:[/dim] {', '.join(summary['probe_order'])} "
+                f"(from execution.coding_cli_probe_order)"
+            )
+        else:
+            console.print(f"\n[dim]Probe order:[/dim] {', '.join(summary['probe_order'])} (default)")
+    if detected:
+        console.print(f"\n[bold]Recommended executor:[/bold] [cyan]{resolved}[/cyan]")
+        console.print(f"Run: [dim]dev run TASK-001 --executor {resolved}[/dim]")
+        console.print(f"Or:  [dim]dev go \"Your goal\" --executor {resolved}[/dim]")
+        console.print(f"Setup: [dim]{PREFERRED_COMMAND} {resolved} --apply[/dim]")
+    else:
+        console.print("\n[yellow]No built-in coding CLI was found on PATH.[/yellow]")
+        console.print("Install Codex, Claude Code, Cursor Agent, OpenCode, Antigravity, or register a custom CLI:")
+        console.print(f"[dim]{PREFERRED_COMMAND} cli-agent NAME --command TOOL --apply[/dim]")
+
+
+def print_integration_status(root: Path, console: Console, *, as_json: bool) -> None:
+    summary = integration_status_summary(root)
+    raw_config = _load_raw_config(root) if (root / ".devcouncil").exists() else {}
+    integrations = raw_config.get("integrations", {})
+
+    if as_json:
+        payload = {
+            **summary,
+            "integrations_enabled": {
+                name: bool(integrations.get(name, {}).get("enabled"))
+                for name in ("cursor", "opencode", "antigravity", "warp", "aider")
+            },
+        }
+        typer.echo(json.dumps(payload, indent=2))
+        return
+
+    table = Table(title="DevCouncil Integration Status")
+    table.add_column("Setting", style="cyan")
+    table.add_column("Value")
+
+    table.add_row("Project", "[green]initialized[/green]" if summary["project_initialized"] else "[yellow]not initialized[/yellow]")
+    table.add_row("Default executor", summary["default_executor"])
+    table.add_row("Resolved executor", summary["resolved_executor"])
+    table.add_row("CLIs on PATH", ", ".join(summary["coding_clis_on_path"]) or "[dim]none[/dim]")
+    table.add_row("Probe order", ", ".join(summary["probe_order"]))
+    table.add_row("Stream CLI output", "yes" if summary["stream_cli_output"] else "no")
+    table.add_row("Cursor resume mode", summary["cursor_resume_mode"])
+    table.add_row("Grok resume mode", summary.get("grok_resume_mode", "off"))
+
+    for name in ("cursor", "grok", "opencode", "antigravity", "warp", "aider"):
+        enabled = bool(integrations.get(name, {}).get("enabled"))
+        table.add_row(f"{name} integration", "[green]enabled[/green]" if enabled else "[dim]off[/dim]")
+
+    console.print(table)
+    if summary["resolved_executor"] not in {"", "manual"}:
+        console.print(
+            f"\n[dim]Next:[/dim] dev run TASK-001 --executor {summary['resolved_executor']} "
+            f"| {PREFERRED_COMMAND} check for full readiness"
+        )
+    else:
+        console.print(f"\n[dim]Next:[/dim] {PREFERRED_COMMAND} recommend | {PREFERRED_COMMAND} check")
+
+
+def print_integration_matrix(console: Console) -> None:
+    table = Table(title="DevCouncil Coding CLI Integration Matrix")
+    table.add_column("Client", style="cyan")
+    table.add_column("Tier")
+    table.add_column("Headless")
+    table.add_column("MCP setup")
+    table.add_column("Native hooks")
+    table.add_column("Enforcement")
+    table.add_column("Notes")
+
+    for client in sorted(BUILTIN_CODING_EXECUTOR_NAMES):
+        info = CODING_CLI_INTEGRATION_INFO.get(client)
+        posture = info.enforcement if info else "verify-only"
+        posture_render = {
+            "pre-action": "[green]pre-action[/green]",
+            "advisory+verify": "[cyan]advisory+verify[/cyan]",
+        }.get(posture, "[yellow]verify-only[/yellow]")
+        table.add_row(
+            client,
+            integration_tier_label(client),
+            "yes" if info and info.tier == 1 else "no",
+            "yes" if info and info.mcp else "no",
+            "yes" if info and info.hooks else "verify only",
+            posture_render,
+            info.notes if info else "",
+        )
+    console.print(table)
+    console.print(
+        "\n[dim]Enforcement:[/dim] [green]pre-action[/green] blocks forbidden writes/commands "
+        "before they happen; [cyan]advisory+verify[/cyan] warns in native hooks and "
+        "contains through sandbox/verification; [yellow]verify-only[/yellow] catches them at verify time."
+    )
+    console.print("\nSee [dim]docs/coding-cli-integration.md[/dim] for workflow guidance.")
+
+
+def run_integration_check(
+    root: Path,
+    console: Console,
+    *,
+    strict: bool,
+    as_json: bool,
+    report_file: Path | None,
+    legacy_command: str = "dev setup --integrate",
+) -> None:
+    report = build_integration_check_report(root, strict=strict)
+    table = Table(title="DevCouncil Integration Check")
+    table.add_column("Check", style="cyan")
+    table.add_column("Status", style="magenta")
+    table.add_column("Details")
+
+    for row in report.checks:
+        if row.status == "ok":
+            rendered = "[green]OK[/green]"
+        elif row.status == "skip":
+            rendered = "[dim]SKIP[/dim]"
+        elif row.status == "missing":
+            rendered = "[yellow]Missing[/yellow]"
+        else:
+            rendered = "[red]FAIL[/red]"
+        table.add_row(row.name, rendered, row.details)
+
+    write_json = as_json or report_file is not None
+    if write_json:
+        json_text = report.to_json()
+        if report_file is not None:
+            report_path = Path(report_file).expanduser().resolve()
+            report_path.parent.mkdir(parents=True, exist_ok=True)
+            report_path.write_text(json_text + "\n", encoding="utf-8")
+            if not as_json:
+                console.print(f"[dim]Wrote integration report to[/dim] {report_path}")
+        if as_json:
+            typer.echo(json_text)
+    if not write_json or not as_json:
+        console.print(table)
+
+    if report.failures:
+        if not as_json:
+            console.print(
+                f"\n[yellow]Fix failed checks, then run:[/yellow] {PREFERRED_COMMAND} all --apply "
+                f"(or {legacy_command} --apply)."
+            )
+        raise typer.Exit(code=1)
+
+    if not as_json:
+        console.print(f"\n[green]Ready.[/green] Run: {PREFERRED_COMMAND} all --apply (or {legacy_command} --apply).")

package/src/devcouncil/integrations/mcp/handlers/__init__.py

@@ -0,0 +1 @@
+"""MCP tool handler modules extracted from server.call_tool."""

package/src/devcouncil/integrations/mcp/handlers/ast_lsp.py

@@ -0,0 +1,77 @@
+"""AST match and LSP status MCP tool handlers."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from mcp.types import TextContent
+
+from devcouncil.indexing.ast_matcher import AstMatcher
+from devcouncil.indexing.lsp import LspInspector
+from devcouncil.integrations.mcp.util import (
+    error_text,
+    int_argument,
+    optional_string_argument,
+)
+
+_AST_MATCHER_CACHE: dict[str, AstMatcher] = {}
+_LSP_INSPECTOR_CACHE: dict[str, LspInspector] = {}
+
+
+def reset_caches() -> None:
+    """Drop per-root AST/LSP caches (for test isolation)."""
+    _AST_MATCHER_CACHE.clear()
+    _LSP_INSPECTOR_CACHE.clear()
+
+
+def get_ast_matcher(root: Path) -> AstMatcher:
+    key = str(root.resolve())
+    matcher = _AST_MATCHER_CACHE.get(key)
+    if matcher is None:
+        matcher = AstMatcher(root)
+        _AST_MATCHER_CACHE[key] = matcher
+    return matcher
+
+
+def get_lsp_inspector(root: Path) -> LspInspector:
+    key = str(root.resolve())
+    inspector = _LSP_INSPECTOR_CACHE.get(key)
+    if inspector is None:
+        inspector = LspInspector(root)
+        _LSP_INSPECTOR_CACHE[key] = inspector
+    return inspector
+
+
+async def handle_lsp_status(root: Path, arguments: dict) -> list[TextContent]:
+    _ = arguments
+    client_enabled = False
+    try:
+        from devcouncil.indexing.lsp_client import lsp_refs_enabled
+
+        client_enabled = lsp_refs_enabled(root)
+    except Exception:
+        client_enabled = False
+    return [
+        TextContent(
+            type="text",
+            text=get_lsp_inspector(root).summary_json(client_enabled=client_enabled),
+        )
+    ]
+
+
+async def handle_ast_match(root: Path, arguments: dict) -> list[TextContent]:
+    query = optional_string_argument(arguments, "query")
+    language = optional_string_argument(arguments, "language")
+    kind = optional_string_argument(arguments, "kind")
+    for arg_name, value in [("query", query), ("language", language), ("kind", kind)]:
+        if value == "":
+            return error_text(f"{arg_name} must be a string", code="invalid_arguments", argument=arg_name)
+    limit = int_argument(arguments, "limit", 100, minimum=1, maximum=500)
+    matches = get_ast_matcher(root).match(
+        query=query or "",
+        language=language,
+        kind=kind,
+        limit=limit,
+    )
+    return [TextContent(type="text", text=json.dumps({"matches": [item.model_dump() for item in matches]}, indent=2))]

package/src/devcouncil/integrations/mcp/handlers/checkout.py

@@ -0,0 +1,50 @@
+"""Task checkout MCP tool handler."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Callable
+
+from mcp.types import TextContent
+
+from devcouncil.integrations.mcp.util import (
+    error_text,
+    json_text,
+    optional_string_argument,
+    parse_cli_json,
+    required_string_argument,
+    run_cli_command,
+)
+
+
+async def handle_checkout_task(
+    root: Path,
+    db: object,
+    arguments: dict,
+    *,
+    load_router: Callable[[Path], object | None],
+) -> list[TextContent]:
+    del db, load_router  # routed through CLI service layer
+    task_id, arg_error = required_string_argument(arguments, "task_id")
+    if arg_error:
+        return arg_error
+    client_id, arg_error = required_string_argument(arguments, "client_id")
+    if arg_error:
+        return arg_error
+    assert task_id is not None and client_id is not None
+    agent = optional_string_argument(arguments, "agent")
+    if agent == "":
+        return error_text("agent must be a string", code="invalid_arguments", argument="agent")
+    force_value = arguments.get("force", False)
+    if not isinstance(force_value, bool):
+        return error_text("force must be a boolean", code="invalid_arguments", argument="force")
+    cli_args = ["checkout", task_id, "--client-id", client_id, "--json"]
+    if agent:
+        cli_args.extend(["--agent", agent])
+    if force_value:
+        cli_args.append("--force")
+    payload, cli_error = parse_cli_json(run_cli_command(cli_args, root))
+    if cli_error:
+        return cli_error
+    assert payload is not None
+    return json_text(payload)

package/src/devcouncil/integrations/mcp/handlers/cli_gate.py

@@ -0,0 +1,43 @@
+"""Gated devcouncil_cli MCP tool handler."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from mcp.types import TextContent
+
+from devcouncil.integrations.mcp.util import error_text, json_text, run_cli_command
+
+CLI_ALLOWED_ROOTS = frozenset({
+    "status", "tasks", "report", "map", "prompt", "show", "trace", "lsp", "ast",
+    "verify", "verify-leased", "rollback", "gaps", "doctor", "cost", "check", "export", "requirements",
+    "runs", "logs", "watch", "go", "wiki", "okf", "graph-context", "provenance", "resource",
+    "checkout", "release", "lease", "write", "apply-patch",
+    "next-task", "scope", "policy-check", "record-command", "run-cmd",
+    "evidence-append", "evidence-list", "handoff-leased",
+})
+CLI_FORBIDDEN_FLAGS = frozenset({"--project-root", "--github", "--github-pr-comment", "--gitlab-pr-comment"})
+
+
+def forbidden_cli_flags(args: list[str]) -> list[str]:
+    forbidden: set[str] = set()
+    for arg in args:
+        for flag in CLI_FORBIDDEN_FLAGS:
+            if arg == flag or arg.startswith(f"{flag}="):
+                forbidden.add(flag)
+    return sorted(forbidden)
+
+
+async def handle_cli(root: Path, arguments: dict) -> list[TextContent]:
+    args = arguments.get("args")
+    if not isinstance(args, list) or not all(isinstance(arg, str) for arg in args) or not args:
+        return error_text("args must be a non-empty string array", code="invalid_arguments")
+    if args[0] not in CLI_ALLOWED_ROOTS:
+        return error_text(f"command {args[0]} is not allowed through MCP", code="command_not_allowed", command=args[0])
+    forbidden = forbidden_cli_flags(args)
+    if forbidden:
+        return error_text("forbidden flag(s) through MCP: " + ", ".join(forbidden), code="forbidden_flags", flags=forbidden)
+    try:
+        return json_text(run_cli_command(args, root))
+    except Exception as exc:
+        return error_text(str(exc), code="cli_execution_error")

package/src/devcouncil/integrations/mcp/handlers/codeintel.py

@@ -0,0 +1,182 @@
+"""Registry-backed MCP tools for transactional code intelligence."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import Awaitable, Callable
+
+from mcp.types import TextContent, Tool
+
+from devcouncil.codeintel.query import CodeIntelQueryEngine
+from devcouncil.codeintel.service import canonical_project_root, get_codeintel_service
+from devcouncil.codeintel.sync import get_sync_coordinator
+from devcouncil.integrations.mcp.util import error_text, json_text, with_codeintel_freshness
+
+Handler = Callable[[Path, dict], Awaitable[list[TextContent]]]
+
+
+def _schema(properties: dict, required: list[str] | None = None) -> dict:
+    schema: dict = {"type": "object", "properties": {
+        "projectPath": {
+            "type": "string",
+            "description": "Explicit repository path; defaults to the MCP server project.",
+        },
+        **properties,
+    }}
+    if required:
+        schema["required"] = required
+    return schema
+
+
+def tools() -> list[Tool]:
+    return [
+        Tool(
+            name="devcouncil_code_explore",
+            description="Unified code exploration: source, callers/callees, semantic hops, and blast radius.",
+            inputSchema=_schema({
+                "query": {"type": "string"},
+                "limit": {"type": "integer", "minimum": 1, "maximum": 100, "default": 20},
+            }, ["query"]),
+        ),
+        Tool(
+            name="devcouncil_code_search",
+            description="FTS5 symbol, qualified-name, and path search over the committed generation.",
+            inputSchema=_schema({
+                "query": {"type": "string"},
+                "limit": {"type": "integer", "minimum": 1, "maximum": 500, "default": 50},
+            }, ["query"]),
+        ),
+        Tool(
+            name="devcouncil_code_path",
+            description="Shortest call/import/framework path with confidence and provenance per hop.",
+            inputSchema=_schema({
+                "from": {"type": "string"},
+                "to": {"type": "string"},
+                "maxDepth": {"type": "integer", "minimum": 1, "maximum": 64, "default": 32},
+            }, ["from", "to"]),
+        ),
+        Tool(
+            name="devcouncil_code_impact",
+            description="Inbound symbol blast radius for one or more paths/symbols.",
+            inputSchema=_schema({
+                "targets": {"type": "array", "items": {"type": "string"}},
+                "maxDepth": {"type": "integer", "minimum": 1, "maximum": 8, "default": 3},
+            }, ["targets"]),
+        ),
+        Tool(
+            name="devcouncil_code_dead",
+            description="Confidence-tiered dead-code candidates; never deletes code.",
+            inputSchema=_schema({
+                "minimumConfidence": {
+                    "type": "string",
+                    "enum": ["extracted", "inferred", "ambiguous"],
+                    "default": "inferred",
+                },
+            }),
+        ),
+        Tool(
+            name="devcouncil_code_affected_tests",
+            description="Tests reachable through the inbound blast radius of paths/symbols.",
+            inputSchema=_schema({
+                "targets": {"type": "array", "items": {"type": "string"}},
+                "maxDepth": {"type": "integer", "minimum": 1, "maximum": 8, "default": 3},
+            }, ["targets"]),
+        ),
+        Tool(
+            name="devcouncil_code_sync",
+            description="Reconcile and commit pending source changes to the canonical index.",
+            inputSchema=_schema({
+                "paths": {"type": "array", "items": {"type": "string"}},
+            }),
+        ),
+        Tool(
+            name="devcouncil_code_status",
+            description="Canonical generation, native watcher backend, pending files, and degraded state.",
+            inputSchema=_schema({}),
+        ),
+    ]
+
+
+def resolve_root(default_root: Path, arguments: dict) -> Path:
+    explicit = arguments.get("projectPath")
+    return canonical_project_root(Path(explicit) if isinstance(explicit, str) and explicit else default_root)
+
+
+async def _explore(root: Path, arguments: dict) -> list[TextContent]:
+    return json_text(CodeIntelQueryEngine(root).explore(str(arguments["query"]), limit=int(arguments.get("limit", 20))))
+
+
+async def _search(root: Path, arguments: dict) -> list[TextContent]:
+    return json_text(CodeIntelQueryEngine(root).search(str(arguments["query"]), limit=int(arguments.get("limit", 50))))
+
+
+async def _path(root: Path, arguments: dict) -> list[TextContent]:
+    return json_text(CodeIntelQueryEngine(root).path(
+        str(arguments["from"]), str(arguments["to"]), max_depth=int(arguments.get("maxDepth", 32))
+    ))
+
+
+async def _impact(root: Path, arguments: dict) -> list[TextContent]:
+    return json_text(CodeIntelQueryEngine(root).impact(
+        [str(value) for value in arguments.get("targets") or []],
+        max_depth=int(arguments.get("maxDepth", 3)),
+    ))
+
+
+async def _dead(root: Path, arguments: dict) -> list[TextContent]:
+    return json_text(CodeIntelQueryEngine(root).dead(
+        minimum_confidence=str(arguments.get("minimumConfidence", "inferred"))
+    ))
+
+
+async def _affected(root: Path, arguments: dict) -> list[TextContent]:
+    return json_text(CodeIntelQueryEngine(root).affected_tests(
+        [str(value) for value in arguments.get("targets") or []],
+        max_depth=int(arguments.get("maxDepth", 3)),
+    ))
+
+
+async def _sync(root: Path, arguments: dict) -> list[TextContent]:
+    coordinator = get_sync_coordinator(root)
+    supplied = [str(value) for value in arguments.get("paths") or []]
+    changed = supplied or await asyncio.to_thread(coordinator.reconcile)
+    ok = await asyncio.to_thread(coordinator.sync_now, changed)
+    payload = {"ok": ok, "reconciled": changed, **coordinator.status().as_dict()}
+    return json_text(payload) if ok else error_text(
+        coordinator.status().last_error or coordinator.status().degraded_reason or "sync failed",
+        code="codeintel_sync_failed",
+        **payload,
+    )
+
+
+async def _status(root: Path, _arguments: dict) -> list[TextContent]:
+    service = get_codeintel_service(root)
+    return json_text({**service.status(), "sync": get_sync_coordinator(root).status().as_dict()})
+
+
+REGISTRY: dict[str, Handler] = {
+    "devcouncil_code_explore": _explore,
+    "devcouncil_code_search": _search,
+    "devcouncil_code_path": _path,
+    "devcouncil_code_impact": _impact,
+    "devcouncil_code_dead": _dead,
+    "devcouncil_code_affected_tests": _affected,
+    "devcouncil_code_sync": _sync,
+    "devcouncil_code_status": _status,
+}
+
+
+async def dispatch(name: str, default_root: Path, arguments: dict) -> list[TextContent] | None:
+    handler = REGISTRY.get(name)
+    if handler is None:
+        return None
+    root = resolve_root(default_root, arguments)
+    try:
+        if name in {"devcouncil_code_sync", "devcouncil_code_status"}:
+            return await handler(root, arguments)
+        return await with_codeintel_freshness(root, lambda: handler(root, arguments))
+    except FileNotFoundError as exc:
+        return error_text(str(exc), code="codeintel_not_initialized", project_root=str(root))
+    except (KeyError, TypeError, ValueError) as exc:
+        return error_text(str(exc), code="invalid_arguments", tool=name)