mirror of
https://github.com/rennf93/roboco.git
synced 2026-08-03 07:23:24 +02:00
Feat: board redraft loop (#139)
* feat(board): expose board review brief + guard approve-and-start
Slice 1 of the board-informed intake re-draft loop (backend foundation):
- JournalService.board_review_brief(task_id): the PO + Head of Marketing
DECISION_LOG entries for a task, oldest-first, each tagged with author —
the board's review as structured data.
- GET /api/tasks/{task_id}/board-review (PM-or-above) backing the CEO's
approval/redraft surface, so the real board analysis is readable instead
of a placeholder; BoardReviewEntry response schema.
- Guard: approve_and_start now refuses a board task whose review is not
complete (service invariant + precise BOARD_REVIEW_INCOMPLETE at the route).
Previously only the UI hid the button; the backend let an early/rogue call
hand the task to Main PM mid-review.
Tests: brief filtering/ordering + endpoint (200/404) + the two guard paths.
* feat(panel): show real board review at the approve gate + live refresh
Slice 1 frontend of the board-informed intake re-draft loop:
- tasksApi.getBoardReview + useBoardReview hook consume GET
/tasks/{id}/board-review.
- The Approve & Start dialog now renders the actual Product Owner + Head of
Marketing notes (markdown) instead of a static placeholder, so the CEO reads
the board's analysis before approving.
- C2: useTask polls (4s) while a task is still on the board with an
incomplete review, so the Approve & Start button appears as soon as the
board finishes — there is no per-task websocket. Polling stops once
board_review_complete flips.
* feat(intake): board-informed re-draft loop (backend, cold path)
Slice 2 of the re-draft loop:
- update_live_draft: apply a board-informed re-draft to the EXISTING task in
place (title/description/acceptance_criteria) — never a duplicate — then route
it: 'main_pm' hands it to the Main PM via approve_and_start; 'board' clears
board_review_complete for another review round.
- confirm route branches on task_id → update_live_draft vs confirm_live_draft;
LiveConfirmRequest.task_id added (scope taken from the task, not required).
- POST /live/re-interview/{task_id} (PM-or-above): spawns a fresh intake session
seeded with the current draft + the board brief (compose_redraft_message),
scoped to the task's product/project. The cold path + Slice-3 fallback.
- format_board_briefing / compose_redraft_message helpers.
Tests: pure helpers + update_live_draft (main_pm hand-off, re-board reset,
missing-task).
* feat(panel): board-informed re-draft entry + prompter re-draft guidance
Slice 2 panel of the re-draft loop:
- 'Re-draft with board feedback' button on a board-reviewed task detail →
/prompter?redraft=<taskId>.
- usePrompter.startRedraft(taskId): calls POST /prompter/live/re-interview/{id},
scopes the chat to the task, and streams the re-draft; redraftTaskId is
threaded (persisted across reload) so confirm carries task_id and updates the
existing task in place rather than creating a duplicate.
- prompterLiveApi.reInterview; ConfirmPayload.task_id.
- Prompter role prompt: a 'Re-drafting after board review' section so the agent
revises the included draft from the board brief instead of starting over.
Panel verified by CI (no local node_modules).
* feat(intake): keep-alive re-draft — park the intake agent during board review
Slice 3 of the re-draft loop (in-context fidelity; cold path is the fallback):
- Registry: LiveIntakeSession.task_id + park(session_id, task_id) (keep alive
instead of reaping) + find_by_task() for board-completion injection.
- Confirm: the board route (first pass) PARKS the intake agent instead of
reaping, so it keeps the whole interview in context.
- Orchestrator: on board-review completion, inject the synthesized board brief
into the parked session (_inject_board_brief_into_parked_intake) so the
resident prompter re-drafts in-context. No-op when nothing is parked (the
container died / a new intake replaced it) — the cold /re-interview path
covers that. No reaper change needed (an idle parked session spends no tokens
and the budget sweep is the only agent-stopping sweep).
- Panel: confirm(board) keeps the chat alive (parked, redraftTaskId set) with a
notice; the injected revised draft arrives over the existing stream to approve.
Tests: registry park/find_by_task/closed-ignored. Container delivery + the full
panel parked flow need live (container-runtime) verification.
---------
Co-authored-by: Renn F <rennf93@users.noreply.github.com>
This commit is contained in:
Renzo F
@@ -52,6 +52,8 @@ async def start_setup(db_session: AsyncSession) -> AsyncIterator[dict]:
|
||||
def _task(
|
||||
status: TaskStatus = TaskStatus.PENDING,
|
||||
assigned_to: UUID | None = None,
|
||||
team: Team = Team.MAIN_PM,
|
||||
board_review_complete: bool = False,
|
||||
) -> TaskTable:
|
||||
t = TaskTable(
|
||||
id=uuid4(),
|
||||
@@ -64,7 +66,8 @@ async def start_setup(db_session: AsyncSession) -> AsyncIterator[dict]:
|
||||
nature=TaskNature.TECHNICAL,
|
||||
project_id=project.id,
|
||||
created_by=po.id,
|
||||
team=Team.MAIN_PM,
|
||||
team=team,
|
||||
board_review_complete=board_review_complete,
|
||||
assigned_to=assigned_to if assigned_to else po.id,
|
||||
)
|
||||
db_session.add(t)
|
||||
@@ -122,3 +125,23 @@ async def test_returns_none_when_not_pending(start_setup: dict) -> None:
|
||||
await start_setup["db"].flush()
|
||||
out = await start_setup["svc"].approve_and_start(task.id, "x" * 25)
|
||||
assert out is None
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_returns_none_when_board_review_incomplete(start_setup: dict) -> None:
|
||||
# A task still on the board with an unfinished review must not be started.
|
||||
task = start_setup["mk"](team=Team.BOARD, board_review_complete=False)
|
||||
await start_setup["db"].flush()
|
||||
out = await start_setup["svc"].approve_and_start(task.id, "x" * 25)
|
||||
assert out is None
|
||||
assert task.assigned_to == start_setup["po"].id # not handed to Main PM
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_succeeds_when_board_review_complete(start_setup: dict) -> None:
|
||||
task = start_setup["mk"](team=Team.BOARD, board_review_complete=True)
|
||||
await start_setup["db"].flush()
|
||||
out = await start_setup["svc"].approve_and_start(task.id, "x" * 25)
|
||||
assert out is not None
|
||||
assert out.assigned_to == start_setup["main_pm"].id
|
||||
assert out.status == TaskStatus.PENDING
|
||||
|
||||
@@ -0,0 +1,229 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from datetime import UTC, datetime
|
||||
from http import HTTPStatus
|
||||
from typing import TYPE_CHECKING
|
||||
from uuid import uuid4
|
||||
|
||||
import pytest
|
||||
import pytest_asyncio
|
||||
from fastapi import FastAPI
|
||||
from httpx import ASGITransport, AsyncClient
|
||||
from roboco.api.deps import get_agent_context, get_db
|
||||
from roboco.api.routes.tasks import router as tasks_router
|
||||
from roboco.db.tables import (
|
||||
AgentTable,
|
||||
JournalEntryTable,
|
||||
JournalTable,
|
||||
ProjectTable,
|
||||
TaskTable,
|
||||
)
|
||||
from roboco.models import AgentRole, AgentStatus, Team
|
||||
from roboco.models.base import JournalEntryType, TaskNature, TaskStatus, TaskType
|
||||
from roboco.models.permissions import AgentContext
|
||||
from roboco.services.journal import JournalService
|
||||
|
||||
_HDR_PM = {"X-Agent-ID": str(uuid4()), "X-Agent-Role": "main_pm"}
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from collections.abc import AsyncIterator
|
||||
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
|
||||
def _agent(slug: str, role: AgentRole) -> AgentTable:
|
||||
return AgentTable(
|
||||
id=uuid4(),
|
||||
name=slug,
|
||||
slug=slug,
|
||||
role=role,
|
||||
team=None,
|
||||
status=AgentStatus.ACTIVE,
|
||||
model_config={},
|
||||
system_prompt="x",
|
||||
capabilities=[],
|
||||
permissions={},
|
||||
metrics={},
|
||||
)
|
||||
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
async def brief_setup(db_session: AsyncSession) -> AsyncIterator[dict]:
|
||||
po = _agent(f"product-owner-{uuid4().hex[:4]}", AgentRole.PRODUCT_OWNER)
|
||||
hom = _agent(f"head-marketing-{uuid4().hex[:4]}", AgentRole.HEAD_MARKETING)
|
||||
dev = _agent(f"be-dev-{uuid4().hex[:4]}", AgentRole.DEVELOPER)
|
||||
db_session.add_all([po, hom, dev])
|
||||
await db_session.flush()
|
||||
|
||||
project = ProjectTable(
|
||||
id=uuid4(),
|
||||
name="P",
|
||||
slug=f"p-{uuid4().hex[:6]}",
|
||||
git_url="https://example.com/r.git",
|
||||
assigned_cell=Team.BACKEND,
|
||||
created_by=po.id,
|
||||
)
|
||||
db_session.add(project)
|
||||
await db_session.flush()
|
||||
|
||||
def _task() -> TaskTable:
|
||||
t = TaskTable(
|
||||
id=uuid4(),
|
||||
title="Board task",
|
||||
description="d",
|
||||
acceptance_criteria=["ac"],
|
||||
status=TaskStatus.PENDING,
|
||||
priority=2,
|
||||
task_type=TaskType.CODE,
|
||||
nature=TaskNature.TECHNICAL,
|
||||
project_id=project.id,
|
||||
created_by=po.id,
|
||||
team=Team.BOARD,
|
||||
)
|
||||
db_session.add(t)
|
||||
return t
|
||||
|
||||
task = _task()
|
||||
other = _task()
|
||||
await db_session.flush()
|
||||
|
||||
journals = {a.id: JournalTable(id=uuid4(), agent_id=a.id) for a in (po, hom, dev)}
|
||||
db_session.add_all(journals.values())
|
||||
await db_session.flush()
|
||||
|
||||
def _entry(
|
||||
agent: AgentTable,
|
||||
*,
|
||||
entry_type: JournalEntryType,
|
||||
task_id,
|
||||
title: str,
|
||||
when: datetime,
|
||||
) -> None:
|
||||
db_session.add(
|
||||
JournalEntryTable(
|
||||
id=uuid4(),
|
||||
journal_id=journals[agent.id].id,
|
||||
type=entry_type,
|
||||
title=title,
|
||||
content=f"{title} — body",
|
||||
task_id=task_id,
|
||||
timestamp=when,
|
||||
tags=["decision"],
|
||||
)
|
||||
)
|
||||
|
||||
# HoM logs after PO so we can assert oldest-first ordering returns PO then HoM.
|
||||
_entry(
|
||||
po,
|
||||
entry_type=JournalEntryType.DECISION_LOG,
|
||||
task_id=task.id,
|
||||
title="PO review",
|
||||
when=datetime(2026, 1, 1, tzinfo=UTC),
|
||||
)
|
||||
_entry(
|
||||
hom,
|
||||
entry_type=JournalEntryType.DECISION_LOG,
|
||||
task_id=task.id,
|
||||
title="HoM review",
|
||||
when=datetime(2026, 1, 2, tzinfo=UTC),
|
||||
)
|
||||
# Noise that must be excluded:
|
||||
_entry( # non-board author, decision log
|
||||
dev,
|
||||
entry_type=JournalEntryType.DECISION_LOG,
|
||||
task_id=task.id,
|
||||
title="Dev decision",
|
||||
when=datetime(2026, 1, 3, tzinfo=UTC),
|
||||
)
|
||||
_entry( # board author, but not a decision log
|
||||
po,
|
||||
entry_type=JournalEntryType.TASK_REFLECTION,
|
||||
task_id=task.id,
|
||||
title="PO reflection",
|
||||
when=datetime(2026, 1, 4, tzinfo=UTC),
|
||||
)
|
||||
_entry( # board decision log, but on a different task
|
||||
po,
|
||||
entry_type=JournalEntryType.DECISION_LOG,
|
||||
task_id=other.id,
|
||||
title="PO review of other task",
|
||||
when=datetime(2026, 1, 5, tzinfo=UTC),
|
||||
)
|
||||
await db_session.flush()
|
||||
|
||||
yield {"svc": JournalService(db_session), "task": task, "other": other}
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_brief_returns_only_board_decision_logs_oldest_first(
|
||||
brief_setup: dict,
|
||||
) -> None:
|
||||
brief = await brief_setup["svc"].board_review_brief(brief_setup["task"].id)
|
||||
titles = [e["title"] for e in brief]
|
||||
assert titles == ["PO review", "HoM review"] # ordered, filtered
|
||||
assert brief[0]["author_role"] == "product_owner"
|
||||
assert brief[1]["author_role"] == "head_marketing"
|
||||
assert all("body" in e["content"] for e in brief)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_brief_empty_when_no_board_review(brief_setup: dict) -> None:
|
||||
# `other` only has a single PO decision log on it (created as noise above),
|
||||
# so build a genuinely un-reviewed task to assert the empty case.
|
||||
fresh = TaskTable(
|
||||
id=uuid4(),
|
||||
title="Unreviewed",
|
||||
description="d",
|
||||
acceptance_criteria=["ac"],
|
||||
status=TaskStatus.PENDING,
|
||||
priority=2,
|
||||
task_type=TaskType.CODE,
|
||||
nature=TaskNature.TECHNICAL,
|
||||
created_by=brief_setup["task"].created_by,
|
||||
team=Team.BOARD,
|
||||
)
|
||||
brief_setup["svc"].session.add(fresh)
|
||||
await brief_setup["svc"].session.flush()
|
||||
assert await brief_setup["svc"].board_review_brief(fresh.id) == []
|
||||
|
||||
|
||||
def _board_review_app(db_session: AsyncSession) -> FastAPI:
|
||||
app = FastAPI()
|
||||
app.include_router(tasks_router, prefix="/api/tasks")
|
||||
|
||||
async def _db():
|
||||
yield db_session
|
||||
|
||||
async def _agent() -> AgentContext:
|
||||
return AgentContext(agent_id=uuid4(), role=AgentRole.MAIN_PM, team=None)
|
||||
|
||||
app.dependency_overrides[get_db] = _db
|
||||
app.dependency_overrides[get_agent_context] = _agent
|
||||
return app
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_board_review_endpoint_returns_entries(
|
||||
brief_setup: dict, db_session: AsyncSession
|
||||
) -> None:
|
||||
app = _board_review_app(db_session)
|
||||
transport = ASGITransport(app=app)
|
||||
async with AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
resp = await client.get(
|
||||
f"/api/tasks/{brief_setup['task'].id}/board-review", headers=_HDR_PM
|
||||
)
|
||||
assert resp.status_code == HTTPStatus.OK
|
||||
body = resp.json()
|
||||
assert [e["title"] for e in body] == ["PO review", "HoM review"]
|
||||
assert body[0]["author_role"] == "product_owner"
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_board_review_endpoint_404_for_missing_task(
|
||||
db_session: AsyncSession,
|
||||
) -> None:
|
||||
app = _board_review_app(db_session)
|
||||
transport = ASGITransport(app=app)
|
||||
async with AsyncClient(transport=transport, base_url="http://test") as client:
|
||||
resp = await client.get(f"/api/tasks/{uuid4()}/board-review", headers=_HDR_PM)
|
||||
assert resp.status_code == HTTPStatus.NOT_FOUND
|
||||
@@ -0,0 +1,169 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from types import SimpleNamespace
|
||||
from typing import TYPE_CHECKING
|
||||
from uuid import uuid4
|
||||
|
||||
import pytest
|
||||
import pytest_asyncio
|
||||
from roboco.db.tables import AgentTable, ProjectTable, TaskTable
|
||||
from roboco.models import AgentRole, AgentStatus, Team
|
||||
from roboco.models.base import TaskNature, TaskStatus, TaskType
|
||||
from roboco.services.base import NotFoundError
|
||||
from roboco.services.prompter import (
|
||||
PrompterService,
|
||||
compose_redraft_message,
|
||||
format_board_briefing,
|
||||
)
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from collections.abc import AsyncIterator
|
||||
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
# Pure helpers (no DB)
|
||||
# --------------------------------------------------------------------------- #
|
||||
def test_format_board_briefing_labels_and_orders() -> None:
|
||||
entries = [
|
||||
{"author_role": "product_owner", "author": "po", "title": "PO", "content": "x"},
|
||||
{
|
||||
"author_role": "head_marketing",
|
||||
"author": "hom",
|
||||
"title": "HoM",
|
||||
"content": "y",
|
||||
},
|
||||
]
|
||||
out = format_board_briefing(entries)
|
||||
assert "Product Owner" in out
|
||||
assert "Head of Marketing" in out
|
||||
assert out.index("Product Owner") < out.index("Head of Marketing")
|
||||
assert "x" in out and "y" in out
|
||||
|
||||
|
||||
def test_format_board_briefing_empty() -> None:
|
||||
assert format_board_briefing([]) == ""
|
||||
|
||||
|
||||
def test_compose_redraft_message_includes_draft_and_brief() -> None:
|
||||
task = SimpleNamespace(
|
||||
title="My Task",
|
||||
description="The current description.",
|
||||
acceptance_criteria=["does X", "does Y"],
|
||||
)
|
||||
entries = [
|
||||
{"author_role": "product_owner", "author": "po", "title": "PO", "content": "z"}
|
||||
]
|
||||
msg = compose_redraft_message(task, entries)
|
||||
assert "My Task" in msg
|
||||
assert "The current description." in msg
|
||||
assert "- does X" in msg
|
||||
assert "Product Owner" in msg
|
||||
assert "z" in msg
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------- #
|
||||
# update_live_draft (DB)
|
||||
# --------------------------------------------------------------------------- #
|
||||
@pytest_asyncio.fixture
|
||||
async def redraft_setup(db_session: AsyncSession) -> AsyncIterator[dict]:
|
||||
def _agent(slug: str, role: AgentRole) -> AgentTable:
|
||||
return AgentTable(
|
||||
id=uuid4(),
|
||||
name=slug,
|
||||
slug=slug,
|
||||
role=role,
|
||||
team=None,
|
||||
status=AgentStatus.ACTIVE,
|
||||
model_config={},
|
||||
system_prompt="x",
|
||||
capabilities=[],
|
||||
permissions={},
|
||||
metrics={},
|
||||
)
|
||||
|
||||
main_pm = _agent("main-pm", AgentRole.MAIN_PM)
|
||||
po = _agent(f"product-owner-{uuid4().hex[:4]}", AgentRole.PRODUCT_OWNER)
|
||||
db_session.add_all([main_pm, po])
|
||||
await db_session.flush()
|
||||
project = ProjectTable(
|
||||
id=uuid4(),
|
||||
name="P",
|
||||
slug=f"p-{uuid4().hex[:6]}",
|
||||
git_url="https://example.com/r.git",
|
||||
assigned_cell=Team.BACKEND,
|
||||
created_by=po.id,
|
||||
)
|
||||
db_session.add(project)
|
||||
await db_session.flush()
|
||||
|
||||
def _board_task(board_review_complete: bool) -> TaskTable:
|
||||
t = TaskTable(
|
||||
id=uuid4(),
|
||||
title="Original title",
|
||||
description="Original description, long enough.",
|
||||
acceptance_criteria=["original ac"],
|
||||
status=TaskStatus.PENDING,
|
||||
priority=2,
|
||||
task_type=TaskType.CODE,
|
||||
nature=TaskNature.TECHNICAL,
|
||||
project_id=project.id,
|
||||
created_by=po.id,
|
||||
team=Team.BOARD,
|
||||
board_review_complete=board_review_complete,
|
||||
assigned_to=po.id,
|
||||
)
|
||||
db_session.add(t)
|
||||
return t
|
||||
|
||||
yield {
|
||||
"svc": PrompterService(db_session),
|
||||
"db": db_session,
|
||||
"main_pm": main_pm,
|
||||
"po": po,
|
||||
"mk": _board_task,
|
||||
}
|
||||
|
||||
|
||||
_DRAFT = {
|
||||
"title": "Revised title",
|
||||
"objective": "Revised objective after board feedback for the task at hand.",
|
||||
"acceptance_criteria": ["revised ac one", "revised ac two"],
|
||||
"description": "Revised description that is comfortably over twenty chars.",
|
||||
}
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_update_live_draft_main_pm_updates_and_hands_off(
|
||||
redraft_setup: dict,
|
||||
) -> None:
|
||||
task = redraft_setup["mk"](True) # board review complete
|
||||
await redraft_setup["db"].flush()
|
||||
out_id = await redraft_setup["svc"].update_live_draft(
|
||||
task.id, _DRAFT, route="main_pm"
|
||||
)
|
||||
assert out_id == task.id
|
||||
assert task.title == "Revised title"
|
||||
assert task.acceptance_criteria == ["revised ac one", "revised ac two"]
|
||||
assert "Revised" in task.description
|
||||
# Approve & Start ran → handed to Main PM.
|
||||
assert task.assigned_to == redraft_setup["main_pm"].id
|
||||
assert task.team == Team.MAIN_PM
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_update_live_draft_reboard_resets_flag(redraft_setup: dict) -> None:
|
||||
task = redraft_setup["mk"](True)
|
||||
await redraft_setup["db"].flush()
|
||||
await redraft_setup["svc"].update_live_draft(task.id, _DRAFT, route="board")
|
||||
assert task.title == "Revised title"
|
||||
assert task.board_review_complete is False # back for another review round
|
||||
assert task.assigned_to == redraft_setup["po"].id # still on the board
|
||||
assert task.team == Team.BOARD
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_update_live_draft_missing_task_raises(redraft_setup: dict) -> None:
|
||||
with pytest.raises(NotFoundError):
|
||||
await redraft_setup["svc"].update_live_draft(uuid4(), _DRAFT, route="main_pm")
|
||||
Reference in New Issue
Block a user