392 Commits

Include renames

Author	SHA1	Message	Date
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	48556a032b	Fix: CEO reject conduit and main pm routing (#91) ... * fix(tasks): deliver CEO change-requests to the reworker and route integration rejects to the Main PM ceo_reject previously appended the CEO's required-changes only to quick_context (never surfaced to an agent) and always reassigned to the original developer, so the feedback never reached whoever reworked the task and a coordination/integration root went to a developer instead of the Main PM. Now ceo_reject records the reason as a DECISION_LOG handoff journal entry — the channel evidence/journal_highlights already serves to the task's assignee — and routes a coordination task (no project, has product) to team=main_pm + the Main PM so it can delegate the rework. Leaf dev tasks still return to the original developer. The journal write is best-effort (author-exists guard) and never blocks a reject. Adds tests for the routing and the handoff-journal write. * feat(gateway): wire the agent context_briefing receive-path EvidenceRepo's agent-scoped methods were stubbed to return empty lists, so agents never received notifications, A2A DMs, @mentions, recent team activity, or in-lane blockers through their briefing — the system was effectively send-only. This implements all five as single capped queries over the live tables (plus a light task-metadata-gap check), mirroring the existing journal_highlights query. Each runs on the per-verb briefing path, so each stays a single LIMIT-10 indexed lookup. Unit tests cover the row mapping + empty paths; an integration suite exercises the real SQL (array contains, the a2a slug filter, team+status) against Postgres. --------- Co-authored-by: Renn F <rennf93@users.noreply.github.com>	2026-06-10 02:26:45 +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
Renn F	e863880883	Fix the Prompter tests against the current schema and SDK ... The Prompter feature's integration tests were never executed by CI — the PR checks run CodeQL and secret-scanning, not the pytest suite — so they carried bugs that only surfaced once the feature was integrated and the full quality gate ran against it: - The project fixture set a `git_branch` field the model doesn't have (it is `default_branch`) and omitted the required `assigned_cell` / `created_by` columns, so every confirm-flow test errored at setup. - The tests patched the Anthropic client's `messages.create` at the class level, but the SDK exposes `messages` as a cached_property, so that target can't be resolved. Route the call through a single `_create_message` seam on PrompterService (behavior-identical) and patch that instead. Also drop `confirm_draft` below the cyclomatic-complexity threshold by extracting the override-merge, UUID-field, and enum-coercion helpers (behavior-preserving; the prompter test suite passes unchanged).	2026-06-08 06:44:14 +02:00
Renn F	5a41ef5c90	Merge master (Prompter #80) into lifecycle-residual-hardening	2026-06-08 05:45:07 +02:00
Renn F	718a16c4f7	Close residual gaps: CEO escalation from blocked, ref repair, reset-script state ... Three independent residual hardenings surfaced by the smoke run: - escalate_to_ceo is now reachable from a blocked task (source widened to {awaiting_pm_review, blocked} with a matching status-transition row), so a main_pm or board agent has a clean verb to surface a task it cannot resolve to the CEO — who can then approve, reject, or cancel it. Regenerated the lifecycle artifacts (status-transitions doc + panel JSON) to match. - WorkspaceService now prunes broken loose refs (.bak debris and any ref whose contents are neither an object id nor a symref) before the refresh fetch, so a ref left corrupt by an interrupted recovery no longer produces per-operation "broken ref" warnings or wedges ref enumeration. Best-effort, file-reads-only. - The reset script's full-reset Claude-state clear now defaults to the replay-state subdirs (projects/, todos/) of the mounted Claude home and refuses to clear the home root, so a full reset actually clears conversation replay state by default without wiping the host's stored credentials.	2026-06-08 05:17:15 +02:00
Renn F	9bbbd6627f	Alert an overseer when the respawn circuit-breaker pauses a wedged agent ... The dispatcher's respawn guard already detects an agent repeatedly spawned on the same task without advancing it, logs a warning, and skips further spawns. But nothing surfaced that to a human, so a wedged agent could sit silently with its task stalled. When the guard trips, send a one-shot high-priority notification to the CEO (tracked per (agent, task) so it fires once, not on every subsequent skipped spawn, and resets if the agent later makes progress). Delivery is best-effort so a notification failure never wedges dispatch. Adds send_stuck_agent_notification to NotificationService and a coverage test asserting the alert fires exactly once across multiple over-threshold spawns.	2026-06-08 04:42:15 +02:00
Renn F	5f32417a63	Harden cell-ownership invariant at reassign and dependency revival ... A board/advisory role (product owner, head of marketing, auditor) has no verb to build, document, or complete a cell task. The escalate path already diverts such a hand-off to the pool; extend the same backstop to the two remaining write-sites: - reassign / reassign_active_claim: a refused board/advisory target is diverted to the pool for a role-matched claim instead of being planted as a non-workable owner. Normal handoff targets (qa, documenter, cell PM) are unaffected. - dependency revival: when a blocked task's last dependency clears, resume in place only under a workable owner; re-home a board/advisory-or-absent owner on a cell task to the pool so it does not immediately re-deadlock. All three sites share one audited pool-divert primitive so no direct status set skips the transition audit. Also reduce cyclomatic complexity below the project threshold for unclaim_for_agent, the dependency-revival path, and the docs index source expansion by extracting helpers (behavior-preserving), and add coverage for the doc source-expansion paths.	2026-06-08 04:23:52 +02:00
3 people	306de1e656	Merge 'master' into 'dogfood feature branch' (smoke test run) (#82) ... * Fix: human surface lifecycle hardening (#81) * fix: harden agent-idle, redis loop, git errors, escalation audit - i_am_idle no longer 500s when auto-pausing a task whose commits are stored as dicts: tolerate dict-or-object commit refs and run the synthetic-checkpoint computation inside the swallowing try block. - The stream event loop no longer logs an idle redis read-timeout as an ERROR every cycle; the blocking-read timeout is treated as a normal idle. - Git command failures surface git's own (secret-scrubbed) stderr in the error message instead of a bare 'Command failed', so push/fetch rejections are diagnosable; the injected PAT is redacted. - The escalate-to-pool redirect emits the task.pending audit event, closing a status mutation that previously skipped the audit log. * fix: let privileged operators set task status via an audited override The task update route silently dropped a 'status' field in the request body, so a CEO/admin could not transition a task wedged in a state with no valid in-band move (e.g. a blocked task whose work merged out-of-band) — the panel returned 200 while nothing changed. Add 'status' to the update schema and apply it through a new audited 'admin_set_status' that bypasses the strict transition validator but always records the audit event. The override requires elevated permissions; ordinary field updates are unchanged. * fix: stop human chat sessions from expiring between messages Messaging sessions fell back to a hardcoded 300s idle timeout, shorter than a normal pause in a human conversation: the sweeper closed the session and the next message opened a new one, so a person could not hold a continuous chat. Make the idle timeout configurable (session_idle_timeout_seconds, default 3600) and resolve an unset timeout to it at every session-creation path instead of the 300s column fallback. * fix: resolve doubled doc paths and stop the indexer warning flood The doc-path resolver returned absolute paths verbatim, so a documenter path that doubled the base segment (/app/docs/docs/...) never resolved on disk and the docs never indexed into RAG. Reduce an absolute path under the docs base to a relative one before normalizing, leaving truly-external absolute paths for the indexer to skip. The indexer now skips non-markdown source files and logs a missing/non-doc source at debug instead of warning on every pass. * fix: reject project repo URLs that point at a protected repository Add a configurable denylist (protected_git_urls) enforced in the project create and update paths, so a project cannot be registered against a repository that must not receive agent commits or merges (e.g. the roboco source repo during a smoke run). Empty by default (no behavior change); operators set it to sandbox smoke-test projects. * fix: let an agent release a blocked task back to the pool A developer (or QA/doc) trapped on a 'blocked' task had no legal forward move — every verb rejected from that state — so the dispatcher kept respawning it with nothing to do. Allow 'unclaim' to release a blocked task the agent owns back to pending (assignment cleared, work session abandoned, audited), so the cell PM can re-delegate it instead of the agent churning. * fix: keep blocked-dev churn out and cell tasks out of board hands - The dispatcher no longer respawns the owner of a blocked task: from blocked the owner has no legal move, so respawning only churns; it is revived on unblock or released via unclaim. - Escalation no longer hands a cell (backend/frontend/ux_ui) coordination task to a board/advisory role — such an escalation is diverted to the cell pool, matching the existing executable-task guard. main_pm targets are unaffected. * chore: add an opt-in full clean-slate to the reset script FULL_RESET=1 wipes everything under the roboco data root except the persistent service stores (ollama/postgres/redis) and clears the persisted agent Claude session dirs (ROBOCO_CLAUDE_STATE_DIRS), which otherwise replay across runs. Default off — the existing DB/Redis wipe + workspace git-reset is unchanged. * ++ --------- Co-authored-by: Renn F <rennf93@users.noreply.github.com> * fix: read the real commit key (hash) and audit the restore-unblock path - The auto-pause checkpoint and _extract_first_commit_sha read commit dicts by key 'sha', but persisted commits are keyed 'hash' (CommitRef.hash) — the prior change stopped the crash but silently dropped every ref. Read 'hash' (sha fallback) at both sites; the test now uses the production dict shape so the regression can't hide. - unblock_with_restore set status directly and skipped the audit log; emit the status-transition audit there too, like the other direct-set paths. --------- Co-authored-by: Renn F <rennf93@users.noreply.github.com>	2026-06-08 03:27:45 +02:00
Renn F	3c02dc7f03	fix: read the real commit key (hash) and audit the restore-unblock path ... - The auto-pause checkpoint and _extract_first_commit_sha read commit dicts by key 'sha', but persisted commits are keyed 'hash' (CommitRef.hash) — the prior change stopped the crash but silently dropped every ref. Read 'hash' (sha fallback) at both sites; the test now uses the production dict shape so the regression can't hide. - unblock_with_restore set status directly and skipped the audit log; emit the status-transition audit there too, like the other direct-set paths.	2026-06-08 02:45:03 +02:00
3 people	f58fd4530e	Fix: human surface lifecycle hardening (#81) ... * fix: harden agent-idle, redis loop, git errors, escalation audit - i_am_idle no longer 500s when auto-pausing a task whose commits are stored as dicts: tolerate dict-or-object commit refs and run the synthetic-checkpoint computation inside the swallowing try block. - The stream event loop no longer logs an idle redis read-timeout as an ERROR every cycle; the blocking-read timeout is treated as a normal idle. - Git command failures surface git's own (secret-scrubbed) stderr in the error message instead of a bare 'Command failed', so push/fetch rejections are diagnosable; the injected PAT is redacted. - The escalate-to-pool redirect emits the task.pending audit event, closing a status mutation that previously skipped the audit log. * fix: let privileged operators set task status via an audited override The task update route silently dropped a 'status' field in the request body, so a CEO/admin could not transition a task wedged in a state with no valid in-band move (e.g. a blocked task whose work merged out-of-band) — the panel returned 200 while nothing changed. Add 'status' to the update schema and apply it through a new audited 'admin_set_status' that bypasses the strict transition validator but always records the audit event. The override requires elevated permissions; ordinary field updates are unchanged. * fix: stop human chat sessions from expiring between messages Messaging sessions fell back to a hardcoded 300s idle timeout, shorter than a normal pause in a human conversation: the sweeper closed the session and the next message opened a new one, so a person could not hold a continuous chat. Make the idle timeout configurable (session_idle_timeout_seconds, default 3600) and resolve an unset timeout to it at every session-creation path instead of the 300s column fallback. * fix: resolve doubled doc paths and stop the indexer warning flood The doc-path resolver returned absolute paths verbatim, so a documenter path that doubled the base segment (/app/docs/docs/...) never resolved on disk and the docs never indexed into RAG. Reduce an absolute path under the docs base to a relative one before normalizing, leaving truly-external absolute paths for the indexer to skip. The indexer now skips non-markdown source files and logs a missing/non-doc source at debug instead of warning on every pass. * fix: reject project repo URLs that point at a protected repository Add a configurable denylist (protected_git_urls) enforced in the project create and update paths, so a project cannot be registered against a repository that must not receive agent commits or merges (e.g. the roboco source repo during a smoke run). Empty by default (no behavior change); operators set it to sandbox smoke-test projects. * fix: let an agent release a blocked task back to the pool A developer (or QA/doc) trapped on a 'blocked' task had no legal forward move — every verb rejected from that state — so the dispatcher kept respawning it with nothing to do. Allow 'unclaim' to release a blocked task the agent owns back to pending (assignment cleared, work session abandoned, audited), so the cell PM can re-delegate it instead of the agent churning. * fix: keep blocked-dev churn out and cell tasks out of board hands - The dispatcher no longer respawns the owner of a blocked task: from blocked the owner has no legal move, so respawning only churns; it is revived on unblock or released via unclaim. - Escalation no longer hands a cell (backend/frontend/ux_ui) coordination task to a board/advisory role — such an escalation is diverted to the cell pool, matching the existing executable-task guard. main_pm targets are unaffected. * chore: add an opt-in full clean-slate to the reset script FULL_RESET=1 wipes everything under the roboco data root except the persistent service stores (ollama/postgres/redis) and clears the persisted agent Claude session dirs (ROBOCO_CLAUDE_STATE_DIRS), which otherwise replay across runs. Default off — the existing DB/Redis wipe + workspace git-reset is unchanged. * ++ --------- Co-authored-by: Renn F <rennf93@users.noreply.github.com>	2026-06-08 01:59:51 +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
3 people	3205443119	Fix: dependency spawn gate and cell ownership (#73) ... * Cleanup + Missing greenlet error * fix(messaging): persist a group's active-session pointer so posts reuse it create_session and create_session_with_access_check set group.active_session_id from session.id BEFORE the flush that materializes it — the id is a flush-time uuid4 default, so the pointer was written as NULL and every post opened a fresh session, fragmenting one conversation across many. Flush first, then link, the same ordering the seed path already uses. Two tests fabricated "two distinct sessions" by calling create_session twice on one group, which only differed because of this bug; switch them to two groups so they keep testing their real intent. Add a regression guard that the pointer is actually persisted and a second create reuses the live session. * fix(orchestrator): gate spawns on dependencies and keep cell tasks in their cell The cross-task dependency check ran only on the dev dispatch path, so cell-PM, Main-PM and board agents were spawned onto dependency-blocked tasks and flailed unblock / escalate / notify against an unfinished upstream — climbing ownership of cell work up to the board, which cannot drive it, and deadlocking the task. - Move the dependency gate into the shared spawn readiness check so it covers every role, and auto-block the task so it leaves the pending pool until the upstream reaches a terminal state (then the existing auto-unblock revives it). - Cell-ownership invariant: a backend/frontend/ux_ui task may only be worked or owned by its own cell. The readiness gate refuses a board or Main-PM spawn onto a cell task; reassign refuses and clears such an owner; and on dependency-clear a mis-owned cell task is re-homed to its cell's pending pool instead of reviving under an owner that cannot progress it. - A dependency block is never a CEO signal: notify(target=ceo) is refused while the task is waiting on an unfinished upstream, with a remediate to idle and wait — the block clears on its own. * Uploading images + Fixing pyproject.toml * ++ * revert(orchestrator): drop the cell-ownership block pending a tooling audit The cell-ownership invariant added earlier — a board / Main-PM role may never be spawned onto or reassigned to a cell task, plus re-homing a mis-owned cell task on dependency-clear — was too absolute. It forbids a higher role from stepping in when something genuinely deeper is going on, and contradicts the existing rule that main_pm may hold a task at awaiting_pm_review. The dependency spawn gate already prevents the cascade that handed the board cell tasks; the deadlock it guarded against will be addressed with a return-path approach after auditing what tools the cell PMs actually need. Keeps the dependency gate and the CEO dependency-block notify guard. * docs(prompts): a dependency wait is wait-and-idle, not escalate The cell-PM and Main-PM prompts told agents to escalate_up / retry unblock on a blocked task without distinguishing a dependency wait (which auto-clears the moment the upstream completes) from a real wedge — the source of the escalate/unblock flail and the CEO-notification spam. Split the blocked-state guidance: a cross-cell dependency wait = note + i_am_idle (do not escalate, unblock, or notify the CEO); escalate only a genuinely broken upstream. Fix two stale references to i_am_blocked, a developer-only verb the PMs do not have, to escalate_up. Correct the CLAUDE.md verb-surface table, which understated every role: it listed 4 cell_pm verbs while the flow manifest derives the full set (11, including unclaim and i_am_idle) from lifecycle.spec.intents_for_role. * feat(gateway): cell_pm reassign verb — intra-cell developer hand-off A cell PM can now hand a claimed/in_progress task to another developer in its own cell without unclaim (which drops the work back to the pool and loses the assignee). The branch is keyed to the task, so the work-in-progress is preserved; the new dev is respawned to continue. Intra-cell only: the task must be in the caller's cell and new_assignee must be a developer of that same cell. Wired through every layer: the reassign IntentSpec (composes=(), cell_pm-only), the choreographer verb + intra-cell guard, a reaper-safe TaskService.reassign_active_claim (reseeds the claim heartbeat so the new dev is not immediately reaped), the ReassignRequest schema, the cell_pm flow route, and the MCP flow-server tool. Tracing-waived like unclaim (mechanical hand-off). Regenerated lifecycle/verb artifacts; prompt + CLAUDE.md updated. --------- Co-authored-by: Renn F <rennf93@users.noreply.github.com>	2026-06-06 22:10:48 +02:00
3 people	06682f33c6	Fix: agent workflow hardening (#70) ... * fix(gateway): push the branch before QA handoff so reviewers see the latest commits The commit content tool commits locally without pushing; only open_pr pushed the branch. On the first submission that was fine, but a fix committed while addressing needs_revision never reached origin (open_pr is skipped once the PR exists), so QA — which reviews the remote PR branch — re-reviewed the stale remote and re-failed the task on every cycle, a loop that never converged. i_am_done now pushes the task branch (idempotent; a no-op when nothing is unpushed) as part of the shared submit gate, covering both the normal and resume-from-verifying paths. A push failure blocks the handoff with a clear remediation rather than parking the task in awaiting_qa with commits that exist only in the developer's local workspace. * fix(orchestrator): don't reap a stale claim while the agent's container is alive The stale-claim reaper released any claimed/in_progress task whose last_heartbeat_at exceeded the TTL. The heartbeat only updates on certain gateway calls, so a developer deep in a long edit/test cycle outran the TTL and had its claim reaped mid-work — churning the task and risking a double spawn against the still-running container. The reaper now skips a task whose assignee still holds a live (ACTIVE) agent instance, trusting container liveness — the ground truth — over the heartbeat proxy. The check is defensive on missing fields so a heartbeat-only caller (and the reaper's existing unit tests) behave exactly as before. * fix(gateway): refuse to unblock a task while a dependency is unfinished A PM unblock on a dependency-gated task moved it straight to in_progress, overriding the dependency — letting a dependent proceed without its upstream's work (e.g. a frontend task built before its UX design lands). A dependency block is meant to clear on its own via _unblock_dependents the moment the upstream reaches a terminal state. unblock now refuses while any dependency is still non-terminal, returning a clear remediation that the block resolves automatically. Manual unblock remains available for genuine, non-dependency blockers. * fix(gateway): release a dependency-blocked claim to pending instead of looping A task that reached claimed/in_progress with an unfinished dependency was left in that state when the claim guard rejected, so the orchestrator's respawn loop kept reviving its assignee — which could make no progress — burning work for nothing. The claim guard now releases such a task back to pending. claimed -> blocked is not a legal transition, so pending — held by the dispatch dependency filter — is the lifecycle-correct resting state: the respawn loop ignores pending tasks, and _unblock_dependents re-dispatches it once the upstream reaches a terminal state. release_dependency_blocked_claim shares a _force_unclaim_to_pending core with unclaim_for_reaper so both record a truthful work-session abandon reason. * feat(security): warn at startup in header-trust mode + document the auth posture When ROBOCO_AGENT_AUTH_REQUIRED is not enabled the API accepts the X-Agent-Id / X-Agent-Role headers without a signed token, so any client that can reach it may act as any role (including 'ceo'). The API now logs a clear warning at startup in this mode, and the README gains a Security section documenting the auth posture and how to harden it. Acceptable only on a trusted private network — do not expose the API to untrusted networks. * fix(workspace): scope the refresh fetch to current + default branch ensure_workspace's healthy short-circuit ran an all-refs 'git fetch origin' to keep every origin/<branch> ref current. On a monorepo with many accumulated feature/* branches that exceeds the refresh timeout, the fetch silently fails, and the workspace keeps a stale base — so an agent builds on an out-of-date branch. The refresh now fetches only the workspace's current branch and the repo's default branch (resolved via origin/HEAD), with --no-tags --prune: it transfers near-nothing and can't time out. Readers need their own branch and the default; the integration branch is refreshed at branch-creation time. * fix(git): refresh a dependency-blocked task's branch off the current integration tip A cross-cell dependent (e.g. a frontend task waiting on the UX design) was branched off a base captured before its upstream merged into the integration branch, and the branch was never re-synced — so the agent built on a stale snapshot with none of the upstream's work. Two changes close the gap: - release_dependency_blocked_claim now clears branch_name, so the re-claim (after the dependency clears) re-runs branch creation. - create_branch, when the branch is already on disk with no commits of its own, resets it onto the freshly-pulled base — the dependent now builds on the current integration tip. A branch carrying real commits is left untouched, so no work is discarded; the cell->leaf cascade carries the upstream down to the dev branch automatically. * refactor(gateway): drop the sibling-sequence claim guard Sibling sequence no longer gates a claim. Cross-cell ordering is enforced by task dependencies — a cell task that depends on another is held until its upstream reaches a terminal state, a stronger, status-aware gate than the sequence-number check. That check was dormant in practice anyway: every fan-out child carries sequence 0, on which the guard short-circuited. `sequence` stays a sibling-ordering / dispatch-priority field (list_pending ordering and the panel). Removes sibling_sequence_guard and its _earlier_blocking_sibling helper, the now-unused skip_sequence parameter threaded through the claim verbs, and the sibling fetch that fed it. * feat(gateway): sort a cross-cell dependent after its upstream When the frontend cell task is wired to depend on its UX/UI sibling, set its sequence to the upstream's sequence + 1 so it sorts after the design it waits on — list_pending ordering and the panel now show UX ahead of the implementation it gates, in either delegation order. Adds TaskService.set_sequence (the sibling-ordering field is a service write; it carries no claim-gating semantics — dependencies gate claims). * feat(gateway): make the backend cell depend on UX too UX/UI design defines the screens and API contracts both implementation cells build against, so the backend cell — not just the frontend — waits on the UX/UI cell task in a product fan-out and sorts after it. Wires in either delegation order: a backend task delegated after UX gets the dependency directly; a UX task delegated after a still-pending backend sibling retro-wires it. Mirrors the existing frontend wiring (_depend_backend_on_ux and _depend_pending_backends_on_ux). Backend is held by the same dependency gate, so it costs no extra dispatch churn. * fix(websocket): forward notification acks instead of logging them incomplete The bridge handler serves both notification.sent and notification.acked, but acked events carry `agent_id` (the acking agent) rather than `recipient_id`, so every acknowledgement tripped the missing-field guard and logged "Incomplete notification event" instead of reaching the panel. Accept either field as the recipient. * feat(api): hint the full UUID when a truncated task id fails validation Agents copy the 8-character task prefix the system shows them (the commit prefix, task summaries) and send it as task_id, which fails UUID validation with an opaque "invalid length" 422 and wastes a call. The request-validation handler now detects a task_id UUID error and attaches a `remediate` hint telling the agent to retry with the full 36-character UUID from its task envelope. * fix(audit): record the blocked transition when a task is escalated Escalation sets a task to blocked by writing task.status directly, which bypassed the validated transition helper and so never emitted a task.blocked audit row — the lifecycle moved but the Auditor saw nothing. Extract the audit emit from the central transition helper into _emit_status_transition_audit and call it from the escalate path, capturing the prior status and outgoing owner before reassignment so the row is attributed correctly. * fix(docs): stop doubling the docs path so design specs index into RAG The documenter sometimes hands a doc path already rooted at docs/, and joining it onto DOCS_BASE_PATH (/app/docs) produced /app/docs/docs/..., so the file was never found and the spec never indexed — the frontend cell could not retrieve the UX design over RAG. Normalize the path before joining: trust an absolute path, otherwise strip a single redundant leading docs/ segment. * feat(security): let the control panel authenticate in secure mode With ROBOCO_AGENT_AUTH_REQUIRED=true every request must carry a valid HMAC token, which locked the human control panel out — it sends role headers but no token. nginx, the only trusted hop between the browser and the API, now injects the CEO token on /api and /ws, so the browser never holds the signing secret. The injected value is just the existing per-agent token issued for the CEO identity (issue_panel_token), so the token-verification path is unchanged. An empty value (dev/header-trust mode) renders to no header. `make panel-token` prints the value; set it as ROBOCO_PANEL_AGENT_TOKEN in .env before enabling secure mode. .env.example and the README Security section document the flow. * chore(compose): consolidate the two compose files into one docker-compose.yml and docker-compose.yaml had diverged: .yml — the file Docker actually uses — carried ROBOCO_PUBLIC_BASE_URL but was missing the /app/manifests bind-mount, while .yaml had the manifests mount but not the base URL. Merge the union into docker-compose.yml and delete the duplicate so there is one source of truth and no "multiple config files" warning. This activates the manifests mount in the deployed file: without it the orchestrator writes per-agent tool manifests to its ephemeral container fs, they never reach the host for the daemon to bind-mount, and agents fall back to all-verbs registration. Drop the stale .yaml reference from the config.py docstring, the labeler, and the CI path filters. --------- Co-authored-by: Renn F <rennf93@users.noreply.github.com>	2026-06-05 16:35:22 +02:00
Renn F	2db9741ff6	fix(messaging): reuse a group's live session instead of recreating per open ... create_session and create_session_with_access_check closed the group's active session and opened a new one on every call. A group is meant to have ONE live session (groups.active_session_id) that all participants post into, so this churned a single conversation across many sessions — the smoke run showed ~one session per message, and the CEO could not hold a conversation in a channel. Both now reuse the live session when one is active and only open a fresh one when none is (closed via timeout / boundary / merge), matching the existing get_or_create_active_session contract.	2026-06-04 06:42:21 +02:00
Renn F	2ee610f6cf	feat(git): resolve a coordination root's repo from its product ... Branch->project resolution (_project_slug_for_branch, _workspace_for_branch) read task.project_id, which is null for a coordination root — so root-level git ops (the root->master PR, the CEO merge) could not resolve a workspace. A new _project_for_task falls through to the product's first distinct repo (monorepo => the single repo) when project_id is null. Purely additive: a task with a project_id resolves exactly as before; only the previously- unresolvable root case changes.	2026-06-04 06:22:01 +02:00
Renn F	d47adfe027	fix(gateway): rejection envelopes always carry a human-readable message ... tracing_gap and incomplete_input rejections set missing and remediate but left message null. The audit log records message (not remediate) and agents keyed on message, so a rejected agent saw a null reason and retried the same verb until it burned out instead of reading remediate and self-correcting. Both builders (and from_decision) now derive a non-null message that folds the missing tokens and the actionable remediate into one line, so the agent and the audit trail always see what was missing and how to fix it.	2026-06-04 06:01:06 +02:00
Renn F	3cfac2e503	feat(git): forbid the agent merge path from merging into master ... pr_merge (the gateway path a cell PM uses to merge a leaf/cell PR up the hierarchy) accepted any target, including a repo's default branch — the hole that let cell completion land on master. It now refuses any target equal to the project's default branch with a CEO_ONLY error: a root→master PR is merged solely by the CEO via approve-&-merge (merge_pr_for_task, already CEO-gated from awaiting_ceo_approval). Agents open the master PR and escalate; they never merge it. Belt-and-suspenders to the integration-branch routing: even if a target ever resolved to master, this blocks the merge at the GitHub-API boundary.	2026-06-04 05:55:03 +02:00
3 people	6cce556536	feat(git): coordination root cuts a Main-PM integration branch per repo (#58) ... The coordination/fan-out root carries a product (cell->repo map) but no project of its own, and was forced branchless — so a cell's parent-branch resolution fell back to the project default (master), and cell completion merged each cell straight to master, bypassing the Main-PM integration point and the CEO merge gate. Per the locked branch model (master <- feature/main_pm/{root} <- cell <- dev), the root is now the Main-PM integration point: on claim it cuts feature/main_pm/{root} off master in EACH distinct repo the product spans (monorepo => 1, multi-repo => N). Cells then branch off it via the existing ancestor-branch resolution, so cell work never targets master. - ProductService.distinct_project_ids: enumerate the repos a product spans - TaskService._create_branch_in_project: project-parameterized branch creation split out of _auto_create_branch - TaskService._ensure_coordination_root_branches: cut the integration branch in each repo; graceful empty when the product has no cell map yet - _ensure_branch_for_task routes a product-backed root here, not to no-op Co-authored-by: Renn F <rennf93@users.noreply.github.com>	2026-06-04 05:48:21 +02:00
Renn F	bbe9ac7c23	test: unblock-resume tests need a claimed task (branch_name) ... The lifecycle fix routes a never-claimed (no-branch) blocked task to pending on unblock; these two tests asserted in_progress on a no-branch task. Give them a branch so they exercise the claimed-task resume path they intend (no-branch -> pending is covered by new unit tests).	2026-06-04 02:41:19 +02:00
Renn F	0dc772a97f	style: hoist test import to module top (PLC0415)	2026-06-04 02:27:12 +02:00
Renn F	48d6e99fa4	style: ruff-format the branch-idempotency test	2026-06-04 02:25:32 +02:00
Renn F	555c33ad7d	fix(gateway): let a dependent agent read its dependency via evidence ... evidence is read-only, but the cross-agent ownership gate blocked a caller from inspecting a task its own work depends on (a frontend cell could not read the UX task it was waiting on). Exempt reads where the target is a dependency of a task assigned to the caller. Also dropped stale internal refs from the docstring.	2026-06-04 02:12:45 +02:00
Renn F	16982ce887	fix(git): idempotent branch creation — checkout existing branch instead of failing 128 ... A prior claim attempt can create the branch on disk before the DB records branch_name (the claim rolls its fields back, but the on-disk branch persists). A plain checkout -b then fails 'already exists' (exit 128), and the resulting error-handling cascade is how branch creation spiraled into INTERNAL_ERROR. Fall back to checkout <branch> when checkout -b returns non-zero.	2026-06-04 02:08:36 +02:00
Renn F	2631f2647c	fix(lifecycle): unblock a never-claimed task to pending, not branchless in_progress ... A task blocked before it was ever claimed (a dependency-gated claim that got escalated) has no branch. Legacy unblock() forced in_progress, which the dispatcher refuses (state=in_progress but branch_name unset) -> a spawn-refused loop. Add the blocked->pending transition and route no-branch tasks there so they are freshly claimed (the claim gate then holds them cleanly while the dependency is unmet). Branched tasks still resume in_progress. Artifacts regenerated.	2026-06-04 02:01:09 +02:00
Renn F	6d1b56b5b0	revert(briefing): drop the verb->MCP-server map from the agent briefing ... The map told agents to hand-construct mcp__<server>__<verb> tool names, which do not match what their runtime exposes — agents fumbled (No such tool available: mcp__roboco-do__evidence) and had to retry the bare verb. It also did not reduce the opening-move fumbling it targeted; agents recover via the gateway's own remediate hints regardless. Net-negative. Reverts 3d04943 and its follow-up 5462fe3.	2026-06-04 01:51:26 +02:00
Renn F	4374cdbf63	fix(workspace): chown the working tree (pruning node_modules), not just .git ... The .git-only walk left the working tree root-owned, so agents (uid 1000) could not write any file — every mkdir/open/commit failed with EACCES and the run died. Walk the whole workspace, chowning the root + tracked files + .git, while pruning the heavy gitignored trees (node_modules/.venv/dist/...) that made the full walk slow. Verified on the host: uid-1000 write succeeds after.	2026-06-04 00:38:42 +02:00
Renn F	d88a8df9f4	test: drop dead MAIN_PM delete that broke lifecycle isolation across test files	2026-06-03 22:06:32 +02:00
Renn F	3f1904825f	fix(gateway): hold pre-assigned dev at give_me_work's list_assigned fallback when deps are unmet	2026-06-03 21:13:09 +02:00
Renn F	49fddd1dc1	fix(project): default_branch defaults to master across the API create path ... The request and service models defaulted default_branch to "main" and the response converters fell back to "main", so omitting the field on the create route persisted "main" instead of the DB column default of master. Flip every default_branch default and fallback to master.	2026-06-03 20:42:15 +02:00
Renn F	b0a596ecac	fix(deps): gate the pre-assigned dev path on unmet dependencies ... A dev subtask is always pre-assigned (assigned_to=<dev>), so it never flows through the unassigned claim pool's dependency filter (list_pending(filter_by_dependencies=True)). Every path that acts on a pre-assigned pending dev subtask previously ignored dependency_ids: the orchestrator spawned the dev container, give_me_work offered the task, and the claim verb accepted it — letting a frontend dev code ahead of an unfinished UX/UI design. Hold the pre-assigned dev at each path it actually arrives by, until every dependency reaches a terminal state: - orchestrator _validate_task_for_spawn now consults dependency_ids via _check_dependencies_terminal and skips the spawn while any dependency is non-terminal (fail-closed on an unreadable dependency); - TaskService.list_pending_for_agent excludes a pre-assigned task with unmet dependencies so give_me_work does not offer it; - the Choreographer claim guard set rejects the claim with a clear remediate via a new unmet_dependency_guard. Add TaskService.unmet_dependency_ids as the single source of truth for "which dependency IDs are not yet terminal" and route the existing inherit_unmet_dependencies through it.	2026-06-03 20:36:35 +02:00
Renn F	5462fe3ae6	fix(briefing): developer claim precondition is note(scope='note'), not 'decision' ... The generated session briefing told every role with i_will_work_on that note(scope='decision') is required before claiming. That is wrong: the i_will_work_on gate is journal:note_at_claim, satisfied by has_note_for_task, which queries JournalEntryType.GENERAL. Only scope='note' maps to GENERAL; scope='decision' maps to DECISION_LOG and is the PM's i_will_plan gate. Emit scope='note' on the dev-claim branch and keep scope='decision' on the i_will_plan branch.	2026-06-03 20:18:47 +02:00
Renn F	1d2e22b586	test(board): drive the board-review CEO gate over a real spawn->active->idle->tick timeline ... The existing gate test mocks both board reviewers as already-idle, so it never exercises the spawn -> active -> exit -> idle -> next-tick transition — the boundary the gate actually guards. Add a real-DB integration test that seeds a board/coordination task plus the agents the handoff resolves against, dispatches both reviewers through the real handler (the spawn stub leaves each ACTIVE in _instances exactly as a real container spawn does), asserts board_review_complete stays False while either reviewer is active, then marks both idle and runs the next tick to assert the flag flips True and the formal CEO approval notification is persisted.	2026-06-03 19:48:10 +02:00
Renn F	45836b4d6e	fix(gateway): docs/optimal RBAC denials return Envelope with remediate ... The docs and knowledge-base HTTP routes enforced authorization inline and raised raw HTTPException(403) with no recovery hint, so agents received remediate=null and an un-actionable error, and the optimal route held the RBAC decision itself (a layer-separation violation). Move the knowledge-base authorization decision into a gateway module (services/gateway/kb_authz) that returns an Envelope.not_authorized with a non-null remediate naming the roles allowed to perform the action. The docs RBAC already lives in DocsService; render its UnauthorizedError through the same gateway helper. Both route groups now return the Envelope wire-dict at top level (HTTP 403) instead of a bare detail string, keeping the routes thin (HTTP translation only). Permitted callers are unaffected.	2026-06-03 19:41:10 +02:00
Renn F	16c425799c	fix(gateway): dev subtask inherits the cell task's unmet cross-cell dependency ... A frontend cell task waits on the UX/UI design, but a dev/code subtask delegated under it did not inherit the unresolved dependency, so the developer became dispatchable and coded ahead of the design. Propagate the parent cell task's still-unresolved dependencies onto the new subtask on delegate, reusing the existing dependency model: the subtask is held by list_pending(filter_by_dependencies=True) until the UX task is terminal.	2026-06-03 19:28:56 +02:00
Renn F	7c91a85e7e	fix(project): include default_branch in project list summary response	2026-06-03 19:20:54 +02:00
Renn F	5afe87716c	fix(git): default branch convention main -> master	2026-06-03 19:18:42 +02:00
Renn F	2bb83c96a3	fix(docs): grant head_marketing read-only documentation access ... The spawn manifest mounts the roboco-docs MCP for head_marketing, but the service READ_ROLES omitted the role, so list/read 403'd against a tool the agent was handed. Add head_marketing to READ_ROLES so the manifest and permissions agree (read-only; not added to WRITE_ROLES).	2026-06-03 19:13:17 +02:00
Renn F	5184d08287	fix(messaging): thread say() by task_id into one per-channel group and enforce channel access first	2026-06-03 19:08:59 +02:00
Renn F	3d04943bf3	feat(orchestrator): embed verb->MCP-server map + key preconditions in agent briefing ... Agents fumble their first move — raw bash/http/shell-git, calling evidence on roboco-flow when it lives on roboco-do, omitting the nature argument on delegate, or skipping the required journal note before claiming. The role docs cover this but agents cannot read them at spawn. Generate a concise, role-accurate block from the role's actual manifest (get_role_config): a verb->server map (roboco-flow / roboco-do / roboco-git-readonly / roboco-optimal / roboco-docs) plus key preconditions (note(scope='decision') before i_will_work_on / i_will_plan; delegate requires nature; evidence is on roboco-do; never use raw bash/http/shell-git). Embed it into the written session briefing.	2026-06-03 19:03:22 +02:00
Renn F	b18bdcd41a	fix(optimal): serialize singleton init, normalize kb_search index_types, surface mentor errors ... The OptimalService singleton published the instance before initialize() finished, so a concurrent caller could observe _initialized=False and hit "OptimalService not initialized" during RAG indexing. Build the instance, initialize it, then publish under a lazily-bound asyncio lock so all callers share a fully-initialized singleton. roboco_kb_search forwarded the legacy alias index_types=['docs'], which is not a valid IndexType value (the enum value is 'documentation'), producing a 400 at the route. Normalize the alias in the client before the request is sent and fix the misleading tool docstring. The mentor route let exceptions from mentor.ask escape as a bare 500 that masked the real cause. Catch, log the true upstream error with stack, and surface it in the response detail so failures are diagnosable.	2026-06-03 18:54:07 +02:00
Renn F	2c96bd09f6	fix(gateway): heartbeat on content-write success, single-claimant gate, progress soft-warn ... commit()/progress()/note() now refresh last_heartbeat_at on the success path (best-effort, suppressed), not only on rejection — an actively writing agent no longer looks idle to the reaper between verb successes. commit()/progress() verify the caller holds the active claim (active_claimant_id), not merely the historical assigned_to, so a reaped or handed-off assignee can no longer write onto a freed task; a non-holder gets a not_authorized envelope with a clear remediate. progress() with no plan_step on a task that has steps is accepted (product decision for narrative mid-step updates) and logs a soft warning instead of rejecting.	2026-06-03 18:44:33 +02:00
Renn F	61e80495c3	fix(workspace): scope _ensure_agent_owned walk to .git subtree only ... Walking the entire workspace (incl node_modules) to chown+chmod every entry cost 2.7-15.5s per git op. The agent only needs write ownership on .git/ during git ops; working-tree files don't need chowning. Restrict the walk to .git, and no-op when .git is absent.	2026-06-03 18:34:31 +02:00
Renn F	e1c3f926f2	fix(orchestrator): a cell code task never routes to board / main_pm by keyword ... A code task whose title/description hit a board keyword (launch, release, architecture, security) was classified to 'board' — so a cell dev code task got 'reviewed' by the Product Owner + Head of Marketing — and a high-complexity cell code task was escalated to 'main_pm', which is how a PM ended up owning (and deadlocking) a dev code task. A code task that belongs to a cell (backend/frontend/ux_ui) is implementation work: route it WITHIN the cell (cell_pm for high/pm-keyword, else dev), never to board/main_pm. The strategic board/cross-cell heuristics now apply only to team-less top-level tasks.	2026-06-03 16:01:03 +02:00
Renn F	5f61ea7b82	test: fix stale activate-guard test + time-fragile grace-window test ... - The activate test asserted the old 'no project set' guard; activate now needs a project OR a product (coordination tasks carry only a product), so it raises only when BOTH are absent. Renamed, set product_id=None, and match the current 'no project or product' message. - The grace-window test used a module-load _FRESH timestamp, but the grace check uses wall-clock now(), so _FRESH aged out of the window during a long full-suite run and flaked. Compute 'fresh' at test time.	2026-06-03 08:46:50 +02:00
Renn F	93c46d86e7	fix(logging): host-side log fallback writes to ./data/logs, not a duplicate ./logs ... _resolve_log_dir fell back to ./logs (relative to CWD) whenever /data was absent — i.e. every host-side run (pytest, scripts, the dev orchestrator). The container writes to /data/logs, whose host side is the compose mount ${ROBOCO_DATA_DIR:-./data}/logs, so ./logs and ./data/logs were two different directories. Point the host-side fallback at that same ${ROBOCO_DATA_DIR:-./data}/logs, eliminating the duplicate ./logs at the repo root.	2026-06-03 08:36:45 +02:00
Renn F	4c59bfa840	fix(prompt): Main PM delegate description is a goal+constraints brief, not a solution-dump ... delegate already requires substantive acceptance_criteria (TASK_AT_CREATE completeness), so the defect was not missing criteria — it was the Main PM writing the cell-PM subtask description as prescriptive prose that dictates the cell's solution (e.g. a full UX layout for a design task), doing the cell's job and wasting the expertise it delegated to. The role doc now tells the Main PM the description is a brief: state the goal + the constraints to fit, leave the HOW to the cell, and for design tasks give the problem, not a mockup.	2026-06-03 08:32:51 +02:00
Renn F	a5af6159d7	fix(gateway): evidence surfaces the task's board/PM handoff journal entries ... journal_highlights_for_task was a Phase-1 stub returning [], so evidence() never surfaced the upstream Product Owner / Head of Marketing review. The Main PM picked up a board-reviewed coordination task, saw no handoff, and re-researched from scratch (duplicated work). Query the task's decision/reflection/note entries across authors (slug + role), oldest first, so the Main PM builds on the board's analysis instead of redoing it.	2026-06-03 08:27:10 +02:00
Renn F	ceb4eec6ca	feat(board): gate CEO Approve & Start on board-review completion ... A board/coordination task stays pending throughout board review — that pending state is what hands it to Main PM on approval — so the CEO's Approve & Start button was live from the instant the task was created, before the Product Owner and Head of Marketing had reviewed anything. That let the CEO approve before the board finished. Persist a board_review_complete flag the orchestrator sets once BOTH board reviewers are done, and gate the button on it (the task stays pending). The same handoff emits the formal CEO notification, so the CEO gets an actionable signal instead of buried channel chatter. - alembic 021: add tasks.board_review_complete (default false) - TaskService.mark_board_review_complete: set the flag without leaving pending - orchestrator: flag the task + notify CEO once both reviewers go idle - panel: Approve & Start requires board_review_complete	2026-06-03 08:06:41 +02:00