3 Commits

Include renames

Author	SHA1	Message	Date
3 people	fc41dfa40e	fix(security): active guard enforcement, CEO A2A target check, notification expiry (#595) ... * fix(security): guard goes active; CEO A2A respects no-comms roles; ack notifications expire ROBOCO_GUARD_PASSIVE_MODE defaults to false in both compose files — the deferred post-calibration flip; fail_secure stays off and the env override remains the rollback. can_a2a_direct no longer short-circuits the CEO past the no-comms set (auditor/pr_reviewer/prompter/secretary), now canonical in foundation.policy.communications.NO_COMMS_ROLES and shared with the content-actions gate; the A2A service refuses at conversation creation instead of silently suppressing the wake. Ack-required notifications get expires_at stamped from ROBOCO_NOTIFICATION_ACK_TTL_HOURS (default 48, 0 disables), so the re-escalation sweeper's expires_at query matches rows for the first time. * refactor(notification): extract _ack_and_expiry — xenon rank back under B The expires_at stamping pushed _create_notification_with_session to rank C; the requires_ack + expiry derivation moves into a helper with the same semantics and comments. * test(conftest): dispose the global DB engine after every test Production code reaching get_db_context()/get_engine() lazily creates the process-global engine bound to the current event loop; with per-test function-scoped loops, any later test touching the global path inherits a dead-loop engine and dies with 'Future attached to a different loop' — the order-dependent class that has been wandering the suite (cloud_auth login, metrics, tasks-routes, full-lifecycle) whenever collection order shifts. An autouse fixture now close_db()s after every test, keeping the global path loop-local; no-op when untouched. --------- Co-authored-by: Renn F <rennf93@users.noreply.github.com>	2026-07-19 18:46:44 +02:00
3 people	7901ea419e	Retire channels/sessions/messages; A2A becomes primary agent comms (#306) ... * 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>	2026-07-04 03:10:33 +02:00
3 people	0ca9d91b72	v0.16.0: fastapi-guard HTTP security layer — calibrated + scanner honeytrap (#290) ... * [fastapi-guard] Phase 1a: gated config flags for the HTTP security layer Adds the ROBOCO_GUARD_* settings (all default-off / secure-default) for the upcoming fastapi-guard 7.2.0 hardening — guard_enabled (master switch), guard_fail_secure (fail-closed default; NAS overrides to false), guard_telemetry_enabled + guard_agent_api_key + guard_project_id (guard-agent telemetry, opt-in), guard_emergency + guard_emergency_whitelist (lockdown kill switch). Inert until consumed: nothing reads them yet, so the request path is unchanged. Foundation for v0.16.0. * [fastapi-guard] Phase 1b: security foundation module + gated wiring Add fastapi-guard 7.2.0 + guard-core 3.3.0 (bare, unpinned) and roboco/security.py: - build_security_config() from settings — behind-nginx real-IP (trusted_proxies + trust_x_forwarded_proto), HSTS/CSP headers, threat-ban + 404-sweep rules, redis-backed state, exclude_paths (/ws + health + docs), env-driven enforce_https, fail_secure (secure default), emergency lockdown, guard-agent telemetry (opt-in), passive-mode calibration switch. - guard_deco singleton (SecurityDecorator) for per-route decorators (Phase 2+). - Three custom content validators guard's WAF can't cover: prompt-injection / role-override, secret-exfil / credential-in-body, internal-SSRF. - apply_guard(app) + guarded_lifespan() wired into create_app AFTER settings. guard_passive_mode config flag added. Entirely gated by ROBOCO_GUARD_ENABLED (default off): create_app mounts nothing and returns the unchanged app when off (verified). make quality GREEN (cov 95.32%, pip-audit clean, import-linter 2/0). 12 new unit tests. * [fastapi-guard] Phase 2: critical-path decorators Apply guard decorators to the highest-value endpoints (metadata-only; enforced only when the middleware is mounted, so no-op while ROBOCO_GUARD_ENABLED is off): - provider keys (ollama/grok/self-hosted writes): strict rate_limit + max_request_size + block_clouds (no datacenter IP should touch secret writes). - settings write + release approve/reject (CEO-gated): strict rate_limit. - intake chat (prompter start/messages/events): rate_limit + max_request_size + custom_validation(prompt_injection_validator) — the prompt-facing free-text ingress gets the injection/role-override/secret-exfil content scan. make quality GREEN (cov 95.32%, contracts 2/0). App builds with guard off, decorators inert (verified). * [fastapi-guard] Phase 3: wide decorator coverage across ingress + sensitive routes Targeted-wide application (metadata-only; no-op until ROBOCO_GUARD_ENABLED). The global SecurityMiddleware already rate-limits + WAF-scans every request, so this adds the custom content validators on free-text ingress + tight limits on sensitive ops (not blanket per-route rate_limit on reads): - agent gateway do verbs (note/say/commit/dm/pitch/progress/draft_playbook/...): rate_limit + max_request_size + custom_validation(secret_exfil or prompt_injection). - a2a message/send + chat writes: rate_limit + size + prompt_injection. - optimal/RAG (kb/search, rag/query, mentor/ask, errors/decisions/standards/ learnings): prompt_injection on searches, secret_exfil on record writes; docs index → internal_ssrf. - tasks: create/update → prompt_injection; QA/doc/PM transitions → secret_exfil; CEO-gated verbs → tight rate_limit. - secretary chat → prompt_injection; research → internal_ssrf; orchestrator spawn/mutations → rate_limit; git ops + flow verbs → tight rate_limit. Pure GET/reads left to the global middleware. Applied via a Sonnet workflow, then verified: app builds with guard off (decorators inert), make quality GREEN (cov 95.37%, contracts 2/0). Decoy/honeypot-path surface deferred (needs verified guard ban-API integration — not rushed). * [fastapi-guard] Phase 5: arm the NAS composes in passive/log-only mode Arm ROBOCO_GUARD_ENABLED=true + ROBOCO_GUARD_PASSIVE_MODE=true + ROBOCO_GUARD_FAIL_SECURE=false on the two NAS composes (docker-compose.yaml + .yml). Passive = guard mounts and logs what it WOULD block but blocks nothing, so the next NAS deploy calibrates against real traffic; flip PASSIVE_MODE off after the false-positive review to enforce. fail_secure=false keeps a guard-internal error from 500ing the personal deploy. The registry (user-facing) compose is deliberately left unarmed so its published default stays conservative. Phase 4 (passive calibration) is the operational step this enables. * feat(security): Phase 3b — full-arsenal per-route guard enrichment Stack the applicable guard decorators per surface instead of the minimal rate_limit/max_request_size/custom_validation triad: content_type_filter on every JSON-body write, honeypot_detection form-traps on human-facing POSTs, block_clouds on key-writes + CEO release ops, behavior_analysis runaway-rate rules on the agent flow/do verbs, suspicious_detection + usage_monitor on the sensitive surfaces. Nine distinct decorators now applied thoughtfully per endpoint. All metadata-only — no-op while ROBOCO_GUARD_ENABLED is off. * fix(a2a): permit PR reviewer to deliver gate verdicts to the owning PM can_a2a_direct had no pr_reviewer rule, so a reviewer (team=board, or a cell team) fell through to the cell-member path and was cross-cell-denied when the in-path gate delivered a pr_fail change-request to main-pm (or a cross-cell cell-pm): "Cannot A2A main-pm ... Ask None to coordinate with None". The delivery is best-effort, so pr_fail still transitioned but the verdict never reached the owning PM — the blind-re-submit signal-gap the pr_fail fix closes. Add an explicit pr_reviewer handler: it may A2A only cell_pm / main_pm (its sole comms surface — everything else it posts on the PR itself), with a matching route hint. The cell reviewers kept same-team access by coincidence; this scopes every reviewer to PM-only, the correct model, with no other A2A caller affected. Refresh uv.lock to the current resolution. * feat(models): adopt Claude Sonnet 5 as the sonnet tier Point the 'sonnet' alias at claude-sonnet-5 (MODEL_MAP) and give pr_reviewer its own opus tier in ROLE_MODEL_MAP — it was falling through to the sonnet default, and the role gates untrusted external/fork PRs plus root→master, which warrants opus. Price claude-sonnet-5 at the promotional 33% off Sonnet 4.6 ($2.01 / $10.05, cache 0.201 / 0.5025) through 2026-08-31 via a dedicated pricing fragment that beats the bare 'sonnet' alias; revert to full rate when the promo ends. Bare 'sonnet' stays full-rate as a conservative fallback (prod prices the resolved claude-sonnet-5 id from the transcript). Update the model docs and the billing / usage / manifest / spawn tests. * feat(security): calibrate the guard WAF for RoboCo traffic + document the layer The first end-to-end run of the fastapi-guard layer showed active enforcement would block ~50% of legitimate agent traffic — RoboCo request bodies are code, SQL, diffs, file paths, HTML, and URLs, which the stock signature WAF reads as attacks. build_security_config now excludes RoboCo's free-text top-level body fields (derived from the real request models, including the free-form container fields whose nested prose is stringified and scanned) from WAF scanning, dropping the active-mode false-positive rate to zero while keeping the WAF on every non-excluded (id/enum/slug/branch) field and leaving the prompt-injection / secret-exfil / internal-SSRF validators — which run independently of the exclusion — fully in force. enable_penetration_detection is made explicit. Only excluded_detection_body_fields is reliable on guard 7.2.1: the per-route categories knob is bypassed for JSON bodies, and the body scanner excludes top-level keys only (scanning str(value) of every non-excluded field), so free-form container fields must be excluded wholesale. Adds tests/unit/test_security_middleware.py — the first end-to-end exercise of the middleware (mounts it, drives guard's lifespan, fires real requests): proves passive mode is log-only, active mode does not false-positive on realistic agent payloads, threats are still blocked inside excluded fields, and the WAF still fires on non-excluded fields. Docs: CHANGELOG (Unreleased); a user-facing Optional-subsystems page + nav + env reference for the HTTP security layer; the agent-facing RAG corpus (what it is + why a request could be blocked); and the roboco mapping (api-core-websocket / deployment-tooling / _complete_map). * feat(security): Surface N — scanner honeytrap (guard /api auto-ban + nginx edge-drop) Turns scanner probes against the scanner, in two layers matched to where traffic lands. Behind nginx only /api, /ws, /health, /ready reach the orchestrator, so guard can only see (and ban) scanner probes on those paths; the classic root probes (/.env, /wp-login.php, /phpmyadmin, /.git/config) hit the panel. So: - build_security_config's threat_ban_config gains recon / sensitive_file / cms_probing categories. A scanner probing those fingerprints on an /api path is detected on the URL-path scan; repeated probes from one IP trip an adaptive per-IP auto-ban (redis-backed, 24h). Only bans in active mode (passive logs the recon hit) and needs redis (the 24h ban exceeds the in-memory cap). The spec's decoy-route file is redundant — the WAF url-path scan bans regardless of a registered route — so it is intentionally omitted. - docker/nginx.conf drops the classic root scanner paths at the edge with 444 (connection closed, no response) before they reach the panel, anchored to known scanner fingerprints so /.well-known and every real panel/API route are untouched. Always on, independent of ROBOCO_GUARD_ENABLED. Tests: 2 unit (the exclusion set + the scanner-ban categories are present) and 2 integration (a decoy path is blocked in active mode, passes in passive). The nginx regex was validated against 15 scanner + 19 legit paths (0 false positives). Docs: CHANGELOG, the HTTP-security page, the roboco mapping, and the agent-facing RAG corpus. * Token optimization — per-role observability, compute policy, spawn preflight (#291) * test(models): lock the sonnet→claude-sonnet-5 MODEL_MAP invariant * feat(usage): surface cache tokens + cache_hit_rate in usage breakdowns * feat(usage): add per-role usage breakdown endpoint * feat(usage): add spawn-waste signal (per-role unproductive rate + respawn strikes) * feat(panel): surface per-role cost/cache + spawn-waste on the metrics page * feat(routing): Phase 2 per-role compute policy — qa→haiku, main_pm→sonnet, per-role effort env mechanism (default-inert) * feat(orchestrator): Phase 3 flag-gated spawn preflight — refuse non-gateway delivery roles (respawn-forever guard) * chore(compose): arm ROBOCO_SPAWN_PREFLIGHT_ENABLED on the NAS composes * docs: per-role usage observability, per-role compute policy, and spawn preflight --------- Co-authored-by: Renn F <rennf93@users.noreply.github.com> * fix(panel): pin outputFileTracingRoot so the standalone build isn't broken by stray lockfiles * feat(routing): populate ROLE_EFFORT_MAP + wire the verified --effort flag (cell_pm/board/auditor to medium) * feat(gateway): omit empty context_briefing sections (Phase 4 payload compaction) * refactor(orchestrator): extract spawn chokepoint guards to restore xenon rank B on spawn_agent --------- Co-authored-by: Renn F <rennf93@users.noreply.github.com>	2026-07-01 23:54:48 +02:00