fix: resolve 3 runtime bugs blocking swe-fast pipeline execution

- Add missing `command` to swe-fast docker-compose service (was running
  swe-planner entrypoint instead of swe_af.fast)
- Replace **kwargs thin wrappers with explicit signatures to fix 422
  schema validation errors from the control plane
- Register planner/verifier modules in __init__.py so fast_plan_tasks
  and fast_verify reasoners are available at startup
- Include execution router in swe-fast app so router.note() calls in
  delegated execution_agents functions don't raise RuntimeError
- Fix fast_verify to adapt task_results into completed/failed/skipped
  split matching run_verifier's interface, use correct model param name,
  and qualify the target with NODE_ID

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: AbirAbbas

docker-compose.yml

@@ -39,6 +39,7 @@ services:
     build:
       context: .
       dockerfile: Dockerfile
+    command: ["python", "-m", "swe_af.fast"]
     environment:
       - AGENTFIELD_SERVER=http://control-plane:8080
       - NODE_ID=swe-fast

swe_af/fast/__init__.py

@@ -28,41 +28,114 @@
 
 
 @fast_router.reasoner()
-async def run_git_init(**kwargs) -> dict:  # type: ignore[override]
+async def run_git_init(
+    repo_path: str,
+    goal: str,
+    artifacts_dir: str = "",
+    model: str = "sonnet",
+    permission_mode: str = "",
+    ai_provider: str = "claude",
+    previous_error: str | None = None,
+    build_id: str = "",
+) -> dict:
     """Thin wrapper around execution_agents.run_git_init."""
     import swe_af.reasoners.execution_agents as _ea  # noqa: PLC0415
-    return await _ea.run_git_init(**kwargs)
+    return await _ea.run_git_init(
+        repo_path=repo_path, goal=goal, artifacts_dir=artifacts_dir,
+        model=model, permission_mode=permission_mode, ai_provider=ai_provider,
+        previous_error=previous_error, build_id=build_id,
+    )
 
 
 @fast_router.reasoner()
-async def run_coder(**kwargs) -> dict:  # type: ignore[override]
+async def run_coder(
+    issue: dict,
+    worktree_path: str,
+    feedback: str = "",
+    iteration: int = 1,
+    iteration_id: str = "",
+    project_context: dict | None = None,
+    memory_context: dict | None = None,
+    model: str = "sonnet",
+    permission_mode: str = "",
+    ai_provider: str = "claude",
+) -> dict:
     """Thin wrapper around execution_agents.run_coder."""
     import swe_af.reasoners.execution_agents as _ea  # noqa: PLC0415
-    return await _ea.run_coder(**kwargs)
+    return await _ea.run_coder(
+        issue=issue, worktree_path=worktree_path, feedback=feedback,
+        iteration=iteration, iteration_id=iteration_id,
+        project_context=project_context, memory_context=memory_context,
+        model=model, permission_mode=permission_mode, ai_provider=ai_provider,
+    )
 
 
 @fast_router.reasoner()
-async def run_verifier(**kwargs) -> dict:  # type: ignore[override]
+async def run_verifier(
+    prd: dict,
+    repo_path: str,
+    artifacts_dir: str,
+    completed_issues: list[dict] | None = None,
+    failed_issues: list[dict] | None = None,
+    skipped_issues: list[str] | None = None,
+    model: str = "sonnet",
+    permission_mode: str = "",
+    ai_provider: str = "claude",
+) -> dict:
     """Thin wrapper around execution_agents.run_verifier."""
     import swe_af.reasoners.execution_agents as _ea  # noqa: PLC0415
-    return await _ea.run_verifier(**kwargs)
+    return await _ea.run_verifier(
+        prd=prd, repo_path=repo_path, artifacts_dir=artifacts_dir,
+        completed_issues=completed_issues or [], failed_issues=failed_issues or [],
+        skipped_issues=skipped_issues or [],
+        model=model, permission_mode=permission_mode, ai_provider=ai_provider,
+    )
 
 
 @fast_router.reasoner()
-async def run_repo_finalize(**kwargs) -> dict:  # type: ignore[override]
+async def run_repo_finalize(
+    repo_path: str,
+    artifacts_dir: str = "",
+    model: str = "sonnet",
+    permission_mode: str = "",
+    ai_provider: str = "claude",
+) -> dict:
     """Thin wrapper around execution_agents.run_repo_finalize."""
     import swe_af.reasoners.execution_agents as _ea  # noqa: PLC0415
-    return await _ea.run_repo_finalize(**kwargs)
+    return await _ea.run_repo_finalize(
+        repo_path=repo_path, artifacts_dir=artifacts_dir,
+        model=model, permission_mode=permission_mode, ai_provider=ai_provider,
+    )
 
 
 @fast_router.reasoner()
-async def run_github_pr(**kwargs) -> dict:  # type: ignore[override]
+async def run_github_pr(
+    repo_path: str,
+    integration_branch: str,
+    base_branch: str,
+    goal: str,
+    build_summary: str = "",
+    completed_issues: list[dict] | None = None,
+    accumulated_debt: list[dict] | None = None,
+    artifacts_dir: str = "",
+    model: str = "sonnet",
+    permission_mode: str = "",
+    ai_provider: str = "claude",
+) -> dict:
     """Thin wrapper around execution_agents.run_github_pr."""
     import swe_af.reasoners.execution_agents as _ea  # noqa: PLC0415
-    return await _ea.run_github_pr(**kwargs)
+    return await _ea.run_github_pr(
+        repo_path=repo_path, integration_branch=integration_branch,
+        base_branch=base_branch, goal=goal, build_summary=build_summary,
+        completed_issues=completed_issues, accumulated_debt=accumulated_debt,
+        artifacts_dir=artifacts_dir, model=model,
+        permission_mode=permission_mode, ai_provider=ai_provider,
+    )
 
 
 from . import executor  # noqa: E402, F401 — registers fast_execute_tasks
+from . import planner  # noqa: E402, F401 — registers fast_plan_tasks
+from . import verifier  # noqa: E402, F401 — registers fast_verify
 
 __all__ = [
     "fast_router",
@@ -72,4 +145,6 @@ async def run_github_pr(**kwargs) -> dict:  # type: ignore[override]
     "run_repo_finalize",
     "run_github_pr",
     "executor",
+    "planner",
+    "verifier",
 ]

swe_af/fast/app.py

@@ -29,6 +29,12 @@
 
 app.include_router(fast_router)
 
+# Include the planner's execution router so that router.note() calls inside
+# the original execution_agents functions (run_coder, run_verifier, etc.)
+# work when delegated to via the thin wrappers.
+from swe_af.reasoners import router as _execution_router  # noqa: E402
+app.include_router(_execution_router)
+
 
 def _repo_name_from_url(url: str) -> str:
     """Extract repo name from a GitHub URL."""

swe_af/fast/verifier.py

@@ -17,51 +17,48 @@
 
 @fast_router.reasoner()
 async def fast_verify(
-    *,
-    prd: str,
+    prd: dict[str, Any],
     repo_path: str,
     task_results: list[dict[str, Any]],
-    verifier_model: str,
-    permission_mode: str,
-    ai_provider: str,
-    artifacts_dir: str,
-    **kwargs: Any,
+    verifier_model: str = "sonnet",
+    permission_mode: str = "",
+    ai_provider: str = "claude",
+    artifacts_dir: str = "",
 ) -> dict[str, Any]:
     """Run a single verification pass against the built repository.
 
-    Calls ``run_verifier`` via a lazy import of ``swe_af.fast.app`` to
-    avoid circular imports at module load time.  No fix cycles are
-    attempted — this is a single-pass reasoner.
-
-    Args:
-        prd: The product requirements document text.
-        repo_path: Absolute path to the repository to verify.
-        task_results: List of task result dicts from the execution phase.
-        verifier_model: Model name string for the verifier agent.
-        permission_mode: Permission mode string passed to the agent runtime.
-        ai_provider: AI provider identifier string.
-        artifacts_dir: Path to the artifacts directory.
-        **kwargs: Additional keyword arguments forwarded to the agent call.
-
-    Returns:
-        A :class:`~swe_af.fast.schemas.FastVerificationResult` serialised
-        as a plain dict.
+    Adapts fast task_results into the completed/failed/skipped split that
+    ``run_verifier`` expects, then delegates to a single verification pass.
+    No fix cycles are attempted.
     """
     try:
         import swe_af.fast.app as _app  # noqa: PLC0415
 
+        # Split task_results into completed/failed for run_verifier's interface
+        completed_issues: list[dict] = []
+        failed_issues: list[dict] = []
+        for tr in task_results:
+            entry = {
+                "issue_name": tr.get("task_name", ""),
+                "result_summary": tr.get("summary", ""),
+            }
+            if tr.get("outcome") == "completed":
+                completed_issues.append(entry)
+            else:
+                failed_issues.append(entry)
+
         result: dict[str, Any] = await _app.app.call(
-            "run_verifier",
+            f"{_app.NODE_ID}.run_verifier",
             prd=prd,
             repo_path=repo_path,
-            task_results=task_results,
-            verifier_model=verifier_model,
+            artifacts_dir=artifacts_dir,
+            completed_issues=completed_issues,
+            failed_issues=failed_issues,
+            skipped_issues=[],
+            model=verifier_model,
             permission_mode=permission_mode,
             ai_provider=ai_provider,
-            artifacts_dir=artifacts_dir,
-            **kwargs,
         )
-        # Ensure the result conforms to FastVerificationResult
         verification = FastVerificationResult(
             passed=result.get("passed", False),
             summary=result.get("summary", ""),