controller

type ACPAcquireSessionLeaseRequest struct {
	Session             store.SessionControl
	Fence               store.ControllerEpochFence
	TaskName            string
	TaskUID             string
	Attempt             int64
	PromptID            string
	PromptRequestDigest string
	AcquiredAt          time.Time
	ExpiresAt           *time.Time

	// NamespaceUID, RuntimeIdentity, and ConfigDigest establish or verify the
	// Kubernetes-authoritative Session protocol/runtime lineage atomically with
	// the lease status CAS when lineage projection is configured.
	NamespaceUID      string
	ContractVersion   corev1alpha1.AgentRuntimeContractVersion
	LineageGeneration int64
	RuntimeIdentity   string
	ConfigDigest      string
}

type ACPAdmissionGate struct {
	// contains filtered or unexported fields
}

type ACPBootstrapLimits struct {
	MaxMessages     int
	MaxBytes        int
	MaxMessageBytes int
}

type ACPBootstrapMessage struct {
	Role       string `json:"role"`
	Content    string `json:"content"`
	Name       string `json:"name,omitempty"`
	ToolCallID string `json:"toolCallID,omitempty"`
}

type ACPBootstrapTranscript struct {
	SessionUID       string
	Messages         []ACPBootstrapMessage
	Artifact         []byte
	Digest           string
	MessageCount     uint32
	TotalMessages    int
	Truncated        bool
	VerifiedBaseline *store.VerifiedBranchBaseline
}

type ACPDispatcher struct {
	Client                   client.Client
	APIReader                client.Reader
	Store                    store.DurableControlStore
	ResultStore              store.ResultStore
	EventStore               store.ExecutionEventStore
	PlanStore                store.PlanStore
	Snapshots                store.AgentExecutionSnapshotStore
	Epochs                   *ControllerEpochManager
	Sessions                 *ACPSessionContinuity
	Publisher                *publisherservice.Client
	ArtifactCapabilitySecret []byte
	ArtifactReservations     artifactcap.CapabilityReservationRecorder
	MCPRegistry              *tools.Registry
	Interval                 time.Duration
	MaxConcurrent            int
	IdlePoolTTL              time.Duration
	ReservationTTL           time.Duration
	RateLimitRetryInterval   time.Duration
	AdmissionGate            *ACPAdmissionGate
	ACPRuntimeImages         ACPRuntimeImages

	// SubstrateRouterURL and SubstrateActorDNSSuffix route Substrate-backed
	// RuntimePool instances through the provider router while preserving the
	// exact actor route host. Empty values fail closed for substrate pools.
	SubstrateRouterURL      string
	SubstrateActorDNSSuffix string
	// contains filtered or unexported fields
}

type ACPEnsureSessionRequest struct {
	Namespace                 string
	SessionName               string
	SessionType               string
	ExpectedSessionUID        string
	RequireExistingTranscript bool
	Fence                     store.ControllerEpochFence
	CreatedAt                 time.Time
}

type ACPExecutionWorkspaceAdapterReconciler struct {
	client.Client
	APIReader client.Reader
	// RuntimeNamespace is the controller-configured ACP runtime namespace
	// where workspace-backed pools place their provider children (the
	// SandboxClaim and its realized durable PVC); empty means the workspace
	// namespace.
	RuntimeNamespace string
}

type ACPFinalizationProjection struct {
	ID             string
	ProjectionKind string
	Payload        json.RawMessage
	AvailableAt    time.Time
}

type ACPFinalizeAssistantRequest struct {
	SessionTurn     ACPSessionTurn
	Fence           store.ControllerEpochFence
	AssistantResult string
	PublicationID   string
	Projection      ACPFinalizationProjection
	FinalizedAt     time.Time
}

type ACPFinalizeOutcomeMarkerRequest struct {
	SessionTurn ACPSessionTurn
	Fence       store.ControllerEpochFence
	Kind        string
	Reason      string
	Projection  ACPFinalizationProjection
	FinalizedAt time.Time
}

type ACPFinalizeOutcomeUnknownRequest struct {
	SessionTurn   ACPSessionTurn
	Fence         store.ControllerEpochFence
	Reason        string
	PublicationID string
	Projection    ACPFinalizationProjection
	FinalizedAt   time.Time
}

type ACPIndependentBranchReceipt struct {
	OperationID  string
	RepositoryID string
	Ref          string
	SHA          string
	VerifiedAt   time.Time
	Digest       string
}

type ACPMCPAuthenticatedTask struct {
	Name         string
	Namespace    string
	UID          string
	ParentTaskID string
	AgentName    string
}

type ACPMCPBroker struct {
	Credentials    ACPMCPBrokerCredentialResolver
	Prompts        ACPMCPPromptAuthorizer
	Executor       ACPMCPToolExecutor
	Effects        store.ExternalEffectStore
	EpochMutations store.ControllerEpochMutationStore
	MaxBodyBytes   int64
}

type ACPMCPBrokerCredentialResolver interface {
	ResolveACPMCPBrokerCredentials(context.Context, harnessv2.MCPBrokerCallRequest) (ACPMCPBrokerCredentials, error)
}

type ACPMCPBrokerCredentialResolverFunc func(context.Context, harnessv2.MCPBrokerCallRequest) (ACPMCPBrokerCredentials, error)

type ACPMCPBrokerCredentials struct {
	ControllerBearerToken string
	CapabilitySecret      []byte
	ExpectedFence         harnessv2.Fence
	RuntimeProfile        harnessv2.RuntimeProfile
	// ExpectedMCPConfiguration freezes the exact prompt-scoped tool and
	// approval policy for external runtimes. RuntimePool callers leave it nil
	// because their controller-owned supervisor receives the same policy.
	ExpectedMCPConfiguration *harnessv2.MCPPolicyConfiguration
	ControllerFence          store.ControllerEpochFence
	Task                     ACPMCPAuthenticatedTask
}

type ACPMCPBrokerDependencies struct {
	Reader                  client.Reader
	Epochs                  *ControllerEpochManager
	ControlStore            store.DurableControlStore
	AgentExecutionSnapshots store.AgentExecutionSnapshotStore
	KubeClient              kubernetes.Interface
	HTTPClient              *http.Client
	Registry                *tools.Registry
	OutboundAccess          outboundaccess.Resolver
	TransactionExchange     *workerexecutor.TransactionExchangeConfig
	ContextFactory          func(context.Context, harnessv2.MCPBrokerCallRequest) (*tools.ToolContext, error)

	// EnforceTransactionCredentialAuth and TransactionCredentialReadScopes bind
	// brokered custom-Tool executions to the authenticated Task's transaction
	// authority; see RegistryACPMCPToolExecutor.
	EnforceTransactionCredentialAuth bool
	TransactionCredentialReadScopes  []string
}

type ACPMCPBrokerPreAuthenticator interface {
	PreAuthenticateACPMCPBroker(ctx context.Context, poolNamespace, poolUID, authorizationHeader string) error
}

type ACPMCPPromptAuthorizer interface {
	AuthorizeACPMCPPrompt(context.Context, harnessv2.MCPBrokerCallRequest) error
}

type ACPMCPPromptAuthorizerFunc func(context.Context, harnessv2.MCPBrokerCallRequest) error

type ACPMCPTaskDataGuard func(context.Context, func(context.Context) error) error

type ACPMCPToolExecutor interface {
	ExecuteACPMCPTool(context.Context, harnessv2.MCPBrokerCallRequest, harnessv2.MCPToolDescriptor) (json.RawMessage, error)
}

type ACPMCPToolExecutorFunc func(context.Context, harnessv2.MCPBrokerCallRequest, harnessv2.MCPToolDescriptor) (json.RawMessage, error)

type ACPOpenSessionTurnRequest struct {
	Lease                ACPSessionLease
	Fence                store.ControllerEpochFence
	PromptAttemptID      string
	PromptRequestDigest  string
	UserPrompt           string
	SkipTranscriptAppend bool
	SkipUserPromptAppend bool
	OpenedAt             time.Time
}

type ACPOutboxProjector struct {
	Client      client.Client
	Store       store.OutboxProjectionStore
	Epochs      *ControllerEpochManager
	WorkerID    string
	Interval    time.Duration
	MaxAttempts int64
}

type ACPPublicationReclaimer interface {
	ReclaimPublication(context.Context, publisherservice.PublicationReclaimRequest) (publisherservice.PublicationReclaimResponse, error)
}

type ACPRecoverBlockedSessionRequest struct {
	Namespace   string
	SessionName string
	SessionUID  string
	Fence       store.ControllerEpochFence
	Receipt     ACPIndependentBranchReceipt
}

type ACPReleaseSessionLeaseRequest struct {
	Lease      ACPSessionLease
	Fence      store.ControllerEpochFence
	ReleasedAt time.Time
}

type ACPResumeSessionTurnFinalizationRequest struct {
	SessionTurn ACPSessionTurn
	Fence       store.ControllerEpochFence
}

type ACPRuntimeImages struct {
	Codex    string
	Claude   string
	Copilot  string
	Opencode string
}

type ACPRuntimePlan struct {
	PoolName string
	Image    string
	Profile  harnessv2.RuntimeProfile
	Digest   harnessv2.ProfileDigest
	// Workspace, when set, binds the pool to an execution-workspace provider.
	// It changes PoolName so workspace-backed sessions never share a plain pool.
	Workspace *ACPRuntimeWorkspaceBinding
}

type ACPRuntimeSessionBinding struct {
	SessionUID         string
	Generation         uint64
	ProfileDigest      harnessv2.ProfileDigest
	RuntimeInstanceID  harnessv2.RuntimeInstanceID
	SupervisorBootID   harnessv2.SupervisorBootID
	WorkspaceDigest    string
	MCPDigest          string
	RecreationRequired bool
}

type ACPRuntimeSessionPlan struct {
	Binding           ACPRuntimeSessionBinding
	Recreate          bool
	BootstrapRequired bool
	Reason            string
}

type ACPRuntimeWorkspaceBinding struct {
	Provider      corev1alpha1.WorkspaceProvider
	ReusePolicy   corev1alpha1.WorkspaceReusePolicy
	CleanupPolicy corev1alpha1.WorkspaceCleanupPolicy
	WorkspaceSlot string
	// SessionUID is the immutable durable SessionControl identity when
	// ReusePolicy is session. It is empty for per-Task workspaces.
	SessionUID string
	// SessionKey scopes the physical workspace to one logical RuntimeSession:
	// the immutable Session UID under reusePolicy session, or the exact Task UID
	// otherwise.
	SessionKey string
	// TemplateNamespace and TemplateName reference the operator-owned Substrate
	// infrastructure ActorTemplate. They are set exactly when Provider is
	// substrate: agent-sandbox workloads run only controller-rendered templates.
	TemplateNamespace string
	TemplateName      string
	// Class is the frozen controller-first ExecutionWorkspaceClass binding for
	// class-selected workspaces. It is nil for legacy provider-shaped requests.
	Class *ACPWorkspaceClassBinding
	// RestoreFrom is a provider-neutral immutable Data checkpoint reference.
	RestoreFrom *corev1alpha1.WorkspaceCheckpointReference
	// BindingDigest is the canonical digest over the fields above. It is part
	// of the RuntimePool identity.
	BindingDigest string
}

type ACPSandboxDurableVolume struct {
	StorageClassName string
	// StorageClassUID pins the exact StorageClass whose Delete reclaim
	// semantics were validated at class resolution; provisioning reverifies
	// it so a same-name replacement class cannot silently retain volumes.
	StorageClassUID string
	AccessModes     []string
	Capacity        string
}

type ACPSessionContinuity struct {
	// contains filtered or unexported fields
}

type ACPSessionContinuityConfig struct {
	SessionControls store.SessionControlStore
	Transcripts     store.SessionStore
	GatewayEvents   store.GatewayEventStore
	Publications    store.PublicationStore
	BranchClaims    store.BranchClaimStore
	BootstrapLimits ACPBootstrapLimits
	NewSessionUID   func() (string, error)

	// Lineages receives an idempotent SQLite payload projection only after the
	// Kubernetes SessionControl store has established or verified lineage in
	// the same status CAS that records the mutation Lease.
	Lineages store.SessionLineageStore
}

type ACPSessionFinalization struct {
	Turn    store.SessionTurn
	Session store.SessionControl
}

type ACPSessionLease struct {
	Session store.SessionControl
	Key     store.SessionTurnKey
}

type ACPSessionTurn struct {
	Lease                ACPSessionLease
	Turn                 store.SessionTurn
	SkipTranscriptAppend bool
	SkipUserPromptAppend bool
}

type ACPUpgradeDrainBarrierObserver interface {
	ObserveACPUpgradeDrainBarriers(context.Context) (ACPUpgradeDrainBarrierSnapshot, error)
}

type ACPUpgradeDrainBarrierObserverFunc func(context.Context) (ACPUpgradeDrainBarrierSnapshot, error)

type ACPUpgradeDrainBarrierSnapshot struct {
	UnsettledOutboxProjections int64 `json:"unsettledOutboxProjections"`
	NonterminalPromptAttempts  int64 `json:"nonterminalPromptAttempts"`
	ActiveSessionControls      int64 `json:"activeSessionControls"`
	NonterminalPublications    int64 `json:"nonterminalPublications"`
	NonterminalExternalEffects int64 `json:"nonterminalExternalEffects"`
}

type ACPUpgradeDrainCoordinator struct {
	Client              client.Client
	APIReader           client.Reader
	Epochs              ACPUpgradeDrainEpochSource
	EpochStore          store.ControllerEpochStore
	AdmissionGate       *ACPAdmissionGate
	Barriers            ACPUpgradeDrainBarrierObserver
	SupervisorClient    RuntimePoolSupervisorClient
	HTTPClient          *http.Client
	SubstrateConfig     SubstrateConfig
	ControllerNamespace string
	Options             ACPUpgradeDrainOptions
	Now                 func() time.Time
	// contains filtered or unexported fields
}

type ACPUpgradeDrainEpochSource interface {
	CurrentFence(context.Context) (store.ControllerEpochFence, error)
}

type ACPUpgradeDrainMarker struct {
	Version             string                     `json:"version"`
	State               ACPUpgradeDrainMarkerState `json:"state"`
	ControllerEpochName string                     `json:"controllerEpochName"`
	ControllerEpoch     int64                      `json:"controllerEpoch"`
	HolderID            string                     `json:"holderID"`
	StartedAt           time.Time                  `json:"startedAt"`
	Deadline            time.Time                  `json:"deadline"`
	CompletedAt         *time.Time                 `json:"completedAt,omitempty"`
	TimedOutAt          *time.Time                 `json:"timedOutAt,omitempty"`
	LastError           string                     `json:"lastError,omitempty"`
	Snapshot            ACPUpgradeDrainSnapshot    `json:"snapshot"`
}

type ACPUpgradeDrainMarkerState string

type ACPUpgradeDrainOptions struct {
	BindAddress       string
	Timeout           time.Duration
	PollInterval      time.Duration
	MarkerNamespace   string
	WatchNamespace    string
	RuntimePoolLabels map[string]string
	TriggerURL        string
	TriggerTimeout    time.Duration
}

type ACPUpgradeDrainOutboxBarrier interface {
	CountUnsettledOutboxProjections(context.Context) (int64, error)
}

type ACPUpgradeDrainOutboxBarrierFunc func(context.Context) (int64, error)

type ACPUpgradeDrainPhase string

type ACPUpgradeDrainSnapshot struct {
	ObservedPools              int                            `json:"observedPools"`
	PoolsAwaitingQuiescence    int                            `json:"poolsAwaitingQuiescence"`
	QueuedTasks                int64                          `json:"queuedTasks"`
	ReservedSessions           int64                          `json:"reservedSessions"`
	ReservedPrompts            int64                          `json:"reservedPrompts"`
	ReservationRecords         int64                          `json:"reservationRecords"`
	RunningPrompts             int64                          `json:"runningPrompts"`
	ResidentSessions           int64                          `json:"residentSessions"`
	FinalizingSessions         int64                          `json:"finalizingSessions"`
	PendingPermissions         int64                          `json:"pendingPermissions"`
	LiveDescendants            int64                          `json:"liveDescendants"`
	QueuedSupervisorAdmissions int64                          `json:"queuedSupervisorAdmissions"`
	Barriers                   ACPUpgradeDrainBarrierSnapshot `json:"barriers"`
}

type ACPUpgradeDrainStatus struct {
	Phase           ACPUpgradeDrainPhase    `json:"phase"`
	ControllerEpoch int64                   `json:"controllerEpoch,omitempty"`
	TriggeredAt     *time.Time              `json:"triggeredAt,omitempty"`
	Deadline        *time.Time              `json:"deadline,omitempty"`
	CompletedAt     *time.Time              `json:"completedAt,omitempty"`
	LastError       string                  `json:"lastError,omitempty"`
	Snapshot        ACPUpgradeDrainSnapshot `json:"snapshot"`
}

type ACPWorkspaceClassBinding struct {
	Name               string
	UID                string
	Generation         int64
	ProfileHash        string
	ProviderName       string
	ProviderUID        string
	ProviderGeneration int64
	// ProviderConfigUID pins the exact cluster-scoped RuntimeProviderConfig
	// that selected the physical backend: recreating the immutable config
	// under the same name must read as drift, never as a silent backend swap.
	ProviderConfigUID string
	// EffectiveOnDetach is the validated detach action for this Task: the
	// Task-requested value when the class allows it, otherwise the class
	// default. Delete is always executable; Suspend is executable only for
	// session-reused workspaces whose backend profile permits DataOnly
	// suspension.
	EffectiveOnDetach string
	// SuspendMode freezes the operator-permitted suspension scope from the
	// class profile. Empty means suspension is not permitted; DataOnly is the
	// only supported value.
	SuspendMode string
	// SandboxVolume freezes the durable workspace PVC shape for
	// suspend-capable agent-sandbox classes. It is nil for every other class.
	SandboxVolume *ACPSandboxDurableVolume
	// MaxSuspendedWorkspaces freezes the class retention cap. Nil means
	// per-workspace age must be bounded by idleTimeout or maxLifetime.
	MaxSuspendedWorkspaces *int32
	// DefaultOnDetach and AllowedOnDetach freeze the class lifecycle policy in
	// class order so the materialized ExecutionWorkspace carries the exact
	// class lifecycle and never drifts from it.
	DefaultOnDetach string
	AllowedOnDetach []string
	DetachTimeout   string
	IdleTimeout     string
	MaxLifetime     string
	DeletionPolicy  ACPWorkspaceClassDeletionPolicy
}

type ACPWorkspaceClassDeletionPolicy struct {
	ProviderResources string
	PersistentVolumes string
	Checkpoints       string
}

type ACPWorkspaceProviderAdapterReconciler struct {
	client.Client
	AgentSandboxEnabled          bool
	SubstrateEnabled             bool
	SubstrateDirectEgressEnabled bool
	SubstrateCheckpointsEnabled  bool
	ACPWorkspaceDispatchEnabled  bool
	WorkspaceProviderAPIEnabled  bool
	Now                          func() time.Time
}

type ACPWorkspaceRetentionReconciler struct {
	client.Client
	// APIReader bypasses the informer cache for suspended-capacity counts so
	// a quota claim never trusts a stale list. Falls back to Client when nil.
	APIReader client.Reader
	// DurableControlStore resolves immutable Session identities for unlinked
	// continuation Tasks. Without it, retention keeps demand fail-closed.
	DurableControlStore store.DurableControlStore
	Recorder            events.EventRecorder
	Now                 func() time.Time
}

type AgentExecutionSnapshotRetentionManager struct {
	APIReader client.Reader
	Store     store.AgentExecutionSnapshotLifecycleStore
	Namespace string

	Retention time.Duration
	Interval  time.Duration
	Now       func() time.Time
	// contains filtered or unexported fields
}

type AgentReconciler struct {
	client.Client
	Scheme *runtime.Scheme
	// Mode is the controller's static execution mode. A built-in Agent that
	// omitted contractVersion is stamped with it on first reconcile so the
	// stored object carries its classification.
	Mode executionmode.Mode
}

type AgentRuntimeReconciler struct {
	client.Client
	APIReader              client.Reader
	Scheme                 *k8sruntime.Scheme
	HarnessV1HTTPClient    *http.Client
	MCPRegistry            *tools.Registry
	ControllerEpochManager *ControllerEpochManager
	ControlStore           store.DurableControlStore
}

type AgentSandboxConfig struct {
	// RouterURL is the optional base URL for an agent-sandbox router service.
	RouterURL string
	// DefaultTemplate is the default agent-sandbox SandboxWarmPool name used when a workspace omits templateRef.name.
	DefaultTemplate string
	// WarmPoolPolicy is retained for the legacy worker environment contract.
	WarmPoolPolicy string
	// NamespaceStrategy selects where sandbox lifecycle resources are managed.
	NamespaceStrategy string
	// ControllerNamespace is the namespace used for controller-scoped sandbox lifecycle resources.
	ControllerNamespace string
	// ClaimTimeout bounds workspace claim and readiness operations.
	ClaimTimeout time.Duration
	// CommandTimeout bounds sandbox command execution operations.
	CommandTimeout time.Duration
	// CleanupPolicy is the controller default when a Task workspace omits cleanupPolicy.
	CleanupPolicy corev1alpha1.WorkspaceCleanupPolicy
}

type ControllerEpochManager struct {
	Store    store.ControllerEpochStore
	Name     string
	HolderID string
	Mirrors  []store.ControllerEpochMirror
	// contains filtered or unexported fields
}

type DurableACPMCPPromptAuthorizer struct {
	Attempts store.PromptAttemptStore
}

type ExecutionWorkspaceClassReconciler struct {
	client.Client
	APIReader   client.Reader
	RESTMapper  apimeta.RESTMapper
	CleanupOnly bool
}

type ExecutionWorkspaceProviderReconciler struct {
	client.Client
	APIReader        client.Reader
	RESTMapper       apimeta.RESTMapper
	HeartbeatTimeout time.Duration
	Now              func() time.Time
	CleanupOnly      bool
}

type ExecutionWorkspaceReconciler struct {
	client.Client
	APIReader               client.Reader
	RESTMapper              apimeta.RESTMapper
	AdmissionLeaseNamespace string
	CleanupOnly             bool
}

type ExecutionWorkspaceRequest struct {
	TemplateName      string
	TemplateNamespace string
	TemplateUID       string

	SubstrateBootstrapSecretName string
	SubstrateBootstrapSecretKey  string
}

type FakeExecutionWorkspacePoolReconciler struct {
	client.Client
}

type FakeExecutionWorkspaceProviderReconciler struct {
	client.Client
	Now func() time.Time
}

type FakeExecutionWorkspaceReconciler struct {
	client.Client
	APIReader  client.Reader
	RESTMapper apimeta.RESTMapper
}

type GatewayBindingReconciler struct {
	client.Client
	Scheme *k8sruntime.Scheme
}

type GatewayClassReconciler struct {
	client.Client
	Scheme *k8sruntime.Scheme
}

type GatewayReconciler struct {
	client.Client
	Scheme                *k8sruntime.Scheme
	HTTPClient            *http.Client
	AllowInsecureLoopback bool
}

type HarnessV1BrokeredToolExecutor interface {
	ExecuteHarnessV1BrokeredTool(
		context.Context,
		string,
		*corev1alpha1.Tool,
		harness.ToolCallRequest,
	) (json.RawMessage, error)
}

type HarnessV1Dispatcher struct {
	Client               client.Client
	APIReader            client.Reader
	Attempts             store.HarnessV1AttemptStore
	Snapshots            store.AgentExecutionSnapshotStore
	ResultStore          store.ResultStore
	EventStore           store.ExecutionEventStore
	ExternalEffects      store.ExternalEffectStore
	BrokeredToolExecutor HarnessV1BrokeredToolExecutor
	Sessions             *ACPSessionContinuity
	Epochs               *ControllerEpochManager
	Interval             time.Duration
	MaxConcurrent        int
	HTTPClient           *http.Client
	// contains filtered or unexported fields
}

type HarnessV1SessionContinuityConfig struct {
	SessionControls store.SessionControlStore
	Transcripts     store.SessionStore
	GatewayEvents   store.GatewayEventStore
	BootstrapLimits ACPBootstrapLimits
	NewSessionUID   func() (string, error)
	Lineages        store.SessionLineageStore
}

type HarnessV1SettlementAcknowledger interface {
	AcknowledgeHarnessV1Settlement(
		context.Context,
		*corev1alpha1.Task,
		*store.HarnessV1Attempt,
	) error
}

type JobBuildOptions struct {
	ResolvedApprovalsJSON       string
	RepositoryMonitorValidation bool
}

type JobBuilder struct {
	client.Client
	AIWorkerImage                              string
	GeneralWorkerImage                         string
	InitImage                                  string
	AIWorkerServiceAccountName                 string
	ContainerWorkerServiceAccountName          string
	ControllerURL                              string // e.g. http://orka-controller.orka-system.svc:8080
	ControllerMode                             executionmode.Mode
	ContextTokenTTSEndpoint                    string
	ContextTokenTTSAudience                    string
	ContextTokenTTSTimeout                     string
	ContextTokenTTSTokenSource                 string
	ContextTokenSubjectTokenType               string
	ContextTokenChildScope                     string
	ContextTokenOutboundScope                  string
	ContextTokenChildTokenTTL                  string
	ContextTokenToolTokenTTL                   string
	EnforceTransactionCredentialAuth           bool
	TransactionCredentialReadScopes            []string
	OutboundAccessTrustedGatewayServices       string
	OutboundAccessTrustedTokenEndpointServices string
	EnableTelemetry                            bool
	// contains filtered or unexported fields
}

type KubernetesACPMCPBrokerCredentialResolver struct {
	Reader                  client.Reader
	Epochs                  *ControllerEpochManager
	AgentExecutionSnapshots store.AgentExecutionSnapshotStore
}

type KubernetesACPUpgradeDrainBarrierObserver struct {
	Reader    client.Reader
	Outbox    ACPUpgradeDrainOutboxBarrier
	Namespace string
}

type KubernetesHarnessV1BrokeredToolExecutor struct {
	Reader              client.Reader
	KubeClient          kubernetes.Interface
	HTTPClient          *http.Client
	OutboundAccess      outboundaccess.Resolver
	TransactionExchange *workerexecutor.TransactionExchangeConfig

	// EnforceTransactionCredentialAuth mirrors the controller-wide
	// context-token authorization enforcement mode. When set, brokered Tool
	// executions bind the authenticated Task's transaction and credential
	// authority before running and fail closed when it cannot be resolved.
	EnforceTransactionCredentialAuth bool
	// TransactionCredentialReadScopes lists the transaction scopes that
	// authorize Secret-backed outbound credentials, matching the scopes the
	// controller stamps into worker Jobs.
	TransactionCredentialReadScopes []string
}

type OutboundAccessPolicyReconciler struct {
	client.Client
	APIReader                  client.Reader
	Scheme                     *runtime.Scheme
	Trust                      outboundaccess.TrustConfig
	AIWorkerServiceAccountName string
}

type ProviderReconciler struct {
	client.Client
	Scheme *runtime.Scheme
}

type RegistryACPMCPToolExecutor struct {
	Registry            *tools.Registry
	Reader              client.Reader
	KubeClient          kubernetes.Interface
	HTTPClient          *http.Client
	OutboundAccess      outboundaccess.Resolver
	TransactionExchange *workerexecutor.TransactionExchangeConfig
	ContextFactory      func(context.Context, harnessv2.MCPBrokerCallRequest) (*tools.ToolContext, error)

	// EnforceTransactionCredentialAuth mirrors the controller-wide context-token
	// authorization enforcement mode. Custom-Tool executions always bind the
	// authenticated Task's transaction authority; this flag gates only its
	// Secret-credential authorization.
	EnforceTransactionCredentialAuth bool
	// TransactionCredentialReadScopes lists the transaction scopes that
	// authorize Secret-backed outbound credentials, matching the scopes the
	// controller stamps into worker Jobs.
	TransactionCredentialReadScopes []string
}

type RepositoryMonitorReconciler struct {
	client.Client
	APIReader                 client.Reader
	Scheme                    *runtime.Scheme
	Store                     store.RepositoryMonitorStore
	ResultStore               store.ResultStore
	ArtifactStore             store.ArtifactStore
	DurableControlStore       store.DurableControlStore
	ControllerEpochManager    *ControllerEpochManager
	HTTPClient                *http.Client
	GitHubAPIBaseURL          string
	EnforceNamespaceIsolation bool
}

type RepositoryScanReconciler struct {
	client.Client
	Scheme           *runtime.Scheme
	SecurityStore    store.SecurityStore
	ArtifactStore    store.ArtifactStore
	ResultStore      store.ResultStore
	PublicationStore store.PublicationStore
	// APIReader reads uncached Secrets and verifies RepositoryScan identity
	// before run admission or cleanup; nil falls back to Client.
	APIReader client.Reader
	// HTTPClient and GitHubAPIBaseURL serve the published-commit read that
	// backs harness-v2 patch evidence; zero values use the defaults.
	HTTPClient       *http.Client
	GitHubAPIBaseURL string
}

type ResultRefPayload struct {
	Available bool `json:"available"`
}

type RuntimePoolProbeResult struct {
	Capabilities harnessv2.CapabilitiesResponse
	Status       harnessv2.StatusResponse
}

type RuntimePoolProviderProxyConfig struct {
	BaseURL         string
	Namespace       string
	PodLabels       map[string]string
	BearerToken     []byte
	BearerTokenFile string
}

type RuntimePoolReconciler struct {
	client.Client
	APIReader client.Reader
	Scheme    *k8sruntime.Scheme

	// RuntimeNamespace is used when spec.runtimeNamespace is empty.
	RuntimeNamespace string
	// ControllerNamespace is the namespace allowed to reach the runtime control port.
	ControllerNamespace string
	// ControllerAPIURL is the exact internal artifact/broker API base URL.
	ControllerAPIURL string
	// ControllerAPIPort is the controller Pod target port allowed by the runtime egress policy.
	ControllerAPIPort int32
	// WorkspaceArtifactMaxBytes is the Publisher-advertised maximum inbound
	// workspace artifact size propagated to every built-in runtime.
	WorkspaceArtifactMaxBytes int64
	// ProviderProxy is the authenticated, NetworkPolicy-confined provider boundary.
	ProviderProxy RuntimePoolProviderProxyConfig
	// ControllerEpoch is a test/static override. Production uses Epochs.
	ControllerEpoch int64
	// Epochs supplies the current durable leader epoch.
	Epochs *ControllerEpochManager
	// EnablePDB protects a serving singleton from voluntary disruption.
	EnablePDB bool
	// EnableTelemetry projects non-secret trace exporter settings into supervisors.
	EnableTelemetry bool
	// AllowedImages is the controller-configured immutable image allowlist for
	// built-in pools. RuntimePool is controller-owned; its public spec cannot be
	// used to select an arbitrary privileged supervisor image.
	AllowedImages ACPRuntimeImages
	// CleanupOnly keeps deletion finalization active while ACP runtime admission
	// is disabled without adding finalizers or creating runtime resources.
	CleanupOnly bool
	// E2EPromptWriteAmbiguityMarker is a disabled-by-default live-conformance
	// fault marker projected into built-in runtime supervisors.
	E2EPromptWriteAmbiguityMarker string

	// AgentSandboxEnabled admits Agent Sandbox-backed workspace pools.
	AgentSandboxEnabled bool
	// SubstrateEnabled admits Substrate-backed workspace pools.
	SubstrateEnabled bool
	// SubstrateConfig carries the externally operated Substrate control-plane
	// and router configuration for Substrate-backed workspace pools.
	SubstrateConfig SubstrateConfig
	// SubstrateActorControlFactory builds the narrow, suspension-free actor
	// control client. Tests inject fakes; production defaults to the gRPC client.
	SubstrateActorControlFactory func(SubstrateConfig) (workspace.SubstrateRuntimeActorControl, error)
	SubstrateNativeClientFactory func(SubstrateConfig) (*workspace.SubstrateNativeClient, error)
	SubstrateTemplates           substrateTemplateStore
	// SubstrateCredentialSeeder overrides the fresh-boot credential PUT for
	// tests. Production sends fresh boots through the router; data-resumed actors
	// require the provider control's operation-fenced bootstrap contract.
	SubstrateCredentialSeeder func(ctx context.Context, routeHost, nonce string, capabilitySecret []byte, request harnessv2.CredentialBootstrapRequest) error
	// WorkspaceCredentialSeeder overrides the Agent Sandbox credential
	// bootstrap PUT for tests. Production seeds the exact attested Pod endpoint
	// directly after provider materialization is verified.
	WorkspaceCredentialSeeder func(ctx context.Context, endpoint, nonce string, capabilitySecret []byte, request harnessv2.CredentialBootstrapRequest) (alreadyComplete bool, err error)

	SupervisorClient RuntimePoolSupervisorClient
	HTTPClient       *http.Client
	Rand             io.Reader
	Now              func() time.Time
	// contains filtered or unexported fields
}

type RuntimePoolSupervisorClient interface {
	Probe(ctx context.Context, endpoint, bearerToken string, capabilitySecret []byte) (RuntimePoolProbeResult, error)
	RequestDrain(ctx context.Context, endpoint, bearerToken string, capabilitySecret []byte, status harnessv2.StatusResponse, reason string) error
}

type SessionCleanupRecoveryManager struct {
	// contains filtered or unexported fields
}

type SessionManager struct {
	// contains filtered or unexported fields
}

type SkillReconciler struct {
	client.Client
	Scheme *runtime.Scheme
}

type SubstrateActorPoolReconciler struct {
	client.Client
	Scheme *runtime.Scheme

	SubstrateEnabled bool
	SubstrateConfig  SubstrateConfig

	SubstrateTemplateValidator func(context.Context, *ExecutionWorkspaceRequest) error
	SubstrateExecutorFactory   func(SubstrateConfig) (SubstratePoolExecutor, error)
}

type SubstrateCheckpointReconciler struct {
	RuntimePools           *RuntimePoolReconciler
	CheckpointAPIInstalled bool
}

type SubstrateConfig struct {
	APIEndpoint        string
	APICAFile          string
	APICertFile        string
	APIKeyFile         string
	APIBearerTokenFile string
	// Atespace is selected from the immutable workspace binding by the controller.
	Atespace              string
	APIInsecureSkipVerify bool
	// DirectEgressEnabled acknowledges that ateapi has tunneled egress disabled.
	// ACP requires worker-scoped NetworkPolicies to see the Actor's destinations.
	DirectEgressEnabled       bool
	RouterURL                 string
	ActorDNSSuffix            string
	DefaultTemplate           string
	DefaultTemplateNS         string
	BootstrapSecretName       string
	BootstrapSecretKey        string
	SessionIdentitySecretName string
	SessionIdentitySecretKey  string
	SessionIdentityRequired   bool
	SessionIdentityAudience   string
	SessionIdentityAppID      string
	SessionIdentityUserID     string
	ClaimTimeout              time.Duration
	CommandTimeout            time.Duration
	CleanupPolicy             corev1alpha1.WorkspaceCleanupPolicy
}

type SubstratePoolExecutor interface {
	ConvergeSubstrateActors(ctx context.Context, prefix string, target int, template workspace.TemplateRef) (int, int, error)
	PruneSubstrateActors(ctx context.Context, prefix string, target int) (int, error)
	SubstratePoolTelemetry(ctx context.Context, prefix string, template workspace.TemplateRef, workerPool workspace.TemplateRef) (workspace.Density, error)
}

type TaskReconciler struct {
	client.Client
	APIReader                    client.Reader
	Scheme                       *runtime.Scheme
	JobBuilder                   *JobBuilder
	SessionManager               *SessionManager
	WebhookNotifier              *WebhookNotifier
	Recorder                     record.EventRecorder
	KubeClient                   kubernetes.Interface
	OutboundAccessResolver       outboundaccess.Resolver
	BrokeredTransactionExchange  *workerpkg.TransactionExchangeConfig
	ResultStore                  store.ResultStore
	PlanStore                    store.PlanStore
	MessageStore                 store.MessageStore
	ArtifactStore                store.ArtifactStore
	ExecutionEventStore          store.ExecutionEventStore
	DurableControlStore          store.DurableControlStore
	AgentExecutionSnapshots      store.AgentExecutionSnapshotStore
	RepositoryValidationBindings tools.RepositoryValidationBindingStore
	MCPRegistry                  *tools.Registry
	ACPArtifactRetirer           artifactcap.IdentityRetirer
	ACPPublicationReclaimer      ACPPublicationReclaimer
	ControllerEpochManager       *ControllerEpochManager
	ControllerNamespace          string
	ACPAdmissionGate             *ACPAdmissionGate
	HarnessV1Enabled             bool
	// Mode is the controller's static execution mode; it classifies built-in
	// Agents that omitted contractVersion.
	Mode                              executionmode.Mode
	HarnessV1Endpoint                 string
	HarnessV1AuthSecretNamespace      string
	HarnessV1AuthSecretName           string
	HarnessV1AuthSecretKey            string
	HarnessV1Attempts                 store.HarnessV1AttemptStore
	HarnessV1SettlementAcknowledger   HarnessV1SettlementAcknowledger
	ACPRuntimeEnabled                 bool
	ACPRuntimeImages                  ACPRuntimeImages
	ACPRuntimeNamespace               string
	EnforceNamespaceIsolation         bool
	MaxTasksPerNamespace              int32
	ExecutionWorkspaceDefaultProvider corev1alpha1.WorkspaceProvider
	WorkspaceProviderAPIEnabled       bool
	// WorkspaceSettlementProtected reports that Task provenance admission
	// guards the reserved acp.workspace.orka.ai/ metadata settlement reads
	// from. When false (a cleanup-only installation without the webhook),
	// class settlement runs non-destructively: it never revokes or deletes a
	// workspace from forgeable Task metadata, and existing workspaces are
	// cleaned through explicit workspace deletion instead.
	WorkspaceSettlementProtected bool
	// ACPWorkspaceDispatchEnabled admits workspace-provider-backed ACP
	// RuntimeSession dispatch. When false, workspace-backed agent Tasks fail
	// closed before any workspace or RuntimePool demand exists.
	ACPWorkspaceDispatchEnabled       bool
	AgentSandboxEnabled               bool
	AgentSandboxConfig                AgentSandboxConfig
	SubstrateEnabled                  bool
	SubstrateConfig                   SubstrateConfig
	AIWorkerServiceAccountName        string
	VendorWorkerServiceAccountName    string
	ContainerWorkerServiceAccountName string
	AIWorkerClusterRoleName           string
	VendorWorkerClusterRoleName       string
	ContainerWorkerClusterRoleName    string
	WorkerRoleBindingNamePrefix       string
	EnforceTransactionCredentialAuth  bool
	TransactionCredentialReadScopes   []string
	OutboundAccessTrust               outboundaccess.TrustConfig
	// contains filtered or unexported fields
}

type ToolReconciler struct {
	client.Client
	Scheme *runtime.Scheme

	// HTTPClient is the HTTP client used for health checks. If nil, a default is used.
	HTTPClient *http.Client

	// SkipSSRFValidation disables SSRF protection for testing. Do NOT set to true in production.
	SkipSSRFValidation bool

	// SubstrateEnabled enables durable MCP tool actors.
	SubstrateEnabled            bool
	SubstrateConfig             SubstrateConfig
	EnforceNamespaceIsolation   bool
	WorkspaceProviderAPIEnabled bool
	OutboundAccessTrust         outboundaccess.TrustConfig

	// SubstrateExecutorFactory is injectable for tests.
	SubstrateTemplateValidator func(context.Context, *ExecutionWorkspaceRequest) error
	SubstrateExecutorFactory   func(SubstrateConfig) (workspace.WorkspaceExecutor, error)
}

type WebhookNotifier struct {
	// contains filtered or unexported fields
}

type WebhookPayload struct {
	TaskName       string                 `json:"taskName"`
	TaskNamespace  string                 `json:"taskNamespace"`
	Phase          corev1alpha1.TaskPhase `json:"phase"`
	Message        string                 `json:"message,omitempty"`
	StartTime      *string                `json:"startTime,omitempty"`
	CompletionTime *string                `json:"completionTime,omitempty"`
	Attempts       int32                  `json:"attempts"`
	ResultRef      *ResultRefPayload      `json:"resultRef,omitempty"`
	RuntimeType    string                 `json:"runtimeType,omitempty"`
}

type WorkspaceAttachmentManager struct {
	Client    client.Client
	APIReader client.Reader
	LeaseTTL  time.Duration
	Now       func() time.Time
}

type WorkspaceAttachmentResult struct {
	Epoch         int64
	AttachmentRef workspacev1alpha1.SecretReference
	ExpiresAt     metav1.Time
}

type WorkspaceClassAuthorizer struct {
	Client client.Client
}