| |
| """One card, two modes. The QA cycle between dry-run and a live cockpit. |
| |
| python -m cli.qa_cycle dry # propose and park; the shell does not run |
| python -m cli.qa_cycle live # run the plan in .sandbox/, critic passes to done |
| |
| The provider is forced to mock so this never calls OMP, Hermes, or OpenClaw. |
| The card is deleted before exit, including on failure. Refuses to start when a |
| conductor or reaper is already running, so a QA card cannot race the live board. |
| """ |
| from __future__ import annotations |
|
|
| import asyncio |
| import json |
| import os |
| import subprocess |
| import sys |
|
|
| MODE = sys.argv[1] if len(sys.argv) > 1 else "" |
| if MODE not in ("dry", "live"): |
| print("usage: python -m cli.qa_cycle dry|live", file=sys.stderr) |
| raise SystemExit(2) |
|
|
| |
| |
| os.environ["KANBOT_DRY_RUN"] = "1" if MODE == "dry" else "0" |
| os.environ["KANBOT_PROVIDER"] = "mock" |
| os.environ["KANBOT_SWARM_N"] = "1" |
|
|
|
|
| def _foreign_workers() -> list[str]: |
| found = subprocess.run( |
| ["pgrep", "-fl", "core.conductor|core.reaper"], |
| capture_output=True, text=True, |
| ) |
| if found.returncode != 0: |
| return [] |
| return [line for line in found.stdout.splitlines() if "qa_cycle" not in line] |
|
|
|
|
| async def _cycle() -> dict: |
| from core import db |
| from core.mcp_server import create_card, move_card |
| from core.workers import DRY_RUN, claim_and_execute, run_critic |
|
|
| if MODE == "dry" and not DRY_RUN: |
| raise RuntimeError("dry cycle imported workers with DRY_RUN off") |
| if MODE == "live" and DRY_RUN: |
| raise RuntimeError("live cycle imported workers with DRY_RUN on") |
|
|
| created = json.loads(await create_card( |
| title="QA e2e sandbox ping", |
| spec="Print a marker through the sandbox and post it as the artifact.", |
| role="executor", |
| acceptance_criteria=["the sandbox ran"], |
| tags=["qa"], |
| )) |
| cid = created["id"] |
| try: |
| promoted = json.loads(await move_card( |
| cid, "ready", actor="qa", reason="qa promote")) |
| if promoted.get("rejected") or promoted.get("error"): |
| raise RuntimeError(f"promote failed: {promoted}") |
| card = await db.get_card(cid) |
| await claim_and_execute(card) |
| card = await db.get_card(cid) |
| kinds = [entry.kind for entry in card.thread] |
| if MODE == "dry": |
| if card.column.value != "blocked": |
| raise RuntimeError(f"dry-run left the card in {card.column.value}") |
| if "tool_call" not in kinds or "tool_result" in kinds: |
| raise RuntimeError(f"dry-run thread kinds: {kinds}") |
| else: |
| if card.column.value != "review": |
| raise RuntimeError(f"live execution left the card in {card.column.value}") |
| if "tool_result" not in kinds or "artifact" not in kinds: |
| raise RuntimeError(f"live thread kinds: {kinds}") |
| blob = "\n".join(entry.content for entry in card.thread) |
| if "mock" not in blob: |
| raise RuntimeError("sandbox stdout did not land on the thread") |
| await run_critic(card) |
| card = await db.get_card(cid) |
| if card.column.value != "done": |
| raise RuntimeError(f"critic left the card in {card.column.value}") |
| return {"ok": True, "mode": MODE, "id": cid, "column": card.column.value} |
| finally: |
| pool = await db.pool() |
| async with pool.acquire() as conn: |
| await conn.execute("DELETE FROM cards WHERE id=$1", cid) |
| await pool.close() |
|
|
|
|
| def main() -> int: |
| busy = _foreign_workers() |
| if busy: |
| print(json.dumps({"ok": False, "error": "conductor or reaper is running", |
| "procs": busy})) |
| return 3 |
| try: |
| report = asyncio.run(_cycle()) |
| except Exception as exc: |
| print(json.dumps({"ok": False, "mode": MODE, "error": f"{type(exc).__name__}: {exc}"})) |
| return 1 |
| print(json.dumps(report)) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
