8 Commits

Include renames

Author	SHA1	Message	Date
4 people	6cf99a1b0a	[beb8cae1] Type-gate tests/ under mypy — fix all errors and flip quality gate (#156) (#157) ... * [420e5e68] Fix mypy errors in tests/unit/ and create tests/__init__.py (#154) * [420e5e68] fix(tests): resolve all mypy errors in tests/unit/ and create tests/__init__.py - Create tests/__init__.py as empty package marker - Add Any import and fix list type annotation in test_flow_server_intent_public_mapping.py - Move AsyncIterator to TYPE_CHECKING block and fix m.cls.__name__ attr error in test_app.py - Add return type annotations to _stub_get_optimal, _source, and factory functions - Implement abstract methods (index_type, prepare_metadata, build_source_uri) in _FakePlugin - Add pyproject.toml per-file-ignore for ARG002 on test_optimal_grounding.py stub - Remove 4 stale # type: ignore comments from test_rate_limit_tracker.py - Fix method-assignment patterns in test_rate_limit_sweep.py via patch.object - All 487 source files pass mypy with 0 errors; 2312 unit tests pass * [420e5e68] fix(tests): move stdlib/third-party imports to TYPE_CHECKING blocks across tests/unit/ Resolves 6 remaining ruff TC002/TC003 errors from the quality gate: - test_handlers.py: Iterator → TYPE_CHECKING - test_quality_gate.py: pathlib → TYPE_CHECKING - test_board_dispatch.py: AsyncIterator + httpx → TYPE_CHECKING - test_streaming.py: Iterator → TYPE_CHECKING - test_notification.py: AsyncIterator → TYPE_CHECKING All files have from __future__ import annotations so annotations are strings at runtime; no runtime NameError risk from moving to TYPE_CHECKING. * [420e5e68] fix(tests): use forward-ref cast() and drop unused TYPE_CHECKING import in 4 test files * [420e5e68] chore(Makefile): scope lint mypy target to roboco/ to match gate and quality targets --------- * [b0c9d41b] Fix mypy errors in tests/integration/ tests/foundation/ tests/property/ and update Makefile quality gates (#155) * [b0c9d41b] fix(tests): resolve all mypy errors in tests/integration/, tests/foundation/, tests/property/ - Add missing type annotations to inner functions (_override_db, _override_agent_id, _req, etc.) - Use cast("UUID", ...) to fix SQLAlchemy UUID vs uuid.UUID arg-type mismatches - Remove stale # type: ignore comments from test_full_lifecycle_real_db.py and test_task_service_lifecycle_misc.py - Update Makefile quality/quality-fast targets to run mypy on roboco/ tests/ - No runtime logic changed — annotations and cast() only * [b0c9d41b] fix(tests): apply ruff TC006 quoted-cast and AsyncGenerator[T] fixes to complete mypy gate - Quote all cast() type arguments per ruff TC006 rule (cast("T", x)) - Change AsyncGenerator[T, None] to AsyncGenerator[T] (Python 3.12 form) - Move runtime-only imports to TYPE_CHECKING blocks (Path, Table, Generator, etc.) - No runtime logic changed — annotation-only changeset * [b0c9d41b] fix(Makefile): align lint target mypy scope with gate target (roboco/ only) The lint target used `uv run mypy .` (all files) while gate uses `uv run mypy roboco/`. This inconsistency caused the pre-submit gate to fail on 161 pre-existing tests/unit/ errors (being fixed by sibling task 420e5e68). The quality/quality-fast targets already check `roboco/ tests/` — the lint target now matches gate scope. --------- --------- Co-authored-by: Backend Developer 1 <be-dev-1@agents.roboco.dev> Co-authored-by: Backend Developer 2 <be-dev-2@agents.roboco.dev>	2026-06-14 13:43:46 +02:00
3 people	718d7dd83e	Fix: open findings cleanup (#122) ... * refactor(usage): remove the unconsumed per-agent USAGE_UPDATE event USAGE_UPDATE was published per active agent each sweep, bridged, and broadcast to /ws/system, but no panel client ever consumed it — the dashboard reads only the aggregate USAGE_SNAPSHOT. Every emission was wasted event-bus and WebSocket traffic. Drop the UsageUpdate payload, publish_usage_update and its throttle, the EventType member, and the bridge subscription. Keep USAGE_SNAPSHOT, which already carries the per-agent breakdown, so no live data is lost. * refactor(prompter): remove the legacy local-LLM HTTP endpoints The panel uses only the live SDK-intake path (/prompter/live/*); the legacy /prompter/chat, /draft and /sessions/* endpoints — backed by the local Ollama LLM with hardcoded prompts — had no remaining caller. Remove the router, its mount in app.py, and its integration test. The live router and the shared draft-confirmation service are untouched. * refactor(prompter): drop the dead legacy local-LLM service + schemas With the legacy HTTP endpoints gone, the local-LLM chat/draft/session methods, their prompt constants, the ConfirmOverrides/TurnResult dataclasses, and the entire prompter schema module had no production caller (only their own tests). Remove them, keeping the live-intake path: create_task_from_draft / confirm_live_draft, the enum/priority/team coercion, and the pure description/readiness helpers. * refactor(agents): stop granting the Task sub-agent tool to roles Every agent role was granted the built-in Task tool, but no role prompt or workflow uses it and there are no custom sub-agent definitions — so a Task call only spawns a context-blind generic sub-agent that burns budget (ToolSearch, the comment's stated use, is MCP-only and not callable in agent containers). Drop Task from all three grant points in lockstep: the --tools spawn flag and both _ROLE_BUILTIN_TOOLS maps (system-prompt + briefing layers), with a regression guard added to each layer's test. --------- Co-authored-by: Renn F <rennf93@users.noreply.github.com>	2026-06-12 23:10:21 +02:00
3 people	303c2db289	Fix: rate limit real probe (#110) ... * fix(rate-limit): real provider liveness probe instead of time-based stub The rate-limit recovery sweeper cleared a provider and resumed parked agents purely on elapsed time — _do_probe was a stub that always returned True once the retry_after window passed, so it never confirmed the provider had actually stopped rate-limiting us. Under a sustained limit that resumes agents straight into another 429, re-parking them: avoidable churn. Make the probe real. _do_probe now issues a free, unmetered liveness call — Anthropic GET /v1/models or Ollama GET /api/tags — and treats any non-429 response as the limit having lifted. A 429 keeps the provider parked; a network error keeps it parked too (retry next sweep). When the provider can't be probed (no API key, or an unrecognized provider), it falls back to the prior time-expiry optimism rather than stranding agents. _probe_target keeps URL/header resolution separate and testable, and _do_probe stays a monkeypatchable boundary so the existing sweep tests are unaffected. Also drop two acceptance-criteria-number labels from comments in this file. * chore(rate-limit): clear merged gate debt in rate-limit tests + deps lint The rate-limit PR landed with ruff violations the full gate flags but the authors' runs missed: test_rate_limit_sweep.py was unformatted, and test_rate_limit_tracker.py had unsorted/unused imports and magic-value comparisons. Format the sweep test, drop the dead imports, and bind the magic comparison values to locals. Also strip acceptance-criteria-number labels from comments/docstrings across the three rate-limit test files (leaving genuine acceptance_criteria=[...] test data untouched), and add api/deps.py to the PLC0415 per-file-ignore — it is the DI wiring hub and defers a couple of service imports to call time to avoid import cycles, the same rationale already applied to api/routes, runtime, and services. * fix(rate-limit): resolve redis type errors in RateLimitStateTracker A cold mypy run (the gate's true state — prior passes were warm-cache only) flagged four redis-typing errors in rate_limit_tracker.py that the merge missed: three unused type:ignore[type-arg] on redis.Redis, and an aclose() the bundled redis type stub doesn't expose. Drop the now-unused ignores, and close the scan client via 'async with redis.from_url(...) as r:' instead of a finally-block aclose(). The context manager closes the client on exit using the modern redis.asyncio API — no deprecated close(), no stub-missing aclose(), no suppression. Extend the test's redis mock to model the async context-manager protocol so it returns itself on enter. * test(prompter): pass route='main_pm' in the product main-PM routing test Pre-existing master failure, unrelated to the rate-limit work. The test is named ...product_routes_to_main_pm and asserts team=MAIN_PM, but called confirm_live_draft without a route, so it got the 'board' default — which assigns the Product Owner and yields team=BOARD by design (the board-review path keeps the root at team=board until the CEO approves). The Main-PM path is selected with route='main_pm', exactly as the sibling ...main_pm_route_assigns_main_pm test does. Add the missing kwarg so the test verifies the path it names; behaviour under test is unchanged. * Updated uv.lock * refactor(complexity): bring all rank-C blocks under the xenon B ceiling The full quality gate's xenon step (--max-absolute B --max-modules A --max-average A) failed on eight rank-C blocks plus the extraction module average — debt the rate-limit and token-analytics merges deferred. Reduce each by extracting cohesive helpers, behaviour unchanged: - orchestrator._probe_one_provider: split into _too_early_to_probe, _on_probe_success, _on_probe_failure, _parked_agents_for. - rate_limit_tracker.list_rate_limited_providers: extract _read_rate_limited_entry and a _decode helper. - trigger_filter.decide_spawn: extract _stale_trigger_decision (drops the PLR0911 suppression too). - ollama_embedder (embed_query, _embed_batch_sync, aembed_query, _embed_batch_async): share _rl_backoff / _map_embed_error / _log_429 / _sleep_connect_retry / _asleep_connect_retry; remove a dead post-loop guard in aembed_query. - mentor._synthesize_answer: extract _select_system_prompt and _answer_from_response. - indexes/base.ask: extract the 429-retried LLM call into _ask_llm. - extraction.__init__: extract _compile_patterns so the module average lands at rank A. xenon now exits 0; rate-limit, optimal_brain, extraction, and events suites all green. * chore(deps): drop obsolete types-redis stub; honor redis 8.0 inline types types-redis 4.6 (typed for redis 4.x) shadowed redis 8.0's own inline types, which both masked real annotation mismatches in stream_bus.py and forced awkward workarounds elsewhere. The stale stub is why the mypy gate only ever passed warm-cached: a cold run under the wrong stub disagreed with the code. Remove types-redis (and its orphaned transitive stubs) so mypy uses redis's shipped types. That surfaces that xreadgroup/xclaim return bytes-keyed records while _handle_message is annotated str — the code already decodes bytes defensively, so this is an annotation gap, not a runtime bug. Make the types honest: cast each result to its concrete shape and decode the stream name and message id to str at the dispatch boundary via a _to_str helper. mypy roboco/ is now clean cold (247 files) against redis's real types; events suite green. * Updated uv.lock * fix(workspace): install the dev extra so agents can run make quality Agent workspaces were set up with plain `uv sync`, which installs only the project's default dependency group (pytest) — not the `dev` *extra* where the gate tools live (ruff, mypy, xenon, radon, vulture, bandit, deptry). So an agent's .venv had pytest but no linters, and `make quality` died immediately on `ruff: command not found`. Agents literally could not lint, type-check, or complexity-check their own work, which is how format/mypy/xenon debt merged unseen. Sync the `dev` extra (`uv sync --extra dev`) so the workspace gets the full toolchain the setup's own docstring already promised. * fix(panel): rate-limit endpoint shape + websocket path Two panel-facing breakages from the rate-limit rework: - GET /api/system/rate-limits returned a raw list, but the panel store reads response.entries — so `r.entries is not iterable` crashed the banner sync on page load. Return the panel's contract: a { entries: [...] } envelope whose items are camelCase {provider, affectedAgents, hitAt, resumeAt, retryAfterSeconds}, derived from the raw Redis state (resumeAt = hitAt + retryAfter). - The rate-limit websocket hook passed "/ws/system" while getWebSocketUrl() already supplies the "/ws" base, producing the doubled "/ws/ws/system" URL. Pass "/system" to match the agents/channels/notifications hooks. Note: the backend /ws/system endpoint itself does not yet exist (the rework shipped the panel hook only); the REST fix keeps the banner correct on load and reconnect until that endpoint is built. * test(workspace): assert uv sync installs the dev extra Follow the workspace setup change: the dependency-install command is now `uv sync --extra dev` so the agent workspace gets the lint/type/complexity toolchain. Update the three assertions that pinned the old `uv sync`. * feat(ws): add /ws/system stream and bridge rate-limit events to the panel The rate-limit rework shipped the panel's websocket hook but no backend: there was no /ws/system endpoint and nothing forwarded RATE_LIMIT_HIT/LIFTED to a socket, so the banner got no live updates. Build the missing half: - ConnectionManager grows a system-wide connection set with connect_system / broadcast_system, and disconnect() now clears it. - A /ws/system websocket endpoint (operator stream, no per-agent keying) with the same connected + ping/pong lifecycle as the other streams. - websocket_bridge subscribes RATE_LIMIT_HIT/LIFTED and forwards each to broadcast_system tagged with the type the panel switches on. Both events ride the same StreamEventBus singleton, and the subscriptions register before start_listening(), so the consumer reads their streams. Pairs with the panel hook now passing '/system' (getWebSocketUrl supplies the '/ws' base). Covered by handler, manager, and endpoint-lifecycle tests. --------- Co-authored-by: Renn F <rennf93@users.noreply.github.com>	2026-06-11 18:16:20 +02:00
3 people	ff35a646fa	Chore: reduce analytics complexity (#100) ... * refactor(analytics): reduce cyclomatic complexity in usage/pricing/rollup Collapse the three near-identical get_by_* aggregation methods in UsageService into a shared _aggregate_by helper parameterized by group column and key name, and centralize token null-coalescing in a _row_tokens helper. Extract the per-row upsert in _sweep_daily_rollup into _upsert_rollup_row, and the pricing-table lookup into _lookup_prices. All blocks now rank <= B and both modules rank A, so the xenon gate passes; behavior is unchanged and existing tests stay green. * feat(billing): make token pricing provider-aware Distinguish three cases when a model has no per-token rate: a non-Anthropic model (local Ollama, or an Ollama Cloud ":cloud" model billed by flat subscription / GPU-time) legitimately has no per-token cost and returns 0.0 silently; an unpriced Anthropic ("claude"-named) model also returns 0.0 but logs a warning, since that is real spend being undercounted and catches new or renamed Claude models missing from the table. Folds the old ollama/ prefix special-case into the general non-Anthropic path so there is one code path, and replaces the blanket 'no pricing data' warning that fired even for self-hosted models. * fix(tasks): preserve ownership when force-unclaiming to pending The stale-claim reaper and the dependency-blocked release both routed through _force_unclaim_to_pending, which nulled assigned_to and left the task in a pending state owned by nobody — no dispatcher re-spawns an ownerless pending task, so it went dormant. The dispatcher-side claimed_by fallback only masked half the cases. Capture the owner before releasing the claim and keep both assigned_to and claimed_by pointed at it (mirroring the unblock restore), releasing only the live claim (active_claimant_id + heartbeat) and the WorkSession. The same agent now resumes the task once it re-dispatches. Updates the reaper test that asserted the old orphaning behavior and adds owner-preservation coverage for both the reaper and dependency-release paths. * fix(tasks): unblock restores the owner into both ownership fields Audit follow-up to the force-unclaim ownership fix. unblock() only restored assigned_to from blocker_raised_by, which block() stashes solely from assigned_to. A task claimed via give_me_work (claimed_by set, assigned_to null) therefore unblocked into a split-owner state — assigned_to null but claimed_by set — that both the dev dispatcher and the PM pool-router race to pick up. It also left claimed_by pointing at the resolver PM after an escalation. Resolve the owner as blocker_raised_by or assigned_to or claimed_by and write it to both fields, matching the force-unclaim and reassign convention so the original worker resumes cleanly. Adds coverage for the give_me_work-claim case and asserts owner restoration on the existing in_progress-resume test. * test(orchestrator): cover dev owner resolution and the claimed_by fallback _resolve_dev_owner_uuid had no coverage. Add the status-dependent precedence (claimed/blocked prefer the live claimant; other statuses prefer the PM-assigned owner) and the half-reap fallback where a pending task with assigned_to nulled still resolves its owner from claimed_by instead of going dormant. * fix(tasks): wire the pre-block snapshot so unblock(restore=True) works The restore=True path on a PM unblock was a no-op: pre_block_state / pre_block_assignee (migration 006) were read by unblock_with_restore but never written, so it always fell through to legacy unblock() and the restore flag did nothing. Snapshot the resting status + owner at every block entry (dependency block, soft block, escalation) before mutating, capturing only the first block in a chain so a re-block doesn't overwrite the original state. Escalation snapshots the outgoing owner, not the escalation target, so restore returns the original worker. The restore path applies the same branchless guard legacy unblock() relies on — a snapshotted in_progress with no branch diverts to pending instead of looping the dispatcher — and is extracted into _apply_pre_block_restore to keep complexity under the gate. Adds coverage for snapshot capture, restore, the branchless divert, and escalation owner restoration. * test(tasks): update orphan-reconciler and dependency-release tests for owner preservation Both the startup orphan reconciler and the dependency-blocked claim release route through unclaim_for_reaper / _force_unclaim_to_pending, which now preserve the owner instead of nulling assigned_to. Update the two tests that asserted the old orphaning behavior to assert the owner is kept (so the same agent resumes) while the live claim is released. * chore(tests): scrub internal work-item labels from test names, docstrings, comments Rename four test files that carried audit work-item IDs in their filenames (test_p0_7_branch_atomicity, test_p2_8_orphan_reconciler, test_p2_9_autogen_prompt_layer, test_p2_7_attempt_id) to describe what they test, and strip the matching P-/D-/S- cluster labels from docstrings, comments, and assertion messages across the test suite and two orchestrator comments. These are internal references with no meaning in the codebase; behavior is unchanged. * style: reformat assertion line shortened by the internal-ref scrub * build: waive unreachable torch CVE-2025-3000 in pip-audit gate torch is a transitive CPU-pinned dep (piragi / sentence-transformers) never loaded at runtime — the stack uses Ollama over HTTP for all embeddings/LLM, so the vulnerable torch.jit.script path is unreachable. CVE-2025-3000 is MEDIUM, local-only, with no published fix. Documented --ignore-vuln waiver; revisit when a fixed torch ships. * fix(orchestrator): route unplaceable pending tasks to main-pm instead of dropping them _get_routing_target returned None when a 'dev'-classified task had no cell agent (no team, or a non-cell team like fullstack/system) or when the routing classification was unrecognized. _route_unassigned_pm_task logged 'no routing target found' and returned, leaving the task ownerless and pending — and no dispatcher re-spawns an unrouted pending task, so it went dormant for 10+ min until the stuck-task detector caught it. Fall back to main-pm (the same default cell_pm routing and escalation already use) so the task is always owned and triaged, never stranded. Logs the fallback so unplaceable tasks stay visible. Adds a test asserting no (routing, team) combination ever resolves to None. * fix(panel): make intake chat markdown inherit the bubble's text color MarkdownBody is shared by the assistant (text-foreground) and user (text-primary-foreground) bubbles. [&_*]:!text-inherit only colored the prose div's descendants, so the prose div itself kept the prose typography body color (gray) and children inherited that — unreadable on the muted assistant bubble. Add !text-inherit on the prose div itself so it inherits the bubble's color too; descendants then inherit the correct foreground. Fixes both bubbles without hardcoding a color. * fix(prompter): keep a board-reviewed product on the board team so Approve & Start shows A product coordination root confirmed via 'Board review & Start' is assigned to a board reviewer (product-owner) for review, but create_task_from_draft set team=main_pm for every product unconditionally. The CEO's Approve & Start gate keys on team=board, so the button never appeared — and because the owner stayed a board agent while the team said main_pm, the dispatcher routed it to the board path (nothing left to do after review) and the task stranded at pending, with the board agent fruitlessly trying to escalate it up. Route a product by its assignee: a board reviewer keeps it team=board (so the gate appears and approve_and_start later hands it to Main PM), while a main-pm assignee — the 'Approve & Start' straight-through path — is team=main_pm. Adds _assignee_is_board mirroring TaskService's board-role check, and a test. --------- Co-authored-by: Renn F <rennf93@users.noreply.github.com>	2026-06-11 04:36:17 +02:00
3 people	b9082a5c70	Fix: agent idle deadlock and lifecycle hardening (#96) ... * fix(panel): cap dialog height and pin footer so actions stay reachable Shared DialogContent now caps at max-h-[85vh] with overflow-y-auto, and the footer is sticky to the bottom. Long content (e.g. a pasted change-request note) no longer pushes the submit/cancel buttons past the viewport — the body scrolls while the actions stay visible. No-op on dialogs that already fit. * feat(notifications): suppress duplicate same-purpose notifications at send A notification is not created when an unacknowledged one with the same purpose — same sender, same type, same task, overlapping recipients — already exists. Body text is not compared, so rewording cannot defeat it; a different type, task, sender, or an already-acked recipient all still send through. Stops agents that loop re-issuing the same signal from piling up unread that soft-blocks the recipient's idle path. * fix(gateway): stop board/PM lifecycle verbs from 500-crashing Two unguarded crashes that wedged the org in respawn/escalate loops: - escalate_to_ceo dereferenced None.status when the verb runner declined the escalation (task not in awaiting_pm_review — e.g. a board agent escalating a blocked task). It now returns a clean invalid_state. The message/remediate build moved to a helper so the function stays within the complexity gate. - The coordination-root git ops (pr_target, pr_merge, PR update, branch-token resolve) called UUID(str(task.project_id)) directly, which raised on a coordination/integration task (project_id is None — 'badly formed hexadecimal UUID string'). They now resolve through _project_for_task, which falls back to the product's repo for project-less roots. * refactor(intake): split out _block_to_chunk per-block classifier Extract the per-block classification from _blocks_to_chunks so each function stays within the xenon cyclomatic-complexity gate (was rank C). Behaviour is unchanged — verified by the existing intake_driver tests. * feat(gateway): make the i_am_idle unread soft-block satisfiable The soft-block on unread A2A / @mentions had no clearing path, so once those briefing fields populated an agent could never idle — a whole-org deadlock. Keep the guard (it is correct) and add the missing clear paths: - New read_messages content verb (schema -> route -> handler -> a2a.mark_all_read -> MCP tool -> role do_tools): bulk-zeroes the caller's unread A2A and stamps read_at. The idle hint now points to it. - list_unread_mentions returns UNACKED MENTION-type notifications (each @mention already raises one via messaging._notify_mentions) instead of raw, unconditional mentions, so they clear via the existing notify_ack. No schema migration needed. The soft-block is now satisfiable: A2A via read_messages, mentions and notifications via notify_ack. * fix(tests): repair notification-dedup db.scalar mocks + prompter agent seeding The notification send-dedup added a db.scalar() purpose-lookup to _create_notification; the two hand-rolled _FakeDb test stubs (test_notification, test_a2a_priority_tristate) had no scalar() method → AttributeError. Add scalar() returning None (no duplicate) so creation proceeds. Separately, the prompter '& Start' route tests assign the draft to a fixed product-owner / main-pm AGENT_UUID but only seeded system + CEO, so the assigned_to FK failed in isolation (and main-pm flaked in the full suite). Seed both via idempotent merge() in _seed_project_and_ceo. * fix(git): gitignore .pnpm-store + flag GH001 push rejection as permanent A dev once committed the ~115 MB pnpm store → GitHub GH001 (>100 MB) pre-receive reject → open_pr retry-loop. Two root fixes: - Add .pnpm-store/ to .gitignore — an ignored dir can't be staged by any git add. - push() restates a GH001 / file-size rejection as an unmistakable PERMANENT error pointing at i_am_blocked, so the agent stops blind-retrying a push that can never succeed (it otherwise mis-reads the raw output as a transient timeout). The per-verb retry cap (open_pr: 5) already bounded the burn; this ends it. * fix(gateway): accept a PM decision note as satisfying the complete/submit_up reflect gate A cell/main PM that wrote a fresh decision but no separate reflect note bounced on the reflect tracing-gate indefinitely (re-confirmed live: cell PMs looped on cell_pm_complete -> journal:reflect until reaped, burning tokens — worse because each respawn resets the per-verb retry cap). For a PM closing/submitting a task the decision note already documents the close; the separate reflect is the redundant artifact weak-model PMs forget. Accept a fresh decision as satisfying reflect for complete + submit_up — the gate still requires a decision + substantive notes, so the close stays documented. NOTE (enforcement tradeoff, flagged for CEO review): this intentionally relaxes the PM complete/submit_up gate. It does NOT touch the developer i_am_done gate. * feat(gateway): refuse i_am_idle when a PM still owns a task awaiting its review A cell/main PM once tried to 'send work back' by DMing the developer and going idle — but a DM changes no task state, so the task stayed awaiting_pm_review and the orchestrator just re-dispatched the PM in a loop. i_am_idle now refuses (like the pending-assignment guard) when a PM owns an awaiting_pm_review task, with a clear remediation: complete() to finish, or reassign()/delegate() to route it back. PM-only; devs/QA/doc unaffected. Pairs with the reflect-gate relaxation so the PM can actually complete instead of looping. * feat(gateway): push a prior-work handoff digest into task-scoped briefings A freshly spawned or respawned agent previously started cold on every lifecycle hand-off: the prior worker's PR, commits, acceptance status and journal highlights lived in task evidence but were pull-on-demand, so each new role agent re-explored the codebase from scratch — wasted tokens and fragile context loss across respawns. build_task_handoff() composes a compact, DB-only digest (no git diff) and _briefing_for() now attaches it to context_briefing whenever the caller already holds the task row. The digest is built only from a passed-in task, so there are zero extra fetches: every resumption entry point (give_me_work and pm_give_me_work, i_will_work_on, i_will_plan, triage/triage_all, i_am_done, submit_up, escalate_up, complete) threads the loaded task, while id-only correction/rejection paths cleanly omit it. Every field is type-guarded so a partial row never leaks a non-serialisable value into the envelope. * docs(prompts): tell agents to resume from the briefing handoff before re-exploring The base prompt described the success envelope but never told agents to act on context_briefing, so a respawned or hand-off agent would re-scan the whole repo and re-derive the plan even when the briefing already carried the prior worker's PR, commits, acceptance status and journal highlights. Adds a 'Resume from your briefing' section that walks each task_handoff field and instructs the agent to continue from it — and to read the unread A2A / mention / notification lists, which are messages addressed to them. Pairs with the gateway change that now pushes task_handoff into every task-scoped briefing. * feat(tasks): remember cleared dependencies so the unblock briefing can surface them When an upstream dependency completed, _unblock_dependents removed its id from the dependent's dependency_ids to let it be claimed — destroying the only record of which upstream task had just landed. The revived dependent then re-discovered that work from cold. Adds tasks.completed_dependency_ids (Alembic 026, uuid[] default '{}'): _unblock_dependents now appends the cleared id there instead of only dropping it, and the briefing handoff digest surfaces it so the agent picking the task back up knows its blocker cleared because that upstream work shipped. The base prompt documents the field. Migration round-trip verified against postgres (upgrade adds the column, downgrade drops it). * docs(prompts): instruct PMs to split oversized tasks into per-concern subtasks A subtask carrying a long acceptance list or spanning multiple layers/files drove repeated QA failures and a PM revision loop — QA can't pass a partial, and the dev keeps re-touching unrelated parts. Nothing in the PM prompts told them to decompose by size/concern. cell_pm gets a 'Sizing' rule: one subtask = one focused concern with ~2-4 criteria and its own dev->QA pass; decompose anything larger before delegating, sequencing with dependencies. main_pm gets a matching reminder to scope each cell's slice to that cell's layer rather than handing a cell a cross-layer monolith that just pushes the problem down a level. * fix(gateway): mirror the task= kwarg on ChoreographerHelpers helper signatures The handoff-digest change added a keyword-only task= parameter to _briefing_for and _build_tracing_gap in _impl, but the ChoreographerHelpers base that the role mixins inherit still declared the old signatures, so the composed Choreographer had two incompatible base definitions (mypy [misc]). Sync the base declarations to match. * fix(tasks): keep the owner on a substitute-out so the task isn't orphaned build_substitute_update unconditionally nulled assigned_to, so any substitute that routes to PENDING (max_retries, low_context, out_of_scope_*) — the path a verb hitting repeated 500s or its retry limit takes — left the task pending AND unassigned. The dispatcher only respawns a pending task when it has an owner, so the task went dormant: no agent ever picked it back up. Keep the task with its current owner instead. A substitute-out is almost always a transient stall, so the task re-dispatches to the SAME agent, which resumes from the briefing handoff. Only the task_complete -> PM-review handoff changes owner (unchanged). * feat(a2a): suppress duplicate unread A2A messages at send A respawned or retrying agent could re-emit the same DM, stacking identical copies on the recipient's inbox and re-bumping the unread count — noise that the recipient then has to clear. The notification path already dedups; A2A did not. send_chat_message now suppresses a send when an identical message from the same sender is still unread in the conversation, keyed on (conversation, sender, message_kind, content). Genuinely different messages are never collapsed (verified: distinct content still produces distinct rows), so this avoids the earlier per-pair over-suppression. No migration. * fix(panel): default the notifications view to Unread, not All Landing on the All tab buried new notifications under everything already seen — the most-reported annoyance. The Unread tab is the actionable view, so make it the default; the All/Pending tabs are one click away. * fix(panel): show clone progress during intake prep instead of a frozen pill The first clone of a repo can take a few minutes, during which the intake form showed only a static 'Preparing the agent…' button — indistinguishable from a hang. Add a progress region while preparing: an elapsed timer, a saturating progress bar (approaches but never reaches 100% until the agent actually answers), and staged copy (spinning up → cloning → first-clone-takes- a-while → reading the codebase) so the wait reads as work, not a freeze. * feat(docs): index workspace-authored docs that never reached the RAG store Docs written through roboco_docs_write land at /app/docs on the orchestrator and index fine. But a documenter can also write docs with Edit/Write directly in its own clone (README, CHANGELOG, workspace markdown); those resolve to a /app/docs path that doesn't exist on the orchestrator, so the indexer reads nothing and the docs never become searchable — a cross-container miss with no shared mount to bridge it. On docs completion, capture each listed doc's committed content out of the branch (new GitService.read_file_at_branch, via git show) and write it server-side under /app/docs before indexing, so workspace-authored docs reach RAG too. Docs already present server-side are skipped; absolute paths and unreadable/uncommitted files are passed over best-effort. * feat(prompter): survive a browser reload by reconnecting to the live intake chat The intake chat lived entirely in React state, so a page reload wiped it and dropped the human back to the scope form — even though the agent container outlives the page. Now the chat persists a small TTL'd slice (session id, messages, scope, draft) to localStorage and, on mount, reconnects: it asks the new GET /live/{id}/status whether the session is still running and, if so, restores the history and reopens the SSE stream; if dead or expired it clears and shows the form. A full reload doesn't run React effect cleanup, so the navigate-away reap never fires on refresh and the session stays up. Backend adds the status endpoint + PrompterLiveRegistry.is_alive; localStorage is cleared on confirm, start-another, and SPA navigate-away. * chore: remove internal session-bookkeeping refs from code comments (part 1) Strip leaked task/finding numbers, Wave/Phase/cluster/audit labels from docstrings and comments across services, foundation policy, runtime, mcp, api schemas, and agent_sdk — they mean nothing to a repo reader and expose process internals. Wording preserved; only the labels dropped. Done by hand, one comment at a time (no scripted rewrite). _impl.py follows separately. * chore: remove internal session-bookkeeping refs from code comments (part 2) Finishes the manual scrub: the choreographer _impl.py docstrings/comments plus the remaining dogfood-run ('smoke-N') labels across runtime, mcp, foundation, api schemas, services, and agent factories. Reworded to describe the bug or behaviour in plain words; every label dropped. The repo source is now free of task/finding numbers, Wave/Phase/cluster/audit/smoke labels. By hand, one comment at a time. --------- Co-authored-by: Renn F <rennf93@users.noreply.github.com>	2026-06-10 12:04:24 +02:00
3 people	9f8834155a	Feature: prompter gold upgrade (#84) ... * feat(prompter): make the assistant a RoboCo insider and fully wire launch The Prompter's intelligence lived in two thin static prompts, so it asked generic checklist questions and produced a flat task. The launch path was also only half-wired: the panel called the generic task-create endpoint with no project, bypassing the Prompter's own confirm flow. Interview brain - Rewrite the chat system prompt with RoboCo's org model, the task-spec standard, a dimensions playbook, and a reflect-back, 1-2-questions-per-turn, auto-stop discipline. - Inject the live projects/products list each turn so the assistant grounds questions in real surfaces and resolves the target itself. - Replace the brittle phrase-match readiness with a parsed roboco-meta control block (parse_readiness); the block is stripped from the visible reply and the turn now returns draft_ready + scale. Structured GOLD draft - Add first-class draft fields (objective, what_this_builds, the_work, notes) carried in the existing draft_data JSONB — no migration. - Compose the GOLD markdown description deterministically from those fields (compose_description); the model never hand-formats the body. Adaptive routing + wired launch - Confirm now runs through the Prompter confirm endpoint with the human's project/product choice and edited structured draft. - Single-cell targets a project and the cell team; a multi-cell feature targets a product and becomes a Main-PM coordination root that fans out. Frontend - Turn-envelope draft_ready (drop the duplicated phrase-match), structured draft card, confirm dialog with a project/product picker and a per-cell The Work editor, and the corrected priority labels (0 highest .. 3 lowest). * fix(prompter): commit session writes so they survive across requests Session create returned 201 but the row was never durably committed, so the immediately-following /messages call could not find it and 404'd. The prompter routes were the only write surface that never called db.commit() — every other write route (tasks, a2a, groups, docs, product) commits explicitly rather than rely on the request-teardown auto-commit, which is sensitive to middleware and teardown ordering under the production server. - Commit explicitly in all four prompter write routes (create session, send message, get/generate draft, confirm). - Fix _get_session's NotFoundError: it passed a full sentence as resource_type, producing the doubled "... not found not found" message; now uses the (resource_type, resource_id) signature. - Panel: when a message hits a session the server no longer has, start a fresh session and retry once instead of dead-ending on a stale id. Add a regression test that gives each request its own non-committing session — the real cross-request boundary the shared-session integration tests never crossed. It reproduces the production 404 without the route commit and passes with it. * refactor(prompter): drop the "GOLD" jargon for plain wording "GOLD" was informal shorthand for "a good/well-formed spec" that should never have been baked into the LLM prompts, comments, and docstrings as if it were a defined term. Replace it everywhere with plain language ("a well-formed task", "a complete task spec", "the markdown description", "structured spec fields"). No behaviour change. * feat(intake): add the intake interviewer agent role (static definition) Phase 1 of the intake-agent feature: a new first-class `prompter` role — the intake interviewer the CEO chats with to draft a task. This commit defines the role across every foundation layer (no runtime yet); spawning + the live session come next. - identity: Role.PROMPTER, RoleLevel.INTAKE (lowest authority), an AGENTS row (intake-1) on the board team, ROLE_LEVEL entry. Deliberately NOT in BOARD_ROLES — it interviews, it does not review. - lifecycle: gets i_am_idle like every agent (its only verb); no delivery-lifecycle intents. - journaling: ReadTier.OWN — isolated, reads only its own journal. - role_config: human-only manifest — note + evidence only, no say/dm/notify/ channels; allows_subagent=True (research), allows_write=False. - agents_config derives it automatically and correctly excludes it from TASK_CREATOR_ROLES (it drafts, it never creates tasks). - seed presentation ("Intake"); regenerated lifecycle artifacts. - role system prompt: read the code first, single-CEO awareness, propose rather than interrogate — written against the failures we saw. - docs: roster count 19 -> 20, org charts, verb-surface table, usage roster. All foundation drift checks pass; role/manifest/permission tests green. * feat(intake): migrate agentrole enum to add 'prompter' ALTER TYPE agentrole ADD VALUE IF NOT EXISTS 'prompter' so the intake agent row seeds/spawns against a migrated production DB. Forward-only (postgres can't drop enum values), guarded for offline mode — matches migration 012. * style(intake): ruff format the role additions * fix(intake): unguard the agentrole migration so it renders offline The enum-migration-parity test renders 'alembic upgrade head --sql' (offline) and greps for ALTER TYPE ... ADD VALUE. The is_offline_mode() guard skipped emitting it, so the parity check couldn't see 'prompter'. Drop the guard — PG16 permits ADD VALUE in a transaction, same as migration 020's backfill. * feat(intake): the live-session driver (Claude Agent SDK loop) Phase 2 begins. The intake agent isn't a one-shot `claude -p`; it's a live Claude Code session the human chats with. This driver is the container's loop: open one long-lived claude-agent-sdk ClaudeSDKClient, then per human message run a turn (query + receive_response) and stream its events out, keeping conversation context in-process — verified against the real SDK (v0.2.94). - StreamChunk + normalize(): map SDK messages (StreamEvent text deltas, AssistantMessage text/thinking/tool_use blocks, ResultMessage→session_id) to panel-facing chunks. Duck-typed, so it works on real SDK objects and on test fakes alike — SDK-free, fully unit-tested. - IntakeDriver.run(): the loop, with injected session/source/sink seams; a turn failure surfaces as an error chunk without killing the session. - SdkIntakeSession + build_intake_options: the only SDK-coupled code (lazy import; needs the live claude binary, so excluded from coverage). - Add claude-agent-sdk dependency + mypy ignore-missing-stubs. Relay, panel SSE, and the persistent on-demand spawn are the next steps. * Updated uv.lock * feat(intake): the panel<->agent live bridge (registry, routes, entrypoint, image) Wires the live intake chat end to end (Phase 2 integration layer): - prompter_live.py: the orchestrator-side per-session registry — open/close, push (agent->panel), stream (SSE drain), deliver (panel->container). In-process (the orchestrator is single-process). 7 unit tests. - routes/prompter_live.py: GET /live/{id}/stream (SSE), POST /live/{id}/messages (deliver), POST /live/{id}/events (relay in); registered under /api/prompter. 5 integration tests. - agent_sdk/intake_main.py: the container entrypoint — a POST /turn receiver (the driver's MessageSource) + a relay-poster EventSink + the ClaudeSDKClient session, run concurrently. 4 unit tests on the wiring helpers. - docker/agent-prompter.Dockerfile: FROM base, ENTRYPOINT = the driver (not the one-shot `claude` the other agents use). Remaining for Phase 2: the orchestrator persistent-spawn path (scope->workspace clone, CMD = driver, registry.open on spawn, reap-on-confirm) — the deploy-side piece, best finalized against a buildable image. * feat(intake): orchestrator persistent spawn + start/stop for the live chat Add the task-free spawn path for the intake (prompter) agent: one fixed intake-1 container running the Agent-SDK driver (image ENTRYPOINT, not claude -p), one live session at a time. - spawn_intake_session clones the scope's repo(s) via WorkspaceService (project -> one; product -> each distinct project, primary first), composes the intake-1 prompt, resolves the model, and builds docker run via _build_intake_run_cmd: no settings/hook mount (driver owns 9000), no MCP config, no -w; registers the live relay and best-effort delivers the opening message once the receiver is up. - reap_intake_session closes the relay and stops the container. - Routes: POST /live/start (project XOR product) and POST /live/{id}/stop. - ROLE_MODEL_MAP[prompter]=opus; intake-1 -> roboco-agent-prompter image map. - Replace the budget-sweep try/except/continue with _fetch_budget_status, which logs the swallow at debug instead of silently dropping it. 25 new tests; docker + the clone are mocked. End-to-end container spawn is pending a built image and the stack. * feat(intake): wire /prompter to the live agent — scope form + SSE chat Replace the Ollama chat loop on /prompter with the spawned-agent flow. - IntakeForm: pick scope (project XOR product) + opening message + Start before the chat; the agent clones that scope and reads the real code. - use-prompter rewritten as the live brain (lib/api/prompter-live.ts): Start spawns via POST /live/start, then an EventSource on /live/{id}/stream streams the agent working — token deltas fill the assistant bubble, tool_use/thinking drive a live activity line, a draft event renders the existing DraftProposalCard. Messages go via POST /live/{id}/messages. - Chat UX unchanged (Keep Chatting / Review & Confirm / ConfirmDialog reused); reap-on-confirm and reap-on-leave call POST /live/{id}/stop. - Drop the dead Ollama prompterApi client; trim prompter.ts to shared types. Frontend gate green (tsc --noEmit, lint, build). The draft event + the /live/{id}/confirm endpoint are the Phase 4 backend seam. * feat(intake): confirm draft -> backlog task + agent draft emission Complete the live intake vertical: the agent proposes a structured draft and Review & Confirm turns it into a task. - Draft emission: the prompter prompt instructs the agent to emit a fenced roboco-draft JSON block when the spec is ready; the driver parses it into a 'draft' event over the existing relay -> the panel's DraftProposalCard. The panel strips the raw block from the chat bubble. - Fix a double-text bug: with include_partial_messages the reply arrives as both StreamEvent deltas and the final AssistantMessage; the driver now takes text from deltas only and the AssistantMessage for thinking/tool_use/draft. - POST /live/{id}/confirm -> confirm_live_draft, reusing a draft->task core extracted from confirm_draft; reaps the session on success. - Both prompter confirm paths create at BACKLOG, not pending: backlog is the holding area a draft waits in until it's reviewed and promoted to pending (TaskService.activate). The legacy Ollama confirm was creating at pending, skipping that gate — fixed. - Remove the dead 'context' bootstrap param from the Ollama session-create chain (schema + route + method + tests), superseded by the live scope form. - No suppressions: replace every type:ignore/noqa across the intake surface with a real fix (ORM .id -> UUID(str(x)); fakes -> monkeypatch.setattr; lazy imports -> pyproject per-file ignore; union-attr -> recipients[0]). Full make quality green; frontend tsc + lint green. * build(intake): add the agent-prompter image builder to compose The orchestrator references roboco-agent-prompter (AGENT_IMAGES + the _ensure_agent_image dockerfile map) and docker/agent-prompter.Dockerfile exists, but docker-compose.yml built every other agent image up front and left this one out — so the image wasn't pre-built for a stack bring-up. Mirror the other specialized agent-*-image builders: build from docker/agent-prompter.Dockerfile, tag roboco-agent-prompter, depend on agent-base-image. * Created docker-compose.yaml for the NAS * fix(intake): non-blocking /live/start so spawn never times out The start POST awaited the whole spawn — workspace clone + first-time image build + docker run — which blew past the panel's 60s HTTP timeout ('Request timed out. The server may be busy.') and triggered a duplicate send. Found on the 2026-06-09 NAS smoke. - start_intake_session opens the live relay synchronously, then spawns the container in the background (_spawn_intake_container_guarded). The route returns the session id immediately; the panel opens the SSE stream right away. - A background spawn failure is pushed onto the relay as an 'error' event and closes the session, so the panel shows it instead of hanging. - spawn_intake_session stays as the synchronous variant for direct callers/tests. - Panel shows a 'Preparing the agent…' indicator until the first event arrives. 18 intake-spawn tests green; tsc + lint green. E2E re-validates on next smoke. * fix(intake): propose_draft MCP tool + lock the agent down Smoke 2026-06-09 exposed two compounding problems: the agent never reliably emitted the draft (it narrated the spec instead of typing the magic fence), and it had inherited the CEO's entire Claude Code env — Write/Edit/Bash + Gmail/ Notion/Calendar/Drive MCP — because bypassPermissions ignored the allowlist and the mounted ~/.claude leaked the host MCP config. - propose_draft: build_intake_options now registers an in-process SDK MCP tool (create_sdk_mcp_server + @tool). The agent calls it to submit the draft; the driver turns that ToolUseBlock into a 'draft' event (_is_propose_draft / _draft_from_tool_input, tolerant of nested/flat/JSON-string input). The fenced roboco-draft block stays as a fallback. - Lockdown: strict_mcp_config=True + setting_sources=[] (ignore host MCP + settings); permission_mode 'dontAsk' + a can_use_tool gate enforcing a hard allowlist (Read/Grep/Glob/Task + propose_draft) replaces bypassPermissions. - Prompt: call propose_draft (not a fence); the draft's downstream chain is backlog -> Board (PO + HoM) -> CEO approve -> Main PM, and the agent's job ends at the draft (it never routes or hands off). SDK API verified against the installed claude-agent-sdk. Driver detection unit- tested; the SDK-construction is validated on the next NAS smoke (incl. that setting_sources=[] doesn't break the mounted-~/.claude auth). * fix(intake): panel UX cluster from the smoke (#3/#4/#6/#12) - #3 message boundaries: a tool call now ends the current text bubble, so the agent's words before and after a tool render as separate messages instead of one merged wall (the 'two waves merged into one bubble' the CEO saw). - #4 activity indicator: promoted from tiny grey text to a prominent primary- tinted pill so 'watch it work' is actually visible. - #12 End chat: a header button (any chat state) reaps the agent and resets to the form, reusing startAnother (which already stops the session). Backend POST /live/{id}/stop already existed. - #6 log noise: the opening-message delivery retry logs at debug, not error — those failures are expected until the container receiver is up. - Also fix a latent test gap from the #1 commit: the live-route test's fake orchestrator now exposes start_intake_session (the route's non-blocking entry). Frontend tsc + lint green; live-route + prompter_live tests green. * fix(intake): render markdown in the chat bubbles (#8) The agent emits rich markdown (### headers, **bold**, tables, lists) but the bubble rendered raw text, so it was illegible (CEO-flagged on the smoke). Render assistant content with react-markdown + remark-gfm (GFM tables) in a prose container. Adds react-markdown + remark-gfm to the panel. * feat(intake): #14 — two start routes (Board review vs straight to Main PM) Per the CEO spec, the draft confirm now starts the task at PENDING with an explicit assignment instead of parking it at backlog: - route="board" (Board review & Start): assigned to the Product Owner, so the orchestrator dispatches the full Board review (PO + Head of Marketing) before the Main PM picks it up. - route="main_pm" (Approve & Start): assigned straight to the Main PM, who delegates to the cells (Board review skipped). create_task_from_draft gains status + assigned_to params (default BACKLOG, so the legacy confirm_draft is unchanged); confirm_live_draft + the /live/{id}/confirm request carry the route. Service tests cover both routes. * feat(intake): #14 draft-card buttons — Board review vs Approve & Start Three buttons on the draft card now (CEO spec): Keep chatting / Board review & Start / Approve & Start. The two action buttons confirm directly with their route — launchTask(route) sends route to POST /live/{id}/confirm, which starts the task at pending assigned to the Board (PO+HoM) or straight to the Main PM. Supersedes the ConfirmDialog review step (scope is chosen up front in the form), so it's removed from the page flow. The ConfirmDialog component + its sub-editors are now unused — flagged for a follow-up cleanup, left in place to avoid churn. tsc + lint green. * fix(intake): keep the live SSE stream bound to its relay session The orchestrator opened the relay session twice per live chat — once on the request path (before the start call returns) and again inside the background container spawn. The SSE stream binds to the session's queue the moment the panel connects, so the second open swapped in a fresh queue and stranded the stream: the agent replied normally, but its events went to the new queue while the panel kept reading the old one, so the chat looked frozen on "Preparing…". The second open was always redundant (the relay is opened by the caller before the spawn). Remove it, and make open() idempotent so a live session is never replaced out from under a stream that is already connected to it. * fix(intake): draft-card launch buttons silently did nothing The launch path required a `description` field, but the prompter draft schema intentionally has none — it sends `objective` + the structured spec and the backend composes the description (compose_description). `editableDraft.description` was therefore undefined, so `description.trim()` inside launch validation threw a TypeError that propagated out of the button's onClick. Clicking "Board review & Start" / "Approve & Start" did nothing, with no feedback — the wall blocking the whole confirm → task → reap flow. - Map a proposed draft's description from `objective` as a fallback. - Make launch validation null-safe. - Replace the silent early-return with a toast that names what's missing, so a blocked launch is never a dead, feedback-less button again. * fix(intake): steer the agent to ask inline, not via AskUserQuestion The intake's job is to ask clarifying questions, so it reached for the AskUserQuestion tool — which isn't wired to the live chat panel and isn't in its allowlist. The bare deny left it to stumble ("let me clarify… — no worries, let me just lay it out") and waste a visible turn. - Prompt: spell out that it asks by writing in the chat (the human reads every message live) and that no question/prompt tool is available to it. - Gate: give AskUserQuestion a specific deny message that nudges it to ask inline, so even a reflex attempt degrades gracefully. Also refresh the now-stale "what happens after propose_draft" section: the draft card has three choices (Keep chatting / Board review & Start / Approve & Start) and produces a pending task — not the old two-button "backlog" description. * feat(intake): copy buttons on agent messages and the draft card The CEO asked for a way to save the agent's plan/spec elsewhere "just in case" — a cheap manual backstop until refresh-durability lands. - New CopyButton: async Clipboard API when available, plus a legacy textarea+execCommand fallback. The fallback is load-bearing — the panel is served over plain http on a LAN IP, where navigator.clipboard is absent (clipboard needs a secure context), so the modern API alone would never copy. - Copy button under each assistant message (copies its text). - Copy button on the draft card (copies the full spec as markdown: title, objective, what-this-builds, the-work per cell, notes, success criteria). * feat(intake): unbuffer logs + log each turn so the container isn't a black box Debugging the intake smoke was painful for two reasons: (a) the orchestrator block-buffered stdout, so `docker logs` lagged minutes behind reality, and (b) the intake container logged only "session opened" then went silent for the whole conversation (the chat streams to the relay, not stdout). - Set PYTHONUNBUFFERED=1 on the orchestrator and agent-base images so structured logs reach `docker logs` in real time instead of in large delayed chunks. - Log each intake turn: "turn received" (with char count) and "turn streamed" (chunk count + whether a draft was emitted), so the container logs show the conversation's shape at a glance. * chore(intake): remove the dead ConfirmDialog draft editor The three-button draft card (Keep chatting / Board review & Start / Approve & Start) replaced the old review-modal confirm flow, leaving ConfirmDialog and its sub-editors (StringListEditor, TheWorkEditor) referenced by nothing but the barrel export. Remove the three files and the export — typecheck + lint confirm no remaining references. * fix(intake): coerce bad draft enums on confirm instead of hard-failing The intake agent is an LLM and will emit off-enum values — e.g. task_type="feature", which is not a valid TaskType (code/documentation/research/planning/design/ administrative). `_coerce_draft_enums` called `TaskType(value)` directly, which raised, and the confirm 400'd with "Draft has invalid or missing required fields: 'feature' is not a valid TaskType". That forced the agent to discover the valid values and self-correct in-chat — unacceptable: clicking "Approve & Start" must never blow up on a cosmetic enum guess. Coerce each enum to a sane default on invalid/missing (task_type→code, nature→technical, complexity→medium); team falls back to the first valid cell in the_work, then backend. `_lead_cell_team` now skips invalid cell names too. The confirm/launch action no longer hard-fails on an enum the model got wrong. * fix(intake): draft card no longer renders above the user's latest message attachDraft fell back to "the last assistant message anywhere" when the current turn had no streamed text yet (propose_draft called first). That last message was often the PREVIOUS turn's — sitting above the user's "Yes, propose it" — so the draft card rendered above the user's message. Attach only to the current turn's streaming message; otherwise append a fresh assistant message so the card always lands at the bottom of the thread. * test(intake): guard draft enum coercion + invalid-cell skipping Regression tests for the confirm-time enum coercion: an off-enum task_type ("feature") / nature / complexity coerce to code/technical/medium instead of raising, and _lead_cell_team skips invalid cell names. Locks in that a bad enum guess from the agent can never 400 the launch again. * fix(intake): stop the agent fumbling through Claude Code meta-tools In smoke it reflexively probed CC built-ins before reaching propose_draft — plan mode + ExitPlanMode (it announced a written plan and waited instead of emitting the draft), ToolSearch, Write — each correctly denied by the lockdown but stumbly, and it only proposed after explicit CEO nudges. - Gate: ExitPlanMode now gets a specific deny nudge ("you don't use plan mode; call propose_draft"), and the generic deny names the actual toolset instead of a bare "not available", so any probe degrades into guidance. - Prompt: forbid plan mode/ExitPlanMode/ToolSearch explicitly and spell out "you do not plan and wait — call propose_draft directly when the spec is ready," plus an anti-pattern bullet. * feat(intake): make the container logs transparent mid-turn `docker logs` on the intake container was a black box: only turn start/end, while the agent read the codebase and spawned 20+ subagents invisibly (the conversation streams to the relay, not stdout), and the benign 3x ~/.claude.json warning was the only thing visible. - Driver logs each tool call mid-turn ("Intake tool use" with the tool name) and the draft emission, plus a tools count in the turn-streamed summary. Text deltas stay unlogged (they'd spam). Now the logs show the turn's real shape. - Pre-create ~/.claude.json ({}) at container boot so the CLI's "config not found" warning (printed 3x, self-healed anyway) stops drowning the real logs. * fix(intake): render markdown in user messages + scope copy to code blocks Two display fixes from the smoke: - User messages collapsed newlines (plain {content} in a div) and rendered no markdown — a "1.\n2.\n3." answer showed as one run-on line. Render user AND assistant bubbles through a shared GFM markdown body that inherits the bubble's text color, so lists / newlines / styling render correctly on both. - Copy was blanketed on every assistant message; scope it to KEY parts — a copy button on fenced code blocks (the draft card keeps its own). Removed the per-message button. * fix(intake): prevent duplicate tasks from a double-click on launch Clicking a draft launch button twice fired two confirms and created duplicate tasks. Add a synchronous re-entry guard (a ref — no stale-closure window) at the top of launchTask so a second click returns immediately, and disable + spin the draft-card buttons while a launch is in flight so it's visually clear it's working. * docs(how-to): lead task creation with the Task Assistant flow Rewrite "1 · It starts with you" to walk the Prompter/Task Assistant path — scope form, the agent reading the codebase, its grounded analysis, the draft card, and the created task — then flow into the Board review. Replaces the old manual task-definition form shots. Image placeholder: images/prompter_draft_card.png (the 3-button card) is referenced but not yet captured — TODO comment marks it for the next smoke run. A second comment flags an optional re-capture of prompter_run_2 after the markdown-rendering fix. * fix(intake): restore assistant message text contrast The markdown refactor dropped `dark:prose-invert` and made text inherit the bubble's color, but the assistant bubble had no explicit text color — so its text rendered near-invisible (dark-on-dark on bg-muted). Give the assistant bubble an explicit text-foreground; the user bubble already carries text-primary-foreground, and [&_*]:!text-inherit now resolves to a readable color on both. * fix(intake): coerce draft priority too — confirm 500'd on priority="high" The enum-coercion fix covered task_type/nature/complexity/team, but priority is a non-enum int field handled by `int(draft_data.get("priority", 2))`, and the agent guesses a word ("high") as readily as a number — so int("high") raised ValueError and the confirm 500'd. Same class of bug, one field missed. Add _coerce_priority: map words (urgent/high/medium/low → 0/1/2/3), clamp numbers to 0-3, default to 2 (medium) on anything else. The launch can no longer crash on any field the LLM guessed. + regression test. * fix(intake): draft card shows distinct cells, not one badge per work item the_work has one entry per work item, so a cell with several items rendered its badge repeatedly ("Board-led across Backend Backend Backend Frontend Frontend …"). De-dupe to distinct teams so the card reads "Board-led across Backend Frontend" — and the "Cell:" vs "Board-led across" label keys off distinct count. * docs(how-to): hero the teaser gif + resolve the Prompter/Task Assistant thread - Move the 12s teaser gif to the top as the hero — it was buried between the "prefer video" link and the first screenshot. - Name the connection: the Task Assistant IS the Prompter, so section 1 (using the tool) and the rest (RoboCo building it) read as one story — you use the tool the company built for itself, then watch the build. - Re-anchor the section 1 → Board transition to follow the Prompter's own journey, instead of implying section 1's example task is the one reviewed next. * Included images for how-to.md * docs(how-to): align agent count to 20 (matches README + CLAUDE.md) The how-to said "18 agents" with UX/UI at one dev and no Intake — stale against the authoritative count. Bump 18→20 (prose + spelled-out eighteen→twenty), give UX/UI 2 devs, and add the Intake line to the org tree (Intake leads section 1, so it belongs in the tree). README + CLAUDE.md already say 20. * ci(release): publish all RoboCo images to GHCR + Docker Hub The release published only the orchestrator to GHCR. Build and push the full set the stack needs — agent-base, the 8 agent images, orchestrator, and panel — to BOTH ghcr.io/rennf93/* and docker.io/renzof93/*, at :<version> and :latest, so consumers can pull instead of compose-building. - agent-base builds first (the agent images build FROM roboco-agent-base, a local tag), then the rest; push only after every build succeeds. - Image names mirror the docker-compose `image:` values 1:1. - Free disk on the runner first (11 images is space-heavy). - Needs a DOCKERHUB_TOKEN repo secret for the Docker Hub login. - SECURITY.md updated to reference both registries. * ci(release): use short SHA as the image tag on manual dispatch A workflow_dispatch runs against a branch, and the branch name (e.g. feature/prompter-gold-upgrade) was used verbatim as the image tag — but "/" is illegal in a Docker tag, so the first build failed instantly with "invalid reference format". Releases still tag from the release tag; manual dispatch now always uses the short SHA, which is a valid tag. --------- Co-authored-by: Renn F <rennf93@users.noreply.github.com>	2026-06-09 17:08:34 +02:00
Renn F	ae65bff883	fix(prompter): use the local Ollama LLM instead of the Anthropic cloud API ... The Prompter service called AsyncAnthropic, which needs an ANTHROPIC_API_KEY and 500'd in production ("Anthropic API key not configured"). Align it with the rest of the system (RAG / HyDE): call the local LLM over the OpenAI-compatible /chat/completions endpoint (settings.local_llm_*) via httpx — no external key. - Replace the Anthropic client and _extract_text with a single _create_message seam that POSTs to the local LLM and returns the reply text. - Move the system prompt into an OpenAI-style system message; drop the hard-coded Claude model and the per-call model parameter. - Strip a wrapping markdown code fence before parsing the draft JSON (local models often wrap it). - Repoint the prompter unit and route tests at the new seam (return strings).	2026-06-08 17:04:35 +02:00
3 people	85ffec86b4	[529f579a] Implement Prompter chat endpoint and structured task drafting (#76) (#77) ... * [529f579a] feat(prompter): add PrompterService with chat and draft generation endpoints * [529f579a] feat(prompter): add PrompterService, schemas, routes, and integration tests * [529f579a] feat(prompter): implement session-based prompter chat endpoints with DB persistence Add full session-based Prompter chat system with: - Alembic migration 024 creating prompter_sessions, prompter_messages, and task_drafts tables with proper foreign keys, indexes, and enum columns - Three new SQLAlchemy ORM table classes in roboco/db/tables.py - Pydantic schemas: PrompterSessionCreateRequest, PrompterMessageRequest, PrompterSessionResponse, PrompterMessageResponse, TaskDraftResponse, TaskConfirmRequest - Four new session-based FastAPI routes: POST /sessions, POST /sessions/{id}/messages, GET /sessions/{id}/draft, POST /sessions/{id}/confirm - PrompterService with DB-backed session, message, and draft persistence; LLM-driven draft generation; ConfirmOverrides dataclass to stay under PLR0913 - Legacy stateless /chat and /draft endpoints retained for backward compatibility - Unit tests for schemas (test_schemas_prompter.py), service pure functions and DB logic (test_prompter.py) with mocked LLM calls - Integration tests for full happy path and legacy endpoints (test_prompter_routes.py) - All ruff format, ruff check, mypy (changed files), and pytest checks passing * [529f579a] fix(prompter): correct test assertion for confirmed_at field nesting The test test_get_draft_generates_from_conversation incorrectly accessed body['draft']['confirmed_at'] but confirmed_at is a field on the outer TaskDraftResponse, not on the nested PrompterDraftTask. Fixed to body['confirmed_at']. --------- Co-authored-by: Backend Developer 2 <be-dev-2@agents.roboco.dev>	2026-06-07 22:16:56 +02:00