mirror of
https://github.com/rennf93/roboco.git
synced 2026-08-03 07:23:24 +02:00
d1cf6ecbf3
* feat(tests): e2e scenario 2 — the PM merge chain through the PR gate
Shared arcs extracted (arcs.py: canonical-company seeding + dev/qa/doc
segments); scenario 2 seeds a root->cell->dev hierarchy mid-flight, rides
the child through the scenario-1 arc into the cell branch (real squash
via the fake GitHub), then submit_up -> claim_gate_review/pr_pass ->
dispatcher re-claim (mirrored) -> PM complete merging cell->root. This is
the exact PM->reviewer->PM turn sequence the wave-1 turn cut shortens —
the BEFORE-net. Learned seams scripted: commit-subject validator (>=20
chars), reviewer learning-note gate, pr_pass clears ownership by design.
* feat(runtime): PR-gate turn cut — assembled parents auto-submit to the reviewer
When every child of an assembled parent is terminal, the closure
dispatcher now runs the real submit_up/submit_root through the internal
API as the owning PM (_try_auto_submit) instead of spawning the PM for
that turn — the submit's substance is deterministic gate code. Any gate
refusal falls back to the classic PM closure spawn; pr_fail routing and
the PM's final merge turn are unchanged; umbrellas never auto-submit.
ROBOCO_PR_GATE_AUTO_SUBMIT_ENABLED default-on; task.auto_submitted audit
row per cut. Proven by e2e scenario 2b (real API, real gates, real git)
against scenario 2 as the before-net.
* feat(notes): structured note sections carry a written_at trace stamp
Sections are overwrite-in-place, so without a stamp there was no way to
reconstruct WHEN a dev/qa/doc/reviewer note landed (CEO reMarkable item:
trace TIMESTAMPS). apply_structured_note stamps ISO written_at beside
the model fields; the panel notes tab renders it next to each card
title (pre-stamp rows render nothing). Progress updates, commits, and
journal entries already carried timestamps — this was the one gap.
* feat(tasks): server-side task search — title, details, and id prefix
The task list's search box only matched titles client-side, and the
trimmed summary payload deliberately carries no description — so
keyword/details/id search was impossible in the browser by design.
GET /tasks/summary gains q (ILIKE over title+description, id-prefix
match, composed with team/status and the view-permission scoping);
the panel debounces the box into the summary fetch and drops the
title-only client filter that would have hidden description matches.
* feat(wave-1): trace timestamps, real task search, Secretary task edits
- apply_structured_note stamps written_at per section; the panel notes
tab shows it (the one trace surface without a timestamp).
- GET /tasks/summary?q= searches title+description+id-prefix server-side
(summaries carry no description by design); panel debounces into the
fetch and drops the title-only client filter.
- Secretary control_task gains a CEO-gated edit action over the content
allowlist, and GET /secretary/tasks?q= resolves task names to ids for
the chat. PM-side expansion deferred per the CEO's 'not that much'.
* fix(workspace): dep-update probe scrubs the inherited venv pin
Under uv run the orchestrator's process tree carries VIRTUAL_ENV, and a
uv-based dep_update_command in the throwaway probe clone would target
that venv instead of the clone's — the same hazard _uv_subprocess_env
already guards on the install path.
* build: private per-repo uv cache — isolate from machine-wide uvx servers
Root cause of the recurring rich/pip/bandit rot, with evidence: uv cache
clean timed out on the ~/.cache/uv lock ('is another uv process
running?') — three uvx mcp-server-fetch processes (Claude Code fetch MCP,
one alive since Wednesday) share that cache and race repo syncs on it;
poisoned entries then survive venv rebuilds because rm -rf .venv never
touches the cache, and every re-link reproduces the breakage. UV_CACHE_DIR
now pins <repo>/.uv-cache (gitignored). The earlier UV_NO_SYNC
serialization stays as defense-in-depth but was not the whole story.
* feat(tests): e2e scenario 3 — pr_fail revision loop + root→CEO chain
3a: reviewer pr_fail with a concrete issue -> needs_revision ->
i_will_plan re-entry (full plan gates) -> real fix lands on the cell
branch (the unchanged-PR hard gate refuses resubmit until it does) ->
clean second pass -> merge. 3b: submit_root -> gate -> Main PM complete
escalates the root to the CEO -> the REAL approve-and-merge endpoint
squash-merges to the origin's master. Harness gains the tasks router, a
seeded CEO identity, origin_commit, and a fake GitHub whose head.sha is
recomputed live (real-GitHub semantics the unchanged gate reads). Seeds
now encode the real shape: delivery roots are team=main_pm and
planning-typed.
---------
Co-authored-by: Renn F <rennf93@users.noreply.github.com>
58 lines
1.9 KiB
Python
58 lines
1.9 KiB
Python
"""Scenario 1: a leaf dev task walks claim → work → PR → QA → docs → PM queue.
|
|
|
|
Every hop goes through the REAL MCP tool functions → real HTTP → real
|
|
gateway gates → real services → real git against the local origin, with a
|
|
fake GitHub REST layer whose merges are real git merges. No LLM: the arcs
|
|
in ``tests/e2e_smoke/arcs.py`` ARE the agent script, and every rejection
|
|
envelope prints verbatim so a seam regression names itself.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import TYPE_CHECKING
|
|
|
|
from tests.e2e_smoke.arcs import (
|
|
dev_arc,
|
|
doc_arc,
|
|
qa_arc,
|
|
seed_company,
|
|
seed_project,
|
|
seed_task,
|
|
task_state,
|
|
)
|
|
|
|
if TYPE_CHECKING:
|
|
from tests.e2e_smoke.harness import E2EStack
|
|
|
|
|
|
def test_leaf_dev_task_reaches_pm_review(e2e_stack: E2EStack) -> None:
|
|
stack = e2e_stack
|
|
company = seed_company(stack)
|
|
project_id, project_slug = seed_project(stack, company)
|
|
task_id = seed_task(
|
|
stack,
|
|
title="Add the greeting module",
|
|
description=(
|
|
"Create greeting.txt with a friendly greeting so the smoke "
|
|
"harness has a real file change to commit, push, and merge."
|
|
),
|
|
acceptance_criteria=[
|
|
"greeting.txt exists at the repo root",
|
|
"its content greets the reader",
|
|
],
|
|
project_id=project_id,
|
|
created_by=company.cell_pm_id,
|
|
# Pool→agent routing is the orchestrator dispatcher's job (not under
|
|
# test); a dev container is always spawned with its task already
|
|
# routed, which give_me_work serves via the pre-assigned lane.
|
|
assigned_to=company.dev_id,
|
|
)
|
|
|
|
dev_arc(stack, company, project_slug, task_id)
|
|
qa_arc(stack, company, task_id)
|
|
doc_arc(stack, company, task_id, filename="greeting.txt")
|
|
|
|
final = task_state(stack, task_id)
|
|
assert final["status"] == "awaiting_pm_review", final
|
|
assert final["docs_complete"] is True, final
|