Remove legacy Claude-only team mode code

[lazabogdan]

Summary

• Removed the legacy Claude-only team mode implementation and the associated prompts, agent manifests, UI surfaces, hooks, stores, API endpoints, and MCP plugin code.
• Reframed delegation and harness guidance around the provider-neutral RalphX-native contracts used by the active runtime.
• Tightened CI to fail when generated plugin build output is out of date.

User Impact

• The app no longer exposes the old Claude team-mode flows or their related chat, ideation, and execution UI.
• Delegation, ideation, and agent orchestration now read as the current native behavior instead of the retired Claude-specific model.
• Generated plugin artifacts must stay committed, which reduces drift between source changes and shipped MCP server output.

Technical Context

• The diff removes the agents/ralphx-execution-team-* and agents/ralphx-ideation-team-* definitions and deletes the legacy team-mode frontend modules, tests, and backend/plugin handlers tied to that surface.
• Remaining documentation and rule updates reword the topology around canonical delegation allowlists and provider-neutral harness behavior.
• Several frontend and backend modules were adjusted to follow the newer chat, ideation, and task paths after the legacy team-mode branches were removed.

Risks / Follow-Ups

• This is a broad cleanup across runtime, UI, docs, and generated output, so any stale references to the retired team-mode surface are the main residual risk.
• The generated plugin build/ artifacts are now part of the expected committed state, so future changes in plugins/app/ralphx-mcp-server need to keep source and generated output aligned.

View full plan

Goal

“we have a legacy Claude-only team mode that was decommisioned and we need to cleanup the codebase for this tech debt. we are only using the rx native team mode capability now.”

Follow-up scope: clean up the stray root ralphx-plugin/ralphx-mcp-server artifact and src-tauri/manual_agent_teams_process.txt as part of the same removal.

Remove the decommissioned Claude Code Agent Teams implementation end to end while preserving RalphX-native team/delegation behavior for both Claude and Codex harnesses. Per the follow-up decision—“Not interested in keeping HISTORICAL COMPATIBILITY … I’d rather clean it up”—the cleanup also removes legacy-only persisted state, schema fields, deserialization branches, renderers, and compatibility tests rather than retaining inert historical support.

Assumptions:

• “RX native team mode” means the current CoordinationMode::RxNativeTeam plus backend-owned delegate_start / delegate_wait / delegate_cancel orchestration described in docs/architecture/native-agent-delegation-bridge.md.
• Existing legacy_claude_team conversations are rewritten once to rx_native_team so unrelated conversation history remains usable; this is a destructive schema cleanup, not an ongoing compatibility path.
• Legacy-only team-session/message rows, tables, activation metadata, import fields, historical renderers, and compatibility tests are removed. Existing migration files remain immutable, but a new forward migration cleans up their resulting schema/data.
• The root ralphx-plugin/ralphx-mcp-server/ is not a second implementation or a live symlink: inspection shows only an empty 96-byte npm lockfile. Remove that entire stray root tree while preserving the canonical package at plugins/app/ralphx-mcp-server/.
• Active artifact tools with legacy-looking names are not legacy-only: create_team_artifact and get_team_artifacts are used by current RX-native delegated agents and therefore remain available. The native TeamIntent, TeamIntentStrategy, TeamMessageTarget, and TeamMessageTargetKind contracts also remain. By contrast, the unrouted typed publish_verification_finding / get_verification_findings path and ArtifactType::VerificationFinding metadata are obsolete fixed-verifier/team-era state and are removed. The preserved artifact writer is not already neutral: handlers/teams/artifacts.rs currently hard-codes created_by, author_teammate, and the system-bucket writer as team-lead; replace those legacy sentinels with backend-owned/system creation plus caller-agent attribution injected by the MCP transport, without adding an author field to the model-facing schema.

Repository Evidence And Classification

Delete: Claude-only live implementation

• agents/ralphx-{ideation,execution}-team-{lead,member}/**: four Claude-only roles whose prompts use TeamCreate, Claude Task(team_name), SendMessage, and TeamDelete.
• config/processes.yaml: process_mapping.*.team branches and team_constraints presets/model/tool ceilings.
• The team-only portions of src-tauri/src/infrastructure/agents/claude/agent_config/team_config.rs: TeamMode, TeamConstraints*, teammate plan validation/presets/budgets, env overrides, and team-variant resolution; plus team agent aliases and Claude teammate spawn helpers in claude_code_client.rs. The provider-neutral ProcessMapping / ProcessSlot default registry is not deleted.
• src-tauri/src/application/team_state_tracker.rs, team_service.rs, team_stream_processor.rs, team_events.rs, sibling tests, and incidental wiring through AppState/HTTP/chat factories.
• src-tauri/src/http_server/handlers/teams/{plan,spawn,spawn_execution,spawn_helpers,session_state}.rs, the corresponding HTTP types/routes, and src-tauri/src/commands/team_commands.rs.
• MCP proxy tools/handlers for request_team_plan, request_teammate_spawn, get_team_session_state, and save_team_session_state, including team-plan-handler.ts and focused tests.
• The dead typed verification-finding artifact surface: unrouted publish_verification_finding / get_verification_findings handlers and HTTP DTOs, ArtifactType::VerificationFinding, VerificationFindingMetadata / VerificationFindingGap, and their compatibility tests. Current Plan verification uses exact-artifact proof through complete_plan_verification, not fixed critic artifacts.
• The old frontend team runtime: frontend/src/api/team.ts, stores/teamStore.ts, legacy team hooks/components, chat team status/history UI, Claude-only Solo/Team execution selector, and their tests.
• The legacy team_mode UI feature flag/config/env gate and CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS writers/protection.
• src-tauri/manual_agent_teams_process.txt and documentation that presents Claude Agent Teams as supported RalphX behavior. The text file is an unreferenced manual transcript of CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS, TeamCreate, Claude Task(team_name), SendMessage, and manual teammate relaunch experiments, so it is legacy evidence rather than product documentation.
• The stray root ralphx-plugin/ralphx-mcp-server/package-lock.json and now-empty parent directories. The lockfile has an empty packages object and no adjacent manifest or source; the real MCP package remains under plugins/app/ralphx-mcp-server/.

Modify: compatibility and shared seams

• CoordinationMode, chat send/resumption, frontend conversation schemas, and SQLite constraints currently still admit legacy_claude_team.
• HarnessTeamCapabilities, agent capability validation, managed overlay resolution, availability helpers, lane/model/effort resolution, and process mappings still carry Claude-only branches.
• Chat/task/ideation creation and recovery paths still propagate legacy team_mode or metadata.agent_variant == "team" into the Claude runtime.
• App setup, server boot, runtime state, command factories, automation, ticketing, and tests carry TeamService only to satisfy old chat-service construction.
• src-tauri/src/http_server/handlers/teams/artifacts.rs mixes active artifact behavior with dead typed verification-finding behavior inside the legacy team namespace; relocate only active create/get artifact handlers mechanically while preserving their public contract.

Keep: current RX-native behavior only

• CoordinationMode::RxNativeTeam, native team intents/strategy, capability gates, delegated agent sessions, current task cards, and the delegate_start/wait/cancel authorization and transport paths.
• Canonical delegation.allowed_targets in active agents/*/agent.yaml, HarnessTeamCapabilities.rx_native_team, and provider-neutral agent-conversation team controls.
• create_team_artifact, get_team_artifacts, their HTTP contract, the team-findings bucket, artifact repository, and ArtifactType::{TeamResearch,TeamAnalysis,TeamSummary} because current RX-native agents actively use them.
• Provider-neutral native contracts: TeamIntent, TeamIntentStrategy, TeamMessageTarget, TeamMessageTargetKind, persisted RxNativeTeam queue/resume handling, and the current Agent conversation capability UI.
• The default/readonly/chat/history ProcessMapping / ProcessSlot registry consumed by the shared agent spawner for both Claude and Codex; extract it from the legacy-named team config module rather than deleting it.
• Existing migration files remain immutable as an audit trail; a new forward migration removes the legacy-only tables and data they introduced.
• Unrelated conversation messages and artifacts remain intact. Only legacy-exclusive columns/metadata/renderers are removed; shared active artifact records are not classified as legacy by name alone.

Implementation Sequence

Keep intermediate states compile-safe and prevent a migrated database from being opened by code that still expects removed columns:

1. Add failing desired-state tests for preserved RX-native behavior, strict current payloads, and the forward migration; inventory every legacy caller.
2. Remove legacy UI/API writers, backend readers, Claude agent/process selection, and control-plane registration while the old storage still exists.
3. Remove TeamService / TeamStateTracker wiring and implementations after reference search proves native coordination has no dependency on them; mechanically relocate the preserved artifact handlers.
4. Land the forward data/schema migration and narrow domain/API types in the same release slice, after runtime code no longer reads the removed storage.
5. Remove residual fixtures/docs/generated output, run focused validation, and enforce the zero-live-reference proof.

Affected Files

1. Normalize persisted coordination data and schemas after callers are removed

   • Add a forward migration under src-tauri/src/infrastructure/sqlite/migrations/ that: rewrites chat_conversations.coordination_mode = 'legacy_claude_team' to 'rx_native_team'; removes the entire agent_variant key from valid task metadata while preserving every unrelated metadata key; deletes obsolete verification_finding artifacts and their dependent relations; normalizes preserved team_research / team_analysis / team_summary metadata that still contains the synthetic team-lead author to an explicit backend/system legacy-attribution fallback; rewrites persisted team-findings.config_json to accept only the three preserved artifact types with backend/system writing; drops team_messages before team_sessions; drops ideation_sessions.team_mode and team_config_json; and rebuilds the conversation CHECK constraint without the legacy literal.
   • Do not infer RX-native activation from old ideation research / debate fields: those fields are discarded fail-closed. Only the explicit conversation-level legacy_claude_team value is converted to rx_native_team, matching the current next-send normalization behavior.
   • Preserve the active team-findings bucket and team_research / team_analysis / team_summary artifacts. Before deleting verification_finding rows, inventory every artifact-id reference, clear retained artifacts' self-FK previous_version_id when it targets a removed finding, and explicitly delete, clear, or assert absence for every other cascading and non-FK dependent pointer so no dangling reference survives. Use the established FK/legacy-alter-table restoration pattern, wrap destructive DML/DDL in an explicit transaction with rollback, recreate and verify dependent indexes/triggers during the CHECK rewrite, run PRAGMA foreign_key_check, and leave no *_new / *_old tables after success or injected failure.
   • Register the migration in MIGRATIONS, bump SCHEMA_VERSION, and add focused full-chain and direct migration tests. Do not provide a downgrade path that recreates deleted legacy data.
   • Remove only LegacyClaudeTeam from the provider-neutral coordination enum in src-tauri/crates/ralphx-domain/src/entities/team.rs; retain native team intent/mailbox types. Remove the legacy literal from frontend/src/types/chat-conversation.ts, API zod schemas/transforms, imports/exports, and fixtures.
   • Simplify src-tauri/src/application/chat_service/mod.rs, chat_resumption.rs, agent_capability_validation.rs, managed_team/overlay_resolver.rs, manual_router_config.rs, and manual_role_default_service.rs after the database and serializers can no longer produce the legacy variant.

2. Remove Claude-only capability, agent, and process selection

   • Remove legacy_native_team_tools from HarnessTeamCapabilities in src-tauri/crates/ralphx-domain/src/agents/harness.rs; retain rx_native_team.
   • Delete effective_team_mode_for_harness, harness_supports_team_mode, Claude-only availability helpers, and the team-lead branches in chat_service_helpers.rs, ideation_harness_availability.rs, agent lane/model/effort resolvers, and their tests.
   • Delete the four agents/ralphx-*-team-*/ directories and remove their aliases from Rust and plugins/app/ralphx-mcp-server/src/{agentNames,canonical-agent-metadata}.ts.
   • Remove only process_mapping.ideation.team, process_mapping.execution.team, and the entire team_constraints section from config/processes.yaml; rewrite its header as the provider-neutral process registry.
   • Mechanically extract ProcessMapping, ProcessSlot, canonical/default mapping load/overlay, and resolve_process_agent plus their non-team tests from agent_config/team_config.rs into a provider-neutral process-config module used by the shared spawner. Delete TeamMode, TeamConstraints*, teammate plan validation/presets/budget logic, legacy env overrides, and team-only tests. Preserve default/readonly/chat/history/custom variants and prove Claude and Codex spawner resolution still works.
   • Remove legacy labels from frontend/src/components/PermissionDialog.tsx and update agent-catalog/config validation tests to assert only active canonical agents.

3. Remove legacy activation and Claude spawn behavior

   • Remove the legacy team_mode: bool / AtomicBool flow from ChatService construction, task transitions, queued/recovered chat starts, ideation verification starts, and Claude command building/resumption.
   • Delete writers and protected-key handling for CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS in chat_service_context.rs and provider_env_file.rs.
   • Delete Claude teammate spawn types/functions/CLI arguments and their tests from src-tauri/src/infrastructure/agents/claude/**; preserve the normal Claude interactive process registry used by standard and RX-native chat.
   • Remove the entire task agent_variant input/metadata contract—not only the == "team" branch—from frontend task APIs, Tauri commands, restart/move flows, TaskTransitionService, queued/recovered execution starts, and tests. The migration removes the key regardless of its old value while preserving unrelated task metadata.
   • Remove ideation team_mode / team_config_json from the domain entity/builder, SQLite repository projections, session creation/linking/inheritance, verification/runtime starts, running-process views, commands/HTTP DTOs, session import/export, frontend API/types/mocks/renderers, and fixtures. Bump the portable ideation export format from schema v1 to v2 and reject v1 imports rather than silently preserving their removed team field; old command/HTTP payload fields receive the normal unknown/unsupported-field behavior of their owning boundary. Do not add a compatibility parser or runtime fallback.
   • Remove the legacy string target teammate-routing input and its team-store callers, but preserve the typed native team_message_target contract.

4. Remove the legacy control plane before deleting its implementation

   • Remove MCP registrations, routing branches, schemas, and tests for request_team_plan, request_teammate_spawn, get_team_session_state, and save_team_session_state from plugins/app/ralphx-mcp-server/src/**.
   • Remove the matching HTTP routes/types and handlers/teams/{plan,spawn,spawn_execution,spawn_helpers,session_state}.rs.
   • Mechanically extract only create_team_artifact / get_team_artifacts and their validation helpers from handlers/teams/artifacts.rs into the existing src-tauri/src/http_server/handlers/artifacts/ ownership seam (for example a leaf team_artifacts.rs re-exported by artifacts/mod.rs). Preserve /api/team/artifact, /api/team/artifacts/:session_id, model-facing request/response shapes, active MCP tool names, team-findings storage, and the team:artifact_created event contract. In the MCP proxy dispatch, inject the canonical AGENT_TYPE as hidden transport context (not a tool-schema field); validate it backend-side and record it as the active artifact's author_teammate, while the backend/system remains the bucket-authorized writer. Missing non-MCP attribution falls back explicitly to system, never team-lead.
   • Delete rather than relocate the unrouted publish_verification_finding / get_verification_findings functions, their HTTP DTOs, ArtifactType::VerificationFinding, metadata structs, bucket allowance, and tests.
   • Update active agent mcp_tools, process allowlists, canonical metadata, tool schemas, authorization, recovery hints, dispatch branches, and generated declarations together so no prompt mentions a removed tool and no registered removed tool is left unauthorized or unreachable.
   • Run npm run build in plugins/app/ralphx-mcp-server and commit the regenerated build/** output required by package policy.

5. Unwind the old live team runtime and persistence wiring

   • Remove callers of TeamService / TeamStateTracker from chat streaming/background send, startup cleanup, AppState, HTTP state, lib.rs, app/server boot, runtime state registration, automation, ticketing, question commands, unified commands, and their fixtures.
   • Delete team_state_tracker.rs, team_service.rs, team_stream_processor.rs, team_events.rs, team_commands.rs, and focused tests once no caller remains.
   • Delete the team session/message repository traits and memory/SQLite implementations after reference search confirms no active RX-native caller depends on them.
   • Remove team IPC commands from the Tauri command registry and startup “disband active teams” cleanup.
   • Drop team_sessions and team_messages in the new forward migration after all readers/writers are removed; leave the original historical migration file untouched.

6. Remove the Claude-only frontend workflow

   • Delete frontend/src/api/team.ts, stores/teamStore.ts, old team event/action/status/keyboard hooks, TeamContextBar/filter/cards/message/plan/system components, the components/Team/** split-pane view, legacy running-process TeamProcessGroup / TeammateProgressBar, and their tests after their imports are removed.
   • Simplify IntegratedChatPanel.tsx, ChatMessageList.tsx, global/pane lifecycle hooks, running-process views, task-detail views, and App.tsx navigation so they no longer hydrate, target, or render the old team service; preserve current Agent-conversation native delegation cards and typed native mailbox controls.
   • Mechanically extract the provider-generic Claude CLI TaskCreate / TaskUpdate / TaskList widgets from components/Chat/tool-widgets/TeamTaskWidgets.tsx into a neutral TaskWidgets.tsx leaf and preserve their registry entries/lazy-loading behavior. Delete only the Claude Team lifecycle TeamCreate / TeamDelete widgets and registry entries.
   • Remove the Claude-only Solo/Team task selector from both task-detail entry points and remove the mutation payload that writes agent_variant: "team".
   • Remove FeatureFlags.teamMode, RALPHX_UI_TEAM_MODE, useTeamModeAvailability, and the corresponding settings/config schema. Preserve the separate current agentConversationTeam feature/capability.
   • Remove UI branches and renderers that exist only for legacy Claude-team or ideation research / debate metadata, including the legacy PlanDisplay team summary/debate sections and IdeationSessionCard badge. Preserve generic artifact-pane rendering and active TeamResearch / TeamAnalysis / TeamSummary storage based on current artifact schemas, not a historical compatibility fallback.

7. Remove repository detritus and update documentation

   • Delete the entire root ralphx-plugin/ tree, currently only ralphx-plugin/ralphx-mcp-server/package-lock.json; do not move, merge, or regenerate it. Confirm plugins/app/ralphx-mcp-server/{package.json,package-lock.json,src/**,build/**} remains the sole canonical package and continues to build.
   • Keep the ralphx-plugin/ralphx-mcp-server/package-lock.json literal in src-tauri/crates/ralphx-domain/src/entities/agent_conversation_issue_tests.rs as an intentional regression fixture: it proves issue canonicalization deduplicates reports of this accidental setup artifact and is not a runtime dependency on the deleted path. Classify that fixture explicitly in the final reference audit rather than deleting the guard.
   • Delete src-tauri/manual_agent_teams_process.txt as captured legacy experiment output; no replacement or archival copy is needed because version control provides history.
   • Update CLAUDE.md, .claude/rules/ideation-verification-architecture.md, .claude/rules/orchestrator-ideation-workflows.md, .claude/rules/synthetic-failure-archetypes.md, .claude/rules/delegation-topology.md, .claude/rules/multi-harness.md, .claude/rules/agent-mcp-tools.md, docs/architecture/harness-specific-agent-config.md, docs/architecture/ideation-pipeline.md, docs/features/cross-project.md, active agent catalog docs, and user-facing team documentation to state that team orchestration is RalphX-native and provider-neutral and to remove deleted agent path triggers.
   • Delete docs/architecture/agent-teams-system-card.md, docs/architecture/agent-teams-context-relaunch.md, docs/architecture/agent-teams-context-relaunch-modifications.md, src-tauri/manual_agent_teams_process.txt, plugins/app/ralphx-mcp-server/TEAM_TOOLS_TESTS.md, and stale Claude Team sections/references; rely on version control for historical archaeology rather than keeping compatibility documentation in the live tree.
   • Preserve docs/architecture/native-agent-delegation-bridge.md and update cross-links to it.
   • Search for the final legacy vocabulary and classify every hit: immutable historical migration, vendor reference, active RX-native shared artifact name, or missed legacy code. There should be no compatibility fixture or live LegacyClaudeTeam, TeamCreate/TeamDelete, experimental-agent-teams env, team-lead agent, spawn/session-state endpoint, VerificationFinding contract, legacy feature flag, task agent_variant contract, or ideation team_mode / team_config_json contract.

Data / State

• First writer: current task/ideation UI and command paths can write legacy team_mode, team_config_json, or task agent_variant; remove these writers before deleting the readers and storage.
• First reader: chat creation/resumption, task transition/recovery, ideation verification, and legacy UI hydration currently consume those values; remove every reader before narrowing schemas or dropping tables.
• Forward migration order: normalize explicit legacy conversation coordination; scrub task metadata and obsolete verification artifacts/relations; drop team_messages then team_sessions; drop ideation activation columns; rebuild/narrow the conversation constraint; verify dependent schema/FKs; commit. Failure at any stage rolls back data/schema changes and restores PRAGMA state.
• Historical migrations remain immutable, but the resulting legacy schema/data is intentionally not retained. No production repository, DTO, serializer, import/export path, or renderer should understand the removed legacy records after migration.
• Shared TeamResearch / TeamAnalysis / TeamSummary artifacts and the team-findings bucket remain because they are active RX-native state. Obsolete VerificationFinding rows/types are deleted, persisted bucket configuration is narrowed, and the irrecoverable historical team-lead placeholder on preserved artifact metadata is normalized to system; newly published artifacts carry the MCP transport's validated canonical caller agent. Field-by-field call-site evidence, not “team” naming, decides whether artifact data is kept or removed.

Agent And MCP Surface

• The supported team surface after cleanup is canonical agent metadata plus delegate_start, delegate_wait, and delegate_cancel; the backend owns delegated session identity, dispatch, settlement, and terminal state.
• Remove Claude Team tools from agent YAML, prompts, process allowlists, MCP registration, HTTP routing, and authorization in the same slice.
• Preserve the shared artifact tools currently consumed by active ideation specialist/critic/advocate agents, even though their public names contain “team”; no active canonical execution agent currently justifies retaining a legacy execution-team agent. Keep caller identity out of the model schema: the MCP proxy injects canonical agent identity, backend validation owns trust, and the artifact handler removes its hard-coded team-lead author.
• Preserve typed native team_message_target routing and delete the legacy string teammate target; preserve delegate_start/wait/cancel and remove the old plan/spawn/session-state tools.
• Verify the canonical agent catalog, harness runtime config, live prompts, generated plugin metadata, and backend registration remain aligned per .claude/rules/agent-mcp-tools.md.

UI / UX

• Remove legacy Claude-only team history/status/filter/approval UI and its startup hydration; this should reduce chat-panel mount work.
• Preserve the current Agent conversation Team choice, RX-native delegated task cards, progress, cancellation, and completion/failure rendering.
• Existing conversations migrated from legacy should reopen as RX-native Team with no error or legacy badge.
• Existing task metadata or ideation records that mention old team mode must not expose a selectable legacy mode or silently launch a Claude team.
• Do not render legacy-only team metadata. Continue rendering only current artifact fields proven to be produced and consumed by RX-native delegation.

Progression Scenarios

1. New native team conversation: user selects Team in an Agent conversation → capability validation accepts RxNativeTeam for the chosen supported harness → backend runs native delegates → task cards/events settle normally.
2. Legacy conversation after upgrade: migration rewrites its coordination mode → conversation opens and resumes as RX-native Team → no legacy-read-only branch or Claude experimental env is reached.
3. Upgrade cleanup: the forward migration removes the entire task agent_variant key, ideation team_mode / team_config_json columns, obsolete verification-finding artifacts, and legacy session/message tables → post-upgrade schemas and APIs contain no compatibility reader or selectable legacy mode, while unrelated task metadata and active team artifacts remain.
4. Native delegated artifact: specialist publishes through create_team_artifact → preserved MCP/HTTP artifact path stores and retrieves it successfully after handler relocation.
5. Failure/cancel/recovery: native delegate launch failure, cancellation, app restart, and terminal settlement continue through delegated-session state; removed TeamService cleanup/disband code is never required.
6. Unsupported harness/capability: current capability validation rejects unsupported RX-native team requests without falling back to a Claude-only path.

Constraints

• Follow .claude/rules/delegation-topology.md, multi-harness.md, agent-mcp-tools.md, stateful-workflow-review.md, and task-state-machine.md.
• Treat this as the explicit removal/migration boundary required by the legacy-harness compatibility rule; do not leave mixed live paths.
• Use validated TaskTransitionService paths; do not add direct internal_status writes.
• Preserve unrelated user data and keep historical migration files immutable. This plan explicitly authorizes deletion of legacy-only team session/message data and deprecated activation metadata in a new forward migration.
• Keep changes compile-safe and reviewable: remove external callers/contracts first, then delete implementations and incidental dependency wiring.
• Use mechanical moves for the artifact-handler relocation; use apply_patch only for wiring/fix-up during implementation.
• Keep Rust formatting surgical to touched leaf files; never run broad cargo fmt.
• Rebuild generated MCP plugin output after source changes.

Avoid

• Do not delete or weaken RX-native delegation, current native Team capability gates, task-card state, or delegated-session recovery.
• Do not infer that every symbol containing “team” is legacy. In particular, do not remove active artifact tools/types, current native strategy/team intents/mailbox targets, or the shared default process registry without proving they have no current caller.
• Do not retrofit Claude Team concepts onto Codex or the provider-neutral native path.
• Do not keep prompts that narrate removed legacy tools, compatibility fallbacks, or migration history.
• Do not rewrite old migration files; remove their legacy-only resulting tables/data through a new forward migration.
• Do not preserve dead code, schema fields, serializers, import compatibility, or UI renderers behind a disabled feature flag; remove the legacy surface completely.
• Do not broaden this cleanup into renaming the active artifact public API unless it is handled as a separate, compatibility-planned change.
• Do not confuse the stray root lockfile with the canonical MCP package: remove only ralphx-plugin/, never plugins/app/ralphx-mcp-server/. Do not remove the issue-canonicalization regression fixture merely because it contains the deleted path as inert test data.

Decisions

• Migrate legacy conversation coordination to rx_native_team once, matching existing next-send semantics, then remove the legacy enum/literal everywhere outside immutable migration history.
• Remove the entire task agent_variant and ideation team_mode / team_config_json contracts from writers, readers, storage, DTOs, imports/exports, serializers, and projections; do not tolerate them through dedicated compatibility code.
• Convert only explicit conversation-level legacy_claude_team rows to rx_native_team; discard old ideation research/debate activation fail-closed, drop legacy session/message tables, and scrub deprecated activation metadata in the forward migration.
• Preserve active create_team_artifact / get_team_artifacts, TeamResearch / TeamAnalysis / TeamSummary, and native team intent/mailbox contracts; relocate artifact handler ownership but defer public renaming. Remove the dead fixed-verifier VerificationFinding contract.
• Remove all four Claude team lead/member agents and all team process presets rather than repointing them to native delegation.
• Keep one normal orchestration flow: model chooses allowed native delegate lenses; backend owns launch/wait/settlement.

Proof Obligations

• A repository-wide search has zero live references to LegacyClaudeTeam, legacy_claude_team, TeamCreate/TeamDelete, CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS, team-lead/team-member agent IDs, request_teammate_spawn, request_team_plan, team session-state tools, VerificationFinding, task agent_variant, ideation team_mode / team_config_json, or the legacy UI feature flag. Only immutable historical migration text, vendor reference material, or documented release history may retain legacy vocabulary.
• The migration converts seeded legacy conversation rows, removes seeded legacy metadata and obsolete verification artifacts, drops team_sessions / team_messages and ideation activation columns, preserves active team artifacts/bucket plus dependent schema objects, and leaves a schema that rejects the legacy coordination literal while accepting solo, rx_native_team, rx_native_workflow, and codex_native_ultra.
• Post-migration domain/API/import schemas have no legacy activation fields, VerificationFinding contract, or compatibility variants; ideation export schema v2 omits them and rejects v1, and stale legacy payloads cannot activate Claude teammate spawning or set the experimental env.
• Shared process mapping still resolves default/readonly/chat/history/custom agents for both Claude and Codex after the team config extraction; only the team variants and constraints are gone.
• RX-native Team works for every harness whose rx_native_team capability is true, and no branch special-cases Claude for native coordination.
• Native delegate start/wait/cancel, cancellation, restart/recovery, failure settlement, and task-card projection retain falsifiable behavioral coverage.
• Active delegated agents can still publish/read artifacts through the preserved contract; newly published summaries expose the validated canonical caller rather than team-lead, missing transport attribution falls back to system, the persisted team-findings bucket has no verification_finding or team-lead allowance, and preserved active artifacts contain no stale synthetic legacy author.
• App startup, HTTP server construction, chat send/resume, task transitions, automation, and ticketing build without TeamService/TeamStateTracker dependencies.
• Frontend renders current native Team controls/task cards and contains no import, command invocation, persisted store hydration, or UI affordance for the old live team subsystem.
• Canonical agent metadata, MCP schemas, process allowlists, prompts, backend registration, and generated plugin build agree on the final tool surface.
• ralphx-plugin/ and src-tauri/manual_agent_teams_process.txt are absent from the repository, while plugins/app/ralphx-mcp-server/ still contains the canonical manifest, lockfile, source, and regenerated build. The only permitted deleted-root-path reference is the explicit issue-canonicalization regression fixture.

Testing Strategy

Use TDD for preserved behavior and desired-state guards: first add focused tests that fail because the migration has not normalized/deleted legacy state, current schemas still accept legacy inputs, or native behavior lacks a preservation assertion; then remove the legacy code. Delete tests whose only purpose was exercising removed implementations rather than replacing them with line-execution or compile-failure tests.

Rust

• Add focused direct and full-chain migration tests for explicit coordination conversion, fail-closed ideation-field removal, complete agent_variant key removal with unrelated metadata preserved, obsolete verification-artifact deletion, cascading/non-FK dependency cleanup, retained-artifact previous_version_id repair, persisted team-findings config narrowing, synthetic team-lead metadata normalization, active team-artifact preservation, child-before-parent table removal, narrowed CHECK behavior, index/trigger/FK preservation, idempotency/retry safety, and injected-failure rollback with no leftover rebuild tables.
• Update focused domain/application tests for coordination parsing, conversation send/queue/resume, capability validation, overlay resolution, task transition/recovery without agent_variant, ideation export v2 plus v1 rejection, typed native mailbox routing, shared Claude/Codex process resolution, native delegation settlement, and current verification exact-proof behavior.
• Replace historical-compatibility fixtures with behavioral absence assertions at live boundaries: stale payloads cannot activate a Claude team; removed tables fail schema inspection; no launch path sets the experimental env, spawns a legacy teammate, creates TeamService state, or emits removed lifecycle events. Use repository zero-reference checks for deleted types rather than non-compiling tests.
• Run only touched focused filters/suites per .claude/rules/rust-test-execution.md, using root-lib cargo test ... --features test-utils <single-filter> and cargo nextest run --test <suite> -E 'test(<focused-name>)' for integration suites.
• Run rustfmt --edition 2021 --check <touched-leaf.rs> for every modified Rust leaf file; never run it on mod.rs roots.
• Run python3 scripts/check-layering.py because handler/module ownership and runtime wiring change.
• Run the focused package_lock_drift_dedupes_across_agent_wording Rust test to preserve detection/deduplication of reports naming either the canonical lockfile or the deleted accidental root path, and assert by repository path inspection that the stray tree and manual transcript are gone.

Frontend

• Update focused Testing Library tests for the Agent conversation Team selector/task cards, migrated conversation display, typed native mailbox controls, task detail without the legacy selector, IntegratedChatPanel without legacy hydration, App navigation without the old Team split view, and the neutral TaskWidgets registry retaining TaskCreate/TaskUpdate/TaskList while dropping TeamCreate/TeamDelete.
• Assert user-visible current native Team behavior, lightweight/lazy interaction behavior, and absence of legacy affordances—not deleted implementation internals.
• Run cd frontend && npm run test:run -- <touched test files>, then npm run typecheck; run targeted lint only for touched frontend files if supported.

MCP plugin

• Update workflow-tools, canonical metadata, routing, and artifact-dispatch tests to assert removed tools are absent, preserved artifact/delegation tools remain, caller identity is injected from AGENT_TYPE rather than accepted from model arguments, unknown/missing attribution follows the specified validation/fallback behavior, and no artifact writer emits team-lead.
• Run cd plugins/app/ralphx-mcp-server && npm test -- <focused test files>.
• Run cd plugins/app/ralphx-mcp-server && npm run build and verify the generated build/** diff contains the same removals.

Final false-success review

Before handoff, follow .claude/rules/big-pr-review-checklist.md and .claude/rules/stateful-workflow-review.md: check migration ordering/rollback, absence of stale persisted modes and compatibility readers, event ordering, restart recovery, capability/prompt/schema drift, artifact route preservation, single-writer ownership, and scope leakage. Review the complete diff against HEAD and report any unrelated pre-existing failures without expanding scope.

---

Generated by RalphX

[codecov]

Codecov Report

✅ All modified and coverable lines are covered by tests.

📢 Thoughts on this report? Let us know!