External/roboco
1
0
Fork 0
mirror of https://github.com/rennf93/roboco.git synced 2026-08-03 07:23:24 +02:00
Code Issues Packages Projects Releases Wiki Activity

Retire channels/sessions/messages; A2A becomes primary agent comms (#306)

Browse Source 
* feat(a2a): deliver latest incoming message preview into the claim briefing

list_unread_a2a now carries last_message_preview (the latest message from the
OTHER agent, never the agent's own reply), fetched via a correlated subquery in
the same query — no N+1 on the per-verb briefing path.

* feat(a2a): read_a2a verb delivers unread message bodies to the agent

A2AService.get_unread_messages returns the caller's unread INCOMING messages
(never its own sends), marking exactly those rows read atomically so a message
arriving mid-call is preserved. Wired as the read_a2a content verb (route +
do_server tool + granted to every delivery role) — the content-bearing read the
A2A inbox lacked (read_messages only zeroed the counter).

* docs(rag): document read_a2a as the A2A content-read path

* fix(task): backlog activation no longer requires a discussion session

Removes the SessionTaskTable gate in activate() (and its dangling log field),
deletes _inherit_parent_session + its create() call, and drops the now-unused
SessionTaskTable import. Coordination rides task state; the session subsystem is
being retired. Tests updated to the new (no-session) behavior.

* fix(orchestrator): drop session sweep from _run_sweep

Removes the messaging import + sweep_timed_out_sessions call. That import sat
outside the try/except, so once messaging.py is deleted it would have killed the
entire sweep cascade (budget kill-switch, token rollups, retention, image prune,
superseded-PR reconcile). Notification sweep + all maintenance sweeps unchanged.

* release-manager --no-tags read-clone fix

* test: update evidence_repo unit test for a2a last_message_preview

* refactor(gateway): drop session propagation on delegate

Removes propagate_sessions_to_subtask from delegate(), the ChoreographerDeps
messaging field + property, and the ChoreographerDeps messaging arg in deps.py
(ContentActions messaging + import stay until the verbs are removed). Deletes the
propagation test; strips the now-invalid messaging kwarg from ChoreographerDeps
test builders.

* refactor(gateway): remove say/open_session/link_session/channels verbs

Removes the four channel/session verbs across content_actions (impls +
ContentActionsDeps.messaging), do_server (tools + registry), role_config (grants
+ _CHANNEL_DISCOVERY), do.py (routes), schemas/v1/do.py (request models), and
deps.py (MessagingService import + construction). Regenerates the prompt verb
tables. dm/notify/read_messages/read_a2a stay. Tests deleted/updated accordingly.

* uv.lock Upgrade

* refactor: remove conversation RAG indexing; Secretary announces via notification

Drops the CONVERSATIONS index (index_conversation, ConversationsIndexPlugin,
IndexType.CONVERSATIONS enum, IndexConversationParams, mentor.py type-label, the
messaging index hook) and its chunk-table manifest entries. The Secretary's
ANNOUNCE/RELAY_MESSAGE now fan out a BROADCAST notification to every agent's
inbox (NotificationService.broadcast) instead of posting to a dead channel.

* fix(panel): label RAG health error lines by subsystem

A red llm_error (e.g. the glm-5.2:cloud weekly-limit 429) rendered under
the 'Embedding: ok' header with no label, reading as an embedding failure.
Prefix each error line with LLM / Embedding / Vector store.

* refactor: remove channel/message reads from metrics, dashboard, git, events

MetricsService drops get_communication_volume + the MessageTable
message-count in get_agent_metrics (and the now-dead messages_sent_week
field). DashboardService drops get_channel_feeds/_compute_channel_status
and the message read in get_recent_activity (task activity kept);
get_auditor_metrics no longer reports communication_volume.
GitService's two primary-session-id helpers always return None now
(callers already treat None as "no primary session"). events/handlers.py
drops the SESSION_CLOSED/SESSION_TIMEOUT subscriptions + the
handle_session_boundary handler.

Forced follow-on: api/routes/dashboard.py + api/schemas/dashboard.py
dropped the now-dangling live_feeds/ChannelFeed surface and the
/metrics/communication route, which wrapped the removed service calls
directly (mypy would otherwise fail on the missing attributes).

* refactor: delete MessagingService + channel seeding

Edited db/__init__.py and services/__init__.py first (drop the unconditional
Channel/Group/Message/Session table + MessagingService re-exports), then
deleted services/messaging.py, then trimmed db/seed.py to only create_agents
(create_channels/create_channel_memberships/create_initial_messages gone).

Forced expansion: api/routes/{channels,groups,sessions,messages}.py import
roboco.services.messaging directly (not through the package __init__), as
does api/routes/tasks.py (the session-links embed on GET /tasks/{id} and the
GET /{id}/sessions route). Deleting messaging.py without addressing these
breaks `import roboco.api.app` immediately, since app.py eagerly imports all
route modules at startup. Since the 4 CRUD route files are 100%
MessagingService-backed with zero independent logic (and are wholesale
deletes in the plan's later API-routes task anyway), deleted them now +
unmounted from app.py/routes/__init__.py; tasks.py got the same surgical
trim its later task already specified (drop session-links embed +
TaskSessionLinkResponse/TaskResponse.sessions). This pulls a slice of that
later work forward — the routes/schemas for channels/groups/sessions/messages
still need their own pass, but their messaging-coupled parts are gone.

Verified with a full-suite collection sweep (12010 tests collected, zero
import errors) beyond the directly touched test dirs, given the expanded
blast radius.

* refactor: remove channel/session/message models, tables, and channel policy

Models: deleted channel.py/group.py/session.py/messaging.py wholesale
(zero external consumers besides the models/__init__.py re-export).
message.py surgically trimmed: removed MessageCreate (dead) and MessageEdit
(never instantiated; ExtractedMessage.edit_history retyped to
list[dict[str, Any]] to match how it's actually persisted — confirmed
ExtractedMessage was never written to any DB table, so MessageTable's
removal carries no functional risk to the kept extraction pipeline).
base.py: removed SessionStatus + ChannelType, kept MessageType. Also
removed the confirmed-dead channels_read/channels_write fields from
models/agent.py:AgentPermissions and models/dashboard.py:ChannelFeedData.

db/tables.py: deleted ChannelTable/GroupTable/SessionTable/SessionTaskTable/
MessageTable, TaskTable.session_links, and JournalEntryTable.session_id —
cascaded through models/journal.py, services/journal.py, and
api/schemas+routes/journals.py (22 plumbing sites).

foundation/policy/communications.py: removed the ChannelSpec/CHANNELS
catalog + TEAM_SCOPED_ROLES/_CELL_*/_AUDITOR_ONLY helpers, kept the
notification policy (Priority/parse_priority/NOTIFY_SENDER_ROLES/
ACK_REQUIRED_BY_TYPE). enforcement/channel_access.py deleted (confirmed
fully dead in production). agents_config.py: removed CHANNEL_ACCESS
(kept A2A_ALLOWED_PAIRS). seeds/initial_data.py: removed
DEFAULT_CHANNELS/CHANNEL_MEMBERSHIPS/AUDITOR_SILENT_ACCESS + the
never-consumed INITIAL_MESSAGES. config.py: removed
session_idle_timeout_seconds (zero consumers). exceptions.py: removed
dead ChannelError/ChannelAccessDeniedError/SessionClosedError.

Forced expansion beyond the original file list — ChannelType cascaded
into a live, mounted surface the plan didn't trace: agents_config.
CHANNEL_ACCESS -> services/permissions.py's channel-RBAC methods (not
models/permissions.py, which turned out to have no channel code at all)
-> two real endpoints in api/routes/stream.py (GET /permissions,
GET /permissions/channel/{name}) and two dependency factories in
api/deps.py. Removed the channel methods + fields, deleted the
channel-specific stream.py endpoint, deleted require_channel_read/write.
Also deleted api/schemas/{channels,sessions}.py (hard dependency on the
removed enums; already fully dead after the Task 10 route deletions) and
api/schemas/messages.py (a TYPE_CHECKING-only import of the deleted
MessageTable; likewise already fully dead) + its dedicated test file.

Test updates: test_permissions.py -14 channel tests (matches the planned
count exactly), test_communications.py / test_communications_consumers.py
split to keep only notification-policy coverage, test_exceptions.py -9,
test_deps.py -4, plus the journal/stream/foundation-smoke fallout. Also
fixed a pre-existing (Task 7) broken assertion in
test_foundation_phase3_smoke.py that inspected a `say()` method already
removed from ContentActions.

Verified: full-suite collection (11961 tests, zero import errors) and a
complete test run (11567 passed, 394 skipped, 0 failed) in addition to
the targeted suites.

* migration: drop channels/groups/sessions/session_tasks/messages + enum types

alembic/versions/060_drop_messaging.py: drop_column journal_entries.
session_id (sidesteps hardcoding the FK constraint name — verified
empirically against a live migrated DB that it's actually
fk_journal_entries_session_id_sessions, but drop_column doesn't care
either way); drop_table in FK order (messages -> session_tasks ->
sessions -> groups -> channels); DROP TABLE IF EXISTS chunks_conversations
(runtime-provisioned, not alembic-managed, would otherwise orphan); DROP
TYPE IF EXISTS for messagetype/sessionstatus/sessionscope/channeltype
(messagetype's Python enum stays for ExtractedMessage, but the DB type
had zero live columns left once MessageTable was dropped in the prior
commit). downgrade() raises NotImplementedError — one-way removal.

Pruned scripts/reset_runtime_state.sql + .sh: removed the DELETE/COUNT
lines for messages/session_tasks/sessions/groups/channels and the
groups.active_session_id reset block.

Verified end-to-end against a scratch Postgres DB: full migration chain
001->060 applies cleanly, alembic heads shows a single head, all 6 dropped
tables + 4 enum types + the journal_entries.session_id column are
confirmed gone, journal_entries keeps only its journal_id/task_id FKs,
downgrade correctly raises NotImplementedError without corrupting DB
state, and the pruned reset_runtime_state.sql runs clean (no errors)
against a fully-migrated DB.

* refactor(api): remove channel/session/message routes + WS streams

Most of this task's file list was already forced through in earlier
commits (routes/{channels,groups,sessions,messages}.py + app.py/__init__.py
unmounting in the MessagingService-deletion commit; tasks.py's
session-links embed + GET /{id}/sessions + schemas/tasks.py's
TaskResponse.sessions in that same commit; deps.py's require_channel_read/
write + schemas/{channels,sessions}.py in the models/tables commit). This
closes out what was left:

- api/websocket.py: deleted the channel_stream + session_stream routes,
  ConnectionManager's channel_connections/session_connections dicts,
  connect_channel/connect_session, broadcast_to_channel/broadcast_to_session,
  get_channel_subscriber_count, and their cleanup lines in disconnect().
  Agent streams, notification streams, and the operator system stream are
  untouched.
- api/websocket_bridge.py: deleted _handle_session_event +
  _handle_message_event and their SESSION_CREATED/SESSION_CLOSED/
  SESSION_TIMEOUT/MESSAGE_SENT subscriptions. The A2A live-view, rate-limit,
  usage, agent-lifecycle, and notification bridges are untouched.
- api/schemas/websocket.py: removed NewMessageBroadcast, WSMessageNew,
  WSMessageEdit, WSMessageDelete, WSSessionClosed — kept the WSMessage base
  class (still subclassed by the kept WSAgentStream/WSNotification) plus
  those two.
- api/schemas/groups.py: deleted (already fully orphaned since routes/
  groups.py was removed; its GroupResponse/GroupDetailResponse had zero
  consumers).

Updated the 5 websocket test files accordingly (removed the channel/
session-specific tests + fixed imports); test_websocket_bridge.py's
registration-coverage test dropped the SESSION_*/MESSAGE_SENT assertions.

Verified: full-suite collection (11943 tests, zero import errors) and a
complete test run (11549 passed, 394 skipped, 0 failed).

* docs: retire channels/sessions/messages from agent-facing docs + CLAUDE.md

Rewrites docs/rag (RAG-indexed) + docs/map + CLAUDE.md to reflect A2A (dm +
read_a2a) as primary agent comms; deletes the channel docs, splits messaging-tools
+ messaging-notification (renamed notification.md), swaps the WS worked example to
A2A_MESSAGE_SENT. _complete_map.md still needs regeneration (generated file).

* refactor(panel): remove Communications surface (channels/sessions)

Deletes the /communications routes, message components, task-detail Sessions tab,
use-channels + channel/session WS hooks, and the channels/sessions/messages/groups
api clients; prunes the Channel/Session/Message/Group types + mock data. (Auditor
live-feeds + dashboard.ts dead-route cleanup is a follow-up.)

* refactor(panel): drop auditor channel-feed + dead communication-metric route

* docs(map): regenerate _complete_map from updated slices

* fix(a2a): reduce get_unread_messages complexity below xenon C + stale comments

Extract the per-conversation unread-counter recompute into _reset_unread_counter
(the CI quality gate flagged get_unread_messages as rank C). Also drop the deleted
open_session from a content_actions comment and reword an evidence_repo docstring
that cited the removed messaging._notify_mentions.

---------

Co-authored-by: Renn F <rennf93@users.noreply.github.com>
This commit is contained in:
Renzo F
2026-07-04 03:10:33 +02:00
committed by GitHub
co-authored by Renn F
parent a807904999
commit 7901ea419e
249 changed files with 2101 additions and 19303 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/unit/gateway/test_auditor_silent_guard.py
+5 -67
View File
@@ -1,11 +1,10 @@
"""Auditor is silent — runtime guard refuses say()/dm().
"""Auditor is silent — runtime guard refuses dm().
Spec §5.5: the auditor is a silent observer. The spawn manifest already
omits `say` and `dm` from the auditor's tool surface, but that is a
convention-only defense. These tests pin a defense-in-depth runtime guard
inside ContentActions.say/dm: if the caller's role is "auditor", the
verb refuses with Envelope.not_authorized regardless of how the call
arrived.
omits `dm` from the auditor's tool surface, but that is a convention-only
defense. These tests pin a defense-in-depth runtime guard inside
ContentActions.dm: if the caller's role is "auditor", the verb refuses with
Envelope.not_authorized regardless of how the call arrived.
"""
from __future__ import annotations
@@ -30,7 +29,6 @@ def _make_deps(agent_role: str, **overrides: AsyncMock) -> ContentActionsDeps:
task.agent_for.return_value = MagicMock(role=agent_role)
git = overrides.get("git", AsyncMock())
messaging = overrides.get("messaging", AsyncMock())
a2a = overrides.get("a2a", AsyncMock())
journal = overrides.get("journal", AsyncMock())
workspace = overrides.get("workspace", AsyncMock())
@@ -38,7 +36,6 @@ def _make_deps(agent_role: str, **overrides: AsyncMock) -> ContentActionsDeps:
return ContentActionsDeps(
task=task,
git=git,
messaging=messaging,
a2a=a2a,
journal=journal,
workspace=workspace,
@@ -46,24 +43,6 @@ def _make_deps(agent_role: str, **overrides: AsyncMock) -> ContentActionsDeps:
)
@pytest.mark.asyncio
async def test_auditor_say_returns_not_authorized() -> None:
"""Auditor role calling say() is refused regardless of manifest."""
auditor_id = uuid4()
deps = _make_deps("auditor")
actions = ContentActions(deps)
env = await actions.say(agent_id=auditor_id, channel="backend-cell", text="hi")
body = env.as_dict()
assert body["error"] == "not_authorized"
haystack = (body.get("message") or "") + " " + (body.get("remediate") or "")
assert "silent" in haystack.lower() or "auditor" in haystack.lower()
# The messaging service must not have been touched — the guard fires
# before any downstream call.
deps.messaging.post_to_channel.assert_not_called()
@pytest.mark.asyncio
async def test_auditor_dm_returns_not_authorized() -> None:
"""Auditor role calling dm() is refused regardless of manifest."""
@@ -85,27 +64,6 @@ async def test_auditor_dm_returns_not_authorized() -> None:
deps.a2a.send.assert_not_called()
@pytest.mark.asyncio
async def test_developer_say_passes_auditor_guard() -> None:
"""Non-auditor roles are not blocked by the new guard.
The messaging mock returns None so downstream flow is whatever the
happy path is — we only assert that the auditor guard didn't fire
(i.e. the response is not the auditor-silent not_authorized envelope).
"""
dev_id = uuid4()
deps = _make_deps("developer")
actions = ContentActions(deps)
env = await actions.say(agent_id=dev_id, channel="backend-cell", text="hi")
body = env.as_dict()
# The auditor-silent message is what we explicitly want to NOT see.
if body.get("error") == "not_authorized":
haystack = (body.get("message") or "") + " " + (body.get("remediate") or "")
assert "silent" not in haystack.lower()
@pytest.mark.asyncio
async def test_developer_dm_passes_auditor_guard() -> None:
"""dm() for a non-auditor role is not blocked by the new guard."""
@@ -139,26 +97,6 @@ async def test_developer_dm_passes_auditor_guard() -> None:
_NO_COMMS_ROLES = ("pr_reviewer", "prompter", "secretary")
@pytest.mark.asyncio
@pytest.mark.parametrize("role", _NO_COMMS_ROLES)
async def test_no_comms_role_say_returns_not_authorized(role: str) -> None:
"""pr_reviewer / prompter / secretary may not say() — the handler-level
guard must refuse them regardless of how the call arrived, same as auditor."""
deps = _make_deps(role)
actions = ContentActions(deps)
env = await actions.say(agent_id=uuid4(), channel="backend-cell", text="hi")
body = env.as_dict()
assert body["error"] == "not_authorized"
# The no-comms signal distinguishes the role guard from any downstream
# reject (channel-access denial) — proves it's the silent-role guard.
haystack = (body.get("message") or "") + " " + (body.get("remediate") or "")
assert "silent" in haystack.lower()
# The guard fires before any downstream call.
deps.messaging.post_to_channel.assert_not_called()
@pytest.mark.asyncio
@pytest.mark.parametrize("role", _NO_COMMS_ROLES)
async def test_no_comms_role_dm_returns_not_authorized(role: str) -> None:
tests/unit/gateway/test_claim_doc_task_checkout.py
-1
View File
@@ -29,7 +29,6 @@ def _make_deps(**overrides: Any) -> ChoreographerDeps:
"journal": AsyncMock(),
"audit": AsyncMock(),
"evidence_repo": AsyncMock(),
"messaging": AsyncMock(),
}
base.update(overrides)
repo = base["evidence_repo"]
tests/unit/gateway/test_commit_prefix.py
-2
View File
@@ -34,7 +34,6 @@ def _make_deps(**overrides: AsyncMock) -> ContentActionsDeps:
git.commit.return_value = {"sha": "abc12345"}
git.diff.return_value = ""
messaging = overrides.get("messaging", AsyncMock())
a2a = overrides.get("a2a", AsyncMock())
journal = overrides.get("journal", AsyncMock())
workspace = overrides.get("workspace", AsyncMock())
@@ -42,7 +41,6 @@ def _make_deps(**overrides: AsyncMock) -> ContentActionsDeps:
return ContentActionsDeps(
task=task,
git=git,
messaging=messaging,
a2a=a2a,
journal=journal,
workspace=workspace,
tests/unit/gateway/test_content_actions.py
+1 -61
View File
@@ -1,4 +1,4 @@
"""Tests for ContentActions — commit, note, say, dm, evidence verbs."""
"""Tests for ContentActions — commit, note, dm, evidence verbs."""
from __future__ import annotations
@@ -32,7 +32,6 @@ def _make_deps(**overrides: AsyncMock) -> ContentActionsDeps:
git.commit.return_value = {"sha": "abc12345"}
git.diff.return_value = ""
messaging = overrides.get("messaging", AsyncMock())
a2a = overrides.get("a2a", AsyncMock())
journal = overrides.get("journal", AsyncMock())
workspace = overrides.get("workspace", AsyncMock())
@@ -46,7 +45,6 @@ def _make_deps(**overrides: AsyncMock) -> ContentActionsDeps:
return ContentActionsDeps(
task=task,
git=git,
messaging=messaging,
a2a=a2a,
journal=journal,
workspace=workspace,
@@ -495,50 +493,6 @@ async def test_note_auto_fills_task_id_from_active_task() -> None:
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_say_auto_injects_task_id_when_active_task_exists() -> None:
"""Channel post auto-injects task_id from active task."""
agent_id = uuid4()
task_id = uuid4()
task_obj = MagicMock(id=task_id, status="in_progress")
task_svc = AsyncMock()
task_svc.get_active_task_for_agent.return_value = task_obj
task_svc.get_journal_context_task_for_agent.return_value = task_obj
messaging_svc = AsyncMock()
deps = _make_deps(task=task_svc, messaging=messaging_svc)
ca = ContentActions(deps)
env = await ca.say(
agent_id=agent_id, channel="backend-cell", text="Starting the auth refactor."
)
body = env.as_dict()
assert body["error"] is None
assert body["task_id"] == str(task_id)
call_kwargs = messaging_svc.post_to_channel.call_args.kwargs
assert call_kwargs["task_id"] == task_id
@pytest.mark.asyncio
async def test_say_succeeds_with_no_active_task_task_id_is_null() -> None:
"""say without active task still succeeds; task_id in response is None."""
deps = _make_deps()
ca = ContentActions(deps)
agent_id = uuid4()
env = await ca.say(
agent_id=agent_id,
channel="all-hands",
text="Hello team, I am about to start work.",
)
body = env.as_dict()
assert body["error"] is None
assert body["task_id"] is None
deps.messaging.post_to_channel.assert_awaited_once()
# ---------------------------------------------------------------------------
# dm
# ---------------------------------------------------------------------------
@@ -912,20 +866,6 @@ async def test_pitch_placeholder_title_rejected_before_role_check() -> None:
deps.task.agent_for.assert_not_awaited()
@pytest.mark.asyncio
async def test_open_session_placeholder_topic_rejected() -> None:
"""``open_session`` topic must be substantive, not 'tbd'."""
deps = _make_deps()
ca = ContentActions(deps)
env = await ca.open_session(
agent_id=uuid4(), task_id=uuid4(), channel="backend-cell", topic="tbd"
)
assert env.as_dict()["error"] == "invalid_state"
deps.task.agent_for.assert_not_awaited()
@pytest.mark.asyncio
async def test_pr_update_placeholder_body_rejected() -> None:
"""``pr_update`` body, when supplied, must not be filler."""
tests/unit/gateway/test_content_actions_ownership.py
+2 -102
View File
@@ -1,6 +1,6 @@
"""Gate Set D: content-tool ownership guards in ContentActions.
When a caller passes a ``task_id`` to commit / say / dm / note / evidence,
When a caller passes a ``task_id`` to commit / dm / note / evidence,
the gateway must verify ``task.assigned_to == caller_agent_id`` before
allowing the side effect.
@@ -8,7 +8,7 @@ Pre-gateway equivalent: agents could only act on tasks they owned because
the MCP handlers resolved task from session context. With the gateway
exposing the task_id parameter, the ownership check must be explicit.
Exception: ``say`` and ``dm`` without a task_id (channel-only / off-task
Exception: ``dm`` without a task_id (channel-only / off-task
A2A) are exempt — used for channel announcements.
"""
@@ -39,7 +39,6 @@ def _make_deps(**overrides: AsyncMock) -> ContentActionsDeps:
git.commit.return_value = {"sha": "abc12345"}
git.diff.return_value = ""
messaging = overrides.get("messaging", AsyncMock())
a2a = overrides.get("a2a", AsyncMock())
journal = overrides.get("journal", AsyncMock())
workspace = overrides.get("workspace", AsyncMock())
@@ -52,7 +51,6 @@ def _make_deps(**overrides: AsyncMock) -> ContentActionsDeps:
return ContentActionsDeps(
task=task,
git=git,
messaging=messaging,
a2a=a2a,
journal=journal,
workspace=workspace,
@@ -182,74 +180,6 @@ async def test_note_without_task_id_skips_ownership_check() -> None:
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_say_with_task_id_blocks_when_not_assignee() -> None:
"""say(task_id=X) where X is owned by someone else is rejected."""
agent_id = uuid4()
other_id = uuid4()
task_id = uuid4()
task_obj = MagicMock(id=task_id, status="in_progress", assigned_to=other_id)
task_svc = AsyncMock()
task_svc.get.return_value = task_obj
messaging_svc = AsyncMock()
deps = _make_deps(task=task_svc, messaging=messaging_svc)
ca = ContentActions(deps)
env = await ca.say(
agent_id=agent_id,
channel="backend-cell",
text="Posting on someone else's task",
task_id=task_id,
)
body = env.as_dict()
assert body["error"] == "not_authorized"
messaging_svc.post_to_channel.assert_not_awaited()
@pytest.mark.asyncio
async def test_say_without_task_id_is_exempt() -> None:
"""say() with NO task_id and no active task: channel announcement, allowed."""
agent_id = uuid4()
task_svc = AsyncMock()
task_svc.get_active_task_for_agent.return_value = None
messaging_svc = AsyncMock()
deps = _make_deps(task=task_svc, messaging=messaging_svc)
ca = ContentActions(deps)
env = await ca.say(
agent_id=agent_id, channel="all-hands", text="General announcement"
)
assert env.error is None
messaging_svc.post_to_channel.assert_awaited_once()
@pytest.mark.asyncio
async def test_say_with_explicit_task_id_owned_by_caller_succeeds() -> None:
"""say(task_id=X) when caller owns X: allowed."""
agent_id = uuid4()
task_id = uuid4()
task_obj = MagicMock(
id=task_id,
status="in_progress",
assigned_to=agent_id,
active_claimant_id=agent_id,
)
task_svc = AsyncMock()
task_svc.get.return_value = task_obj
messaging_svc = AsyncMock()
deps = _make_deps(task=task_svc, messaging=messaging_svc)
ca = ContentActions(deps)
env = await ca.say(
agent_id=agent_id,
channel="backend-cell",
text="Working on my task",
task_id=task_id,
)
assert env.error is None
messaging_svc.post_to_channel.assert_awaited_once()
# ---------------------------------------------------------------------------
# dm — explicit task_id ownership
# ---------------------------------------------------------------------------
@@ -564,36 +494,6 @@ async def test_note_reaped_assignee_cannot_post_to_former_task() -> None:
journal_svc.write_entry.assert_not_awaited()
@pytest.mark.asyncio
async def test_say_reaped_assignee_cannot_post_to_former_task() -> None:
"""A reaped agent is rejected on say(task_id=X) too — same stale-window
divergence as note."""
agent_id = uuid4()
task_id = uuid4()
task_obj = MagicMock(
id=task_id,
status="in_progress",
assigned_to=agent_id,
active_claimant_id=None,
)
task_svc = AsyncMock()
task_svc.get.return_value = task_obj
messaging_svc = AsyncMock()
deps = _make_deps(task=task_svc, messaging=messaging_svc)
ca = ContentActions(deps)
env = await ca.say(
agent_id=agent_id,
channel="backend-cell",
text="Posting after my claim was reaped",
task_id=task_id,
)
body = env.as_dict()
assert body["error"] == "not_authorized", body
assert "active claim" in body["message"], body
messaging_svc.post_to_channel.assert_not_awaited()
@pytest.mark.asyncio
async def test_note_active_owner_can_still_post() -> None:
"""No-regression: an active owner (assigned_to=caller AND
tests/unit/gateway/test_content_actions_pitch.py
-1
View File
@@ -18,7 +18,6 @@ def _actions(role: str) -> ContentActions:
deps = ContentActionsDeps(
task=task,
git=MagicMock(),
messaging=MagicMock(),
a2a=MagicMock(),
journal=MagicMock(),
workspace=MagicMock(),
tests/unit/gateway/test_content_actions_roadmap.py
-1
View File
@@ -37,7 +37,6 @@ def _actions(role: str) -> ContentActions:
deps = ContentActionsDeps(
task=task,
git=MagicMock(),
messaging=MagicMock(),
a2a=MagicMock(),
journal=MagicMock(),
workspace=MagicMock(),
tests/unit/gateway/test_content_actions_runkiller.py
-1
View File
@@ -141,7 +141,6 @@ def _content_actions(session: AsyncSession) -> ContentActions:
ContentActionsDeps(
task=TaskService(session),
git=git,
messaging=AsyncMock(),
a2a=AsyncMock(),
journal=AsyncMock(),
workspace=AsyncMock(),
tests/unit/gateway/test_delegate_assignee_task_type.py
-1
View File
@@ -33,7 +33,6 @@ def _make_deps(**overrides: Any) -> ChoreographerDeps:
"journal": AsyncMock(),
"audit": AsyncMock(),
"evidence_repo": AsyncMock(),
"messaging": AsyncMock(),
}
base.update(overrides)
repo = base["evidence_repo"]
tests/unit/gateway/test_delegate_propagates_sessions.py
-138
View File
@@ -1,138 +0,0 @@
"""Task #156: delegate() must thread parent sessions onto the new subtask.
Pre-gateway flow created sessions for whole task trees at once, so subtasks
were visible in the group chat the PM was already using. The gateway's
delegate() creates subtasks one-by-one — without this step the new agent
spawns into an empty channel and can't see the PM's prior discussion.
"""
from __future__ import annotations
from datetime import UTC, datetime
from typing import Any
from unittest.mock import AsyncMock, MagicMock
from uuid import uuid4
import pytest
from roboco.services.gateway.choreographer import Choreographer, ChoreographerDeps
from roboco.services.gateway.choreographer._impl import DelegateInputs
def _make_deps(**overrides: Any) -> ChoreographerDeps:
base: dict[str, Any] = {
"task": AsyncMock(),
"work_session": AsyncMock(),
"git": AsyncMock(),
"a2a": AsyncMock(),
"journal": AsyncMock(),
"audit": AsyncMock(),
"evidence_repo": AsyncMock(),
"messaging": AsyncMock(),
}
base.update(overrides)
task = base["task"]
task.session = MagicMock()
task.session.begin_nested = MagicMock(
return_value=MagicMock(
__aenter__=AsyncMock(return_value=None),
__aexit__=AsyncMock(return_value=False),
)
)
repo = base["evidence_repo"]
for method in (
"list_unread_a2a",
"list_unread_mentions",
"list_pending_notifications",
"task_metadata_gaps",
"recent_team_activity",
"blockers_in_lane",
"journal_highlights_for_task",
):
getattr(repo, method).return_value = []
_ldef = base["journal"].latest_decision_at.return_value
if type(_ldef).__name__ in ("MagicMock", "AsyncMock"):
base["journal"].latest_decision_at.return_value = datetime.now(UTC)
return ChoreographerDeps(**base)
@pytest.mark.asyncio
async def test_create_subtask_propagates_parent_sessions() -> None:
"""When the choreographer creates a subtask, the parent's session
links are auto-attached to it via MessagingService.propagate_sessions_to_subtask.
"""
pm_id = uuid4()
parent_id = uuid4()
new_task_id = uuid4()
parent = MagicMock(
id=parent_id,
project_id=uuid4(),
team="backend",
status="in_progress",
task_type="planning",
sequence=0,
assigned_to=pm_id,
)
new_task = MagicMock(id=new_task_id, status="pending")
task_svc = AsyncMock()
task_svc.create_subtask.return_value = new_task
messaging = AsyncMock()
messaging.propagate_sessions_to_subtask.return_value = []
deps = _make_deps(task=task_svc, messaging=messaging)
c = Choreographer(deps)
inputs = DelegateInputs(
title="Backend slice",
description="API + DB",
acceptance_criteria=["api works", "schema migrated"],
assigned_to="be-dev-1",
team="backend",
task_type="code",
nature="technical",
estimated_complexity="medium",
)
result = await c._create_subtask_from_inputs(pm_id, parent_id, parent, inputs)
assert result is new_task
messaging.propagate_sessions_to_subtask.assert_awaited_once_with(
parent_task_id=parent_id,
subtask_id=new_task_id,
added_by=pm_id,
)
@pytest.mark.asyncio
async def test_create_subtask_no_messaging_skips_propagation() -> None:
"""When messaging dep is None (e.g. lightweight test wiring), the
subtask is still created — propagation is a soft enhancement, not a
hard requirement."""
pm_id = uuid4()
parent_id = uuid4()
new_task_id = uuid4()
parent = MagicMock(
id=parent_id,
project_id=uuid4(),
team="backend",
status="in_progress",
task_type="planning",
sequence=0,
assigned_to=pm_id,
)
new_task = MagicMock(id=new_task_id, status="pending")
task_svc = AsyncMock()
task_svc.create_subtask.return_value = new_task
deps = _make_deps(task=task_svc, messaging=None)
c = Choreographer(deps)
inputs = DelegateInputs(
title="Backend slice",
description="API + DB",
acceptance_criteria=["api works"],
assigned_to="be-dev-1",
team="backend",
task_type="code",
nature="technical",
estimated_complexity="medium",
)
# Must not raise even though messaging is None.
result = await c._create_subtask_from_inputs(pm_id, parent_id, parent, inputs)
assert result is new_task
tests/unit/gateway/test_delegate_rejects_documentation_subtask.py
-1
View File
@@ -32,7 +32,6 @@ def _make_deps(**overrides: Any) -> ChoreographerDeps:
"journal": AsyncMock(),
"audit": AsyncMock(),
"evidence_repo": AsyncMock(),
"messaging": AsyncMock(),
}
base.update(overrides)
repo = base["evidence_repo"]
tests/unit/gateway/test_dm_a2a_denied.py
-1
View File
@@ -29,7 +29,6 @@ def _make_deps(**overrides: object) -> ContentActionsDeps:
base: dict[str, object] = {
"task": AsyncMock(),
"git": AsyncMock(),
"messaging": AsyncMock(),
"a2a": AsyncMock(),
"journal": AsyncMock(),
"workspace": AsyncMock(),
tests/unit/gateway/test_doc_reflect_autowrite.py
-1
View File
@@ -29,7 +29,6 @@ def _make_deps(**overrides: Any) -> ChoreographerDeps:
"journal": AsyncMock(),
"audit": AsyncMock(),
"evidence_repo": AsyncMock(),
"messaging": AsyncMock(),
}
base.update(overrides)
return ChoreographerDeps(**base)
tests/unit/gateway/test_evidence_populates_files_changed.py
-1
View File
@@ -32,7 +32,6 @@ def _deps_for_evidence(
return ContentActionsDeps(
task=task_svc,
git=git_svc,
messaging=AsyncMock(),
a2a=AsyncMock(),
journal=AsyncMock(),
workspace=workspace_svc,
tests/unit/gateway/test_evidence_repo.py
+5 -1
View File
@@ -141,7 +141,10 @@ async def test_unread_a2a_maps_other_agent_and_unread_count() -> None:
topic="rework",
task_id=None,
)
out = await _repo_with_rows([conv], scalar="be-pm").list_unread_a2a(uuid4())
# list_unread_a2a now selects (conversation, last_incoming_preview) tuples.
out = await _repo_with_rows(
[(conv, "please redo the auth check")], scalar="be-pm"
).list_unread_a2a(uuid4())
assert out == [
{
"conversation_id": str(cid),
@@ -149,6 +152,7 @@ async def test_unread_a2a_maps_other_agent_and_unread_count() -> None:
"unread": 3,
"topic": "rework",
"task_id": None,
"last_message_preview": "please redo the auth check",
}
]
tests/unit/gateway/test_milestone_progress.py
-2
View File
@@ -29,7 +29,6 @@ async def test_record_milestone_progress_calls_add_progress() -> None:
journal=AsyncMock(),
audit=AsyncMock(),
evidence_repo=AsyncMock(),
messaging=AsyncMock(),
)
c = Choreographer(deps)
@@ -59,7 +58,6 @@ async def test_record_milestone_progress_swallows_errors() -> None:
journal=AsyncMock(),
audit=AsyncMock(),
evidence_repo=AsyncMock(),
messaging=AsyncMock(),
)
c = Choreographer(deps)
tests/unit/gateway/test_note_handoff.py
-1
View File
@@ -21,7 +21,6 @@ def _make_deps(**overrides: object) -> ContentActionsDeps:
return ContentActionsDeps(
task=task,
git=overrides.get("git") or AsyncMock(),
messaging=overrides.get("messaging") or AsyncMock(),
a2a=overrides.get("a2a") or AsyncMock(),
journal=overrides.get("journal") or AsyncMock(),
workspace=overrides.get("workspace") or AsyncMock(),
tests/unit/gateway/test_notify.py
-2
View File
@@ -26,7 +26,6 @@ def _make_deps(**overrides: AsyncMock) -> ContentActionsDeps:
task.agent_for.return_value = MagicMock(role="cell_pm")
git = overrides.get("git", AsyncMock())
messaging = overrides.get("messaging", AsyncMock())
a2a = overrides.get("a2a", AsyncMock())
journal = overrides.get("journal", AsyncMock())
workspace = overrides.get("workspace", AsyncMock())
@@ -34,7 +33,6 @@ def _make_deps(**overrides: AsyncMock) -> ContentActionsDeps:
return ContentActionsDeps(
task=task,
git=git,
messaging=messaging,
a2a=a2a,
journal=journal,
workspace=workspace,
tests/unit/gateway/test_open_session_schema.py
-99
View File
@@ -1,99 +0,0 @@
"""Smoke-4: open_session must pass the model schema (not the API schema) to
the messaging service.
Smoke run 4 surfaced an AttributeError because content_actions.open_session
constructed a `SessionForTasksCreateRequest` (API schema, flat fields) but
`MessagingService._build_session_request` reads `req.config.max_message_count`
(the model has nested `config`). Two schemas, one expected, one passed.
This test pins the contract: the gateway constructs the model and the
service receives the model.
"""
from __future__ import annotations
from unittest.mock import AsyncMock, MagicMock
from uuid import uuid4
import pytest
from roboco.models.session import SessionForTasksCreate, SessionTaskRelationshipType
from roboco.services.gateway.content_actions import ContentActions, ContentActionsDeps
def _make_deps(**overrides: object) -> ContentActionsDeps:
base: dict[str, object] = {
"task": AsyncMock(),
"git": AsyncMock(),
"messaging": AsyncMock(),
"a2a": AsyncMock(),
"journal": AsyncMock(),
"workspace": AsyncMock(),
"notifications": AsyncMock(),
}
base.update(overrides)
return ContentActionsDeps(**base)
@pytest.mark.asyncio
async def test_open_session_passes_model_schema_to_service() -> None:
"""The service must receive a SessionForTasksCreate (model), not the API schema."""
agent_id = uuid4()
task_id = uuid4()
pm_agent = MagicMock(role="cell_pm")
task_svc = AsyncMock()
task_svc.agent_for.return_value = pm_agent
session_row = MagicMock(id=uuid4())
messaging_svc = AsyncMock()
messaging_svc.create_session_for_tasks.return_value = (session_row, [])
deps = _make_deps(task=task_svc, messaging=messaging_svc)
actions = ContentActions(deps)
env = await actions.open_session(
agent_id=agent_id,
task_id=task_id,
channel="backend-cell",
topic="discuss the plan",
relationship_type="discussion",
group_id=None,
)
assert env.error is None, (
f"open_session returned error: {env.error} / {env.message}"
)
messaging_svc.create_session_for_tasks.assert_awaited_once()
call = messaging_svc.create_session_for_tasks.await_args
passed_req = call.kwargs["req"]
assert isinstance(passed_req, SessionForTasksCreate), (
f"expected SessionForTasksCreate (model), got {type(passed_req).__name__}. "
f"The service reads req.config.* which only exists on the model."
)
@pytest.mark.asyncio
async def test_open_session_unknown_relationship_falls_back_to_discussion() -> None:
"""Invalid relationship_type string defaults to DISCUSSION enum."""
pm_agent = MagicMock(role="main_pm")
task_svc = AsyncMock()
task_svc.agent_for.return_value = pm_agent
session_row = MagicMock(id=uuid4())
messaging_svc = AsyncMock()
messaging_svc.create_session_for_tasks.return_value = (session_row, [])
deps = _make_deps(task=task_svc, messaging=messaging_svc)
actions = ContentActions(deps)
await actions.open_session(
agent_id=uuid4(),
task_id=uuid4(),
channel="backend-cell",
topic="discuss",
relationship_type="nonsense-type-not-in-enum",
group_id=None,
)
passed_req = messaging_svc.create_session_for_tasks.await_args.kwargs["req"]
assert passed_req.relationship_type == SessionTaskRelationshipType.DISCUSSION
tests/unit/gateway/test_playbook_verbs.py
-1
View File
@@ -54,7 +54,6 @@ def _actions(role: str) -> ContentActions:
deps = ContentActionsDeps(
task=task,
git=MagicMock(),
messaging=MagicMock(),
a2a=MagicMock(),
journal=MagicMock(),
workspace=MagicMock(),
tests/unit/gateway/test_pm_own_review_hint.py
-1
View File
@@ -29,7 +29,6 @@ def _make_deps(**overrides: Any) -> ChoreographerDeps:
"journal": AsyncMock(),
"audit": AsyncMock(),
"evidence_repo": AsyncMock(),
"messaging": AsyncMock(),
}
base.update(overrides)
repo = base["evidence_repo"]
tests/unit/gateway/test_pr_update.py
-1
View File
@@ -21,7 +21,6 @@ def _make_deps(**overrides: AsyncMock) -> ContentActionsDeps:
return ContentActionsDeps(
task=task,
git=git,
messaging=overrides.get("messaging", AsyncMock()),
a2a=overrides.get("a2a", AsyncMock()),
journal=overrides.get("journal", AsyncMock()),
workspace=overrides.get("workspace", AsyncMock()),
tests/unit/gateway/test_say_channel_rbac.py
-123
View File
@@ -1,123 +0,0 @@
"""ContentActions.say must enforce channel write-access via send_message.
The gateway path (post_to_channel -> send_message) historically called
send_message WITHOUT agent_slug, which bypassed validate_channel_access.
Pre-gateway returned a friendly ChannelAccessDeniedError listing the
agent's writable channels. These tests pin the restored behaviour:
1. say() converts ChannelAccessDeniedError into a not_authorized Envelope
that names the offending channel and includes a remediation hint
listing the writable channels for the agent's role.
"""
from __future__ import annotations
from unittest.mock import AsyncMock
from uuid import uuid4
import pytest
from roboco.enforcement.channel_access import ChannelAccessDeniedError
from roboco.services.gateway.content_actions import (
ContentActions,
ContentActionsDeps,
)
def _make_deps(**overrides: AsyncMock) -> ContentActionsDeps:
"""Mirrors test_content_actions._make_deps."""
if "task" in overrides:
task = overrides["task"]
else:
task = AsyncMock()
task.get_active_task_for_agent.return_value = None
git = overrides.get("git", AsyncMock())
messaging = overrides.get("messaging", AsyncMock())
a2a = overrides.get("a2a", AsyncMock())
journal = overrides.get("journal", AsyncMock())
workspace = overrides.get("workspace", AsyncMock())
notifications = overrides.get("notifications", AsyncMock())
return ContentActionsDeps(
task=task,
git=git,
messaging=messaging,
a2a=a2a,
journal=journal,
workspace=workspace,
notifications=notifications,
)
@pytest.mark.asyncio
async def test_say_returns_not_authorized_envelope_on_access_denied() -> None:
"""When messaging.post_to_channel raises ChannelAccessDeniedError, say()
converts it into a not_authorized Envelope with a writable-channels hint.
"""
aid = uuid4()
msg_svc = AsyncMock()
msg_svc.post_to_channel.side_effect = ChannelAccessDeniedError(
agent_id="be-dev-1",
channel_slug="announcements",
action="write",
)
deps = _make_deps(messaging=msg_svc)
actions = ContentActions(deps)
env = await actions.say(agent_id=aid, channel="announcements", text="hi")
body = env.as_dict()
assert body["error"] == "not_authorized"
assert "announcements" in body["message"]
# Remediation should hint at the channels the agent may write to (or
# that they have none). The list is resolved from CHANNEL_ACCESS via
# get_agent_channels using the agent's slug — note the wording is
# slug-keyed ("channels you may write to") rather than role-keyed,
# since CHANNEL_ACCESS is keyed by slug not role.
assert body["remediate"] is not None
assert "channels you may write to" in body["remediate"].lower()
@pytest.mark.asyncio
async def test_say_success_path_returns_posted_envelope() -> None:
"""Sanity: when messaging accepts the post, say() returns the
standard posted/continue Envelope (no regression in the happy path).
"""
aid = uuid4()
msg_svc = AsyncMock()
deps = _make_deps(messaging=msg_svc)
actions = ContentActions(deps)
env = await actions.say(agent_id=aid, channel="dev-all", text="hello")
body = env.as_dict()
assert body["error"] is None
assert body["status"] == "posted"
assert body["next"] == "continue"
msg_svc.post_to_channel.assert_awaited_once()
@pytest.mark.asyncio
async def test_say_returns_not_authorized_when_agent_lookup_fails() -> None:
"""If get_agent_slug returns None (deleted agent), say must fail closed.
Pins the I1 fix: post_to_channel raises ChannelAccessDeniedError directly
when the slug lookup fails, so send_message's `if agent_slug:` can no
longer skip validate_channel_access for unknown/removed agents. The
Envelope conversion in say() carries that through to the agent.
"""
aid = uuid4()
msg_svc = AsyncMock()
msg_svc.post_to_channel.side_effect = ChannelAccessDeniedError(
agent_id=str(aid),
channel_slug="dev-all",
action="write",
message="agent not found",
)
deps = _make_deps(messaging=msg_svc)
actions = ContentActions(deps)
env = await actions.say(agent_id=aid, channel="dev-all", text="hi")
body = env.as_dict()
assert body["error"] == "not_authorized"
assert "dev-all" in body["message"]
tests/unit/gateway/test_say_status.py
-96
View File
@@ -1,96 +0,0 @@
"""Wave B3 (2026-05-12): say() returns canonical 'posted' status.
Smoke run 3 showed main-pm got status='sent' while be-pm got status='posted'
for the same verb. This test pins the canonical past-tense pattern:
note() -> 'noted'
say() -> 'posted' (this file)
notify_ack() -> 'acked'
dm() and notify() return 'sent' — those are different verbs with their own
semantics and are intentionally not touched here.
"""
from __future__ import annotations
from unittest.mock import AsyncMock, MagicMock
from uuid import uuid4
import pytest
from roboco.services.gateway.content_actions import ContentActions, ContentActionsDeps
def _make_deps(**overrides: AsyncMock) -> ContentActionsDeps:
if "task" in overrides:
task = overrides["task"]
else:
task = AsyncMock()
task.agent_for.return_value = MagicMock(role="developer", slug="be-dev-1")
task.get_active_task_for_agent.return_value = None
task.get_journal_context_task_for_agent.return_value = None
git = overrides.get("git", AsyncMock())
messaging = overrides.get("messaging", AsyncMock())
a2a = overrides.get("a2a", AsyncMock())
journal = overrides.get("journal", AsyncMock())
workspace = overrides.get("workspace", AsyncMock())
notifications = overrides.get("notifications", AsyncMock())
notification_delivery = overrides.get("notification_delivery", AsyncMock())
return ContentActionsDeps(
task=task,
git=git,
messaging=messaging,
a2a=a2a,
journal=journal,
workspace=workspace,
notifications=notifications,
notification_delivery=notification_delivery,
)
@pytest.mark.asyncio
async def test_say_returns_posted_status() -> None:
"""say() returns status='posted' (past-tense, aligned with 'noted'/'acked')."""
ca = ContentActions(_make_deps())
env = await ca.say(
agent_id=uuid4(),
channel="backend-cell",
text="hello team",
)
body = env.as_dict()
assert body["error"] is None, body
assert body["status"] == "posted", body
@pytest.mark.asyncio
async def test_say_posted_status_with_active_task() -> None:
"""say() returns 'posted' even when an active task is auto-injected."""
task_id = uuid4()
task_obj = MagicMock(id=task_id, status="in_progress")
task_svc = AsyncMock()
task_svc.agent_for.return_value = MagicMock(role="developer", slug="be-dev-1")
task_svc.get_active_task_for_agent.return_value = task_obj
task_svc.get_journal_context_task_for_agent.return_value = task_obj
ca = ContentActions(_make_deps(task=task_svc))
env = await ca.say(
agent_id=uuid4(),
channel="backend-cell",
text="progress update",
)
body = env.as_dict()
assert body["error"] is None, body
assert body["status"] == "posted", body
assert body["task_id"] == str(task_id), body
@pytest.mark.asyncio
async def test_say_next_is_continue() -> None:
"""say() sets next='continue' so agents know to keep working."""
ca = ContentActions(_make_deps())
env = await ca.say(
agent_id=uuid4(),
channel="dev-all",
text="syncing up",
)
body = env.as_dict()
assert body["next"] == "continue", body
tests/unit/gateway/test_tracing_gap_hints.py
-1
View File
@@ -36,7 +36,6 @@ def _build_choreographer() -> Choreographer:
journal=AsyncMock(),
audit=AsyncMock(),
evidence_repo=AsyncMock(),
messaging=AsyncMock(),
)
repo = deps.evidence_repo
for method in (