Run Codex Subagents and Skills natively

apps/daemon/internal/agent/codex/harness_config_test.go

@@ -8,6 +8,7 @@ import (
 	"github.com/MiniMax-AI/OpenAgentCore/internal/agentdaemon/proto"
 	"github.com/MiniMax-AI/OpenAgentCore/internal/harnessconfig"
 	"slices"
+	"strings"
 	"testing"
 )
 
@@ -40,7 +41,7 @@ func TestHarnessConfigConflictFailsBeforePreparation(t *testing.T) {
 	}
 }
 
-func TestReasoningEffortReachesEveryNativeTurn(t *testing.T) {
+func TestNativeTurnsCarryNoCollaborationMode(t *testing.T) {
 	for _, resumeID := range []string{"", "fixture-native-thread"} {
 		t.Run("resume="+resumeID, func(t *testing.T) {
 			req, cfg, root := preparationFixture(t)
@@ -78,13 +79,8 @@ func TestReasoningEffortReachesEveryNativeTurn(t *testing.T) {
 				if frame.Method != "turn/start" {
 					continue
 				}
-				var wire struct {
-					CollaborationMode struct {
-						Settings map[string]any `json:"settings"`
-					} `json:"collaborationMode"`
-				}
-				if json.Unmarshal(frame.Params, &wire) != nil || wire.CollaborationMode.Settings["reasoning_effort"] != "high" {
-					t.Fatal("Turn lost the frozen native reasoning effort", string(frame.Params))
+				if strings.Contains(string(frame.Params), "ollaborationMode") {
+					t.Fatal("turn/start must not carry a collaboration mode", string(frame.Params))
 				}
 			}
 			method := "thread/start"

apps/daemon/internal/agent/codex/preparation.go

@@ -92,7 +92,7 @@ func newPreparation(parent context.Context, req proto.PromptRequestPayload, cfg
 		}
 	}
 	if s.observeSubagentIdentities {
-		if err := verifySubagentObservationProfile(cancelCtx, rpc, plan.Cwd); err != nil {
+		if err := verifySubagentObservationProfile(cancelCtx, rpc); err != nil {
 			return p.preparationFailed(err)
 		}
 	}

apps/daemon/internal/agent/codex/protocol.go

@@ -164,28 +164,12 @@ type UserInput struct {
 }
 
 type TurnStartParams struct {
-	ThreadID          string             `json:"threadId"`
-	Input             []UserInput        `json:"input"`
-	CollaborationMode *CollaborationMode `json:"collaborationMode,omitempty"`
+	ThreadID string      `json:"threadId"`
+	Input    []UserInput `json:"input"`
 	// OutputSchema constrains this Turn's final assistant message natively.
 	OutputSchema json.RawMessage `json:"outputSchema,omitempty"`
 }
 
-type CollaborationModeKind string
-
-const CollaborationModeDefault CollaborationModeKind = "default"
-
-type CollaborationMode struct {
-	Mode     CollaborationModeKind     `json:"mode"`
-	Settings CollaborationModeSettings `json:"settings"`
-}
-
-type CollaborationModeSettings struct {
-	ReasoningEffort       string  `json:"reasoning_effort,omitempty"`
-	Model                 string  `json:"model"`
-	DeveloperInstructions *string `json:"developer_instructions"`
-}
-
 type TurnInterruptParams struct {
 	ThreadID string `json:"threadId"`
 	TurnID   string `json:"turnId"`

apps/daemon/internal/agent/codex/protocol_wire_test.go

@@ -49,29 +49,3 @@ func TestThreadStartParams_ModelProviderIsCamelCaseField(t *testing.T) {
 		t.Fatalf("snake_case model_provider leaked: %s", body)
 	}
 }
-
-func TestTurnStartParams_CollaborationModeWireShape(t *testing.T) {
-	developerInstructions := "stay within the configured workspace"
-	params := TurnStartParams{
-		ThreadID: "thread-1",
-		Input:    []UserInput{{Type: UserInputText, Text: "ask me a question"}},
-		CollaborationMode: &CollaborationMode{
-			Mode: CollaborationModeDefault,
-			Settings: CollaborationModeSettings{
-				Model:                 "MiniMax-M3",
-				DeveloperInstructions: &developerInstructions,
-			},
-		},
-	}
-	raw, err := json.Marshal(params)
-	if err != nil {
-		t.Fatalf("marshal: %v", err)
-	}
-	body := string(raw)
-	if !strings.Contains(body, `"collaborationMode":{"mode":"default","settings":{"model":"MiniMax-M3","developer_instructions":"stay within the configured workspace"}}`) {
-		t.Fatalf("collaboration mode missing or malformed: %s", body)
-	}
-	if strings.Contains(body, `"collaboration_mode"`) {
-		t.Fatalf("snake_case collaboration_mode leaked: %s", body)
-	}
-}

apps/daemon/internal/agent/codex/session_plan.go

@@ -65,10 +65,6 @@ func prepareSessionPlan(ctx context.Context, req proto.PromptRequestPayload, cfg
 	}
 	var skillRoots []string
 	if req.LocalEnvironment != nil && len(req.LocalEnvironment.Skills) > 0 {
-		if err := verifyHostedSkills(req.LocalEnvironment.Skills); err != nil {
-			plan.Cleanup()
-			return SessionPlan{}, nil, err
-		}
 		for _, skill := range req.LocalEnvironment.Skills {
 			skillRoots = append(skillRoots, localworkspace.SkillPath(skill))
 		}

apps/daemon/internal/agent/codex/session_run.go

@@ -3,7 +3,6 @@ package codex
 import (
 	"context"
 	"fmt"
-	"strings"
 	"time"
 
 	"github.com/MiniMax-AI/OpenAgentCore/internal/agentdaemon/proto"
@@ -25,22 +24,6 @@ func (s *Session) startNative(ctx context.Context, plan SessionPlan, req proto.P
 		Input:        input,
 		OutputSchema: plan.OutputSchema,
 	}
-	model := strings.TrimSpace(s.resolvedModel)
-	if model == "" {
-		return fmt.Errorf("codex: collaboration mode requires a resolved model")
-	}
-	var developerInstructions *string
-	if plan.SystemPrompt != "" {
-		developerInstructions = &plan.SystemPrompt
-	}
-	turnParams.CollaborationMode = &CollaborationMode{
-		Mode: CollaborationModeDefault,
-		Settings: CollaborationModeSettings{
-			ReasoningEffort:       plan.ModelReasoningEffort,
-			Model:                 model,
-			DeveloperInstructions: developerInstructions,
-		},
-	}
 	turnCtx, turnCancel := context.WithTimeout(ctx, 10*time.Second)
 	_, ackErr := s.rpc.requestWithResult(turnCtx, "turn/start", turnParams, s.bindTurnResult)
 	turnCancel()

apps/daemon/internal/agent/codex/subagent_profile.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
-	"slices"
 	stdstrconv "strconv"
 
 	"github.com/MiniMax-AI/OpenAgentCore/internal/agentdaemon/proto"
@@ -14,14 +13,8 @@ func configureSubagentObservations(plan *SessionPlan, req proto.PromptRequestPay
 	if !req.ObserveSubagentIdentities || req.DisableSubagents {
 		return nil
 	}
-	for _, feature := range []string{"hooks", "plugins", "code_mode", "code_mode_only", "code_mode_prewarm", "multi_agent_v2"} {
-		if !slices.Contains(plan.DisableFeatures, feature) {
-			plan.DisableFeatures = append(plan.DisableFeatures, feature)
-		}
-		plan.ExtraConfig = append(plan.ExtraConfig, [2]string{"features." + feature, "false"})
-	}
 	plan.EnableFeatures = append(plan.EnableFeatures, "multi_agent")
-	plan.ExtraConfig = append(plan.ExtraConfig, [2]string{"features.multi_agent", "true"}, [2]string{"agents.max_depth", "64"})
+	plan.ExtraConfig = append(plan.ExtraConfig, [2]string{"features.multi_agent", "true"})
 	if req.MaxConcurrentSubagents != nil {
 		if *req.MaxConcurrentSubagents < 1 {
 			return errors.New("codex: invalid subagent concurrency limit")
@@ -31,38 +24,24 @@ func configureSubagentObservations(plan *SessionPlan, req proto.PromptRequestPay
 	return nil
 }
 
-func verifySubagentObservationProfile(ctx context.Context, rpc *JSONRPCClient, cwd string) error {
-	hooks, err := readNativeToolHooks(ctx, rpc, cwd)
-	if err != nil {
-		return err
-	}
-	if len(hooks) != 0 {
-		return errors.New("codex: subagent observation requires hooks disabled")
-	}
-
+// Code-mode collaboration calls and multi_agent_v2 leave no persisted receipt, so
+// managed requirements that force them cannot be observed.
+func verifySubagentObservationProfile(ctx context.Context, rpc *JSONRPCClient) error {
 	raw, err := rpc.Request(ctx, "configRequirements/read", nil)
 	var response struct {
 		Requirements *struct {
-			AllowManagedHooksOnly bool            `json:"allowManagedHooksOnly"`
-			Features              map[string]bool `json:"featureRequirements"`
+			Features map[string]bool `json:"featureRequirements"`
 		} `json:"requirements"`
 	}
 	if err != nil || json.Unmarshal(raw, &response) != nil {
-		return errors.New("codex: subagent hook requirements unavailable")
+		return errors.New("codex: subagent feature requirements unavailable")
 	}
 	if response.Requirements == nil {
-		if len(hooks) != 0 {
-			return errors.New("codex: managed-only subagent hooks are not enforced")
-		}
 		return nil
 	}
-	requirements := response.Requirements
-	if (len(hooks) != 0 || requirements.Features["hooks"]) && !requirements.AllowManagedHooksOnly {
-		return errors.New("codex: managed-only subagent hooks are not enforced")
-	}
-	for _, feature := range []string{"plugins", "code_mode", "code_mode_only", "code_mode_prewarm", "multi_agent_v2"} {
-		if requirements.Features[feature] {
-			return errors.New("codex: required feature conflicts with subagent observation profile")
+	for _, feature := range []string{"code_mode", "code_mode_only", "code_mode_prewarm", "multi_agent_v2"} {
+		if response.Requirements.Features[feature] {
+			return errors.New("codex: required feature conflicts with subagent observation")
 		}
 	}
 	return nil