Please address the comments from this code review:

## Overall Comments
- Now that the feature flags are removed, consider refactoring the affected structs (e.g., Pipeline, Manager) to drop unused fields/methods (getCurrentContext, resetContext, etc.) and streamline the code paths.
- Rather than leaving old offline‐mode tests marked as skipped, delete or consolidate them so the test suite remains concise and avoids future confusion.

Please address the comments from this code review:

## Individual Comments

### Comment 1
<location> `central/sensor/service/connection/connection_test.go:172-174` </location>
<code_context>
 }

 func (s *testSuite) TestSendDeduperStateIfSensorReconciliation() {
-	s.T().Setenv(features.SensorReconciliationOnReconnect.EnvVar(), "true")
 	s.T().Setenv(env.MaxDeduperEntriesPerMessage.EnvVar(), "2")
-	if !features.SensorReconciliationOnReconnect.Enabled() {
-		s.T().Skip("Test skipped if ROX_SENSOR_RECONCILIATION feature flag isn't set")
-	}
</code_context>

<issue_to_address>
**suggestion (testing):** Test logic for feature flag gating has been removed; ensure test still covers always-on reconciliation.

Please verify the test still checks deduper state transmission on reconnect, update the test name for clarity, and confirm negative scenarios are tested.

Suggested implementation:

```golang
func (s *testSuite) TestDeduperStateTransmissionOnReconnectAlwaysOnReconciliation() {
	s.T().Setenv(env.MaxDeduperEntriesPerMessage.EnvVar(), "2")
	cases := map[string]struct {
		givenSensorCapabilities     []centralsensor.SensorCapability
		givenSensorState            central.SensorHello_SensorState
		expectDeduperStateSent      bool
	}{
		"deduper state sent on reconnect": {
			givenSensorCapabilities: []centralsensor.SensorCapability{centralsensor.SensorCapability_DEDUPER},
			givenSensorState:       central.SensorHello_SENSOR_STATE_RECONNECTING,
			expectDeduperStateSent: true,
		},
		"deduper state not sent if capability missing": {
			givenSensorCapabilities: []centralsensor.SensorCapability{},
			givenSensorState:       central.SensorHello_SENSOR_STATE_RECONNECTING,
			expectDeduperStateSent: false,
		},
		"deduper state not sent if not reconnecting": {
			givenSensorCapabilities: []centralsensor.SensorCapability{centralsensor.SensorCapability_DEDUPER},
			givenSensorState:       central.SensorHello_SENSOR_STATE_CONNECTED,
			expectDeduperStateSent: false,
		},
	}

	for name, tc := range cases {
		s.Run(name, func() {
			// Setup sensor with given capabilities and state
			sensor := newTestSensor(tc.givenSensorCapabilities, tc.givenSensorState)
			// Simulate reconnect
			sensor.Reconnect()
			// Check if deduper state was sent
			if tc.expectDeduperStateSent {
				s.True(sensor.DeduperStateSent(), "Expected deduper state to be sent")
			} else {
				s.False(sensor.DeduperStateSent(), "Expected deduper state NOT to be sent")
			}
		})
	}

```

You may need to implement or adjust the helper methods `newTestSensor`, `Reconnect`, and `DeduperStateSent` to match your test infrastructure. Ensure that the test covers both positive and negative scenarios as shown.
</issue_to_address>

### Comment 2
<location> `sensor/tests/connection/k8sreconciliation/reconcile_test.go:47-8` </location>
<code_context>
 }

 func Test_SensorReconcilesKubernetesEvents(t *testing.T) {
-	t.Setenv(features.SensorReconciliationOnReconnect.EnvVar(), "true")
-
 	t.Setenv("ROX_SENSOR_CONNECTION_RETRY_INITIAL_INTERVAL", "1s")
 	t.Setenv("ROX_SENSOR_CONNECTION_RETRY_MAX_INTERVAL", "2s")
</code_context>

<issue_to_address>
**suggestion (testing):** Removed feature flag environment setup; verify test covers reconciliation unconditionally.

Ensure the test now asserts reconciliation occurs on reconnect without relying on the feature flag. Update the test name or comments to reflect this unconditional behavior.

Suggested implementation:

```golang
func Test_SensorAlwaysReconcilesKubernetesEventsOnReconnect(t *testing.T) {
	// This test verifies that reconciliation occurs on reconnect unconditionally,
	// without relying on any feature flag.
	t.Setenv("ROX_SENSOR_CONNECTION_RETRY_INITIAL_INTERVAL", "1s")
	t.Setenv("ROX_SENSOR_CONNECTION_RETRY_MAX_INTERVAL", "2s")

	// Setup test environment and sensor
	env := helper.NewTestEnv(t)
	defer env.Cleanup()

	// Simulate initial connection and event processing
	env.ConnectSensor()
	env.SendKubernetesEvent("Pod", "pod-1", hash.NewHash("pod-1"))
	assert.True(t, env.HasProcessedEvent("Pod", "pod-1"), "Sensor should process initial event")

	// Simulate sensor disconnect and reconnect
	env.DisconnectSensor()
	env.ConnectSensor()

	// Assert that reconciliation occurs on reconnect
	assert.True(t, env.HasReconciledEvent("Pod", "pod-1"), "Sensor should reconcile event on reconnect unconditionally")

```

- Ensure that `helper.NewTestEnv`, `SendKubernetesEvent`, `HasProcessedEvent`, `DisconnectSensor`, `ConnectSensor`, and `HasReconciledEvent` exist and behave as expected in your test helper.
- If these helper methods do not exist, you will need to implement them or adjust the test logic to match your actual test environment and reconciliation verification.
</issue_to_address>

### Comment 3
<location> `sensor/tests/connection/runtime/runtime_test.go:32-29` </location>
<code_context>
 }

 func Test_SensorReconcilesKubernetesEvents(t *testing.T) {
-	t.Setenv(features.SensorReconciliationOnReconnect.EnvVar(), "true")
-
 	t.Setenv("ROX_SENSOR_CONNECTION_RETRY_INITIAL_INTERVAL", "1s")
 	t.Setenv("ROX_SENSOR_CONNECTION_RETRY_MAX_INTERVAL", "2s")
</code_context>

<issue_to_address>
**suggestion (testing):** Feature flag environment variable setup removed; confirm test still validates runtime event reconciliation.

Ensure the test accurately reflects the always-on state for event reconciliation, updating assertions if necessary.

Suggested implementation:

```golang
func Test_SensorIntermediateRuntimeEvents(t *testing.T) {
	t.Setenv(env.ConnectionRetryInitialInterval.EnvVar(), "1s")
	t.Setenv(env.ConnectionRetryMaxInterval.EnvVar(), "2s")

	// Ensure runtime event reconciliation is always enabled.
	// Remove any logic that depends on the feature flag and assert reconciliation occurs.

	// Setup test environment and sensor
	sensor, cleanup := helper.SetupTestSensor(t)
	defer cleanup()

	// Simulate a runtime event (e.g., pod creation)
	pod := testutils.NewPod("test-pod", "default")
	sensor.EmitKubernetesEvent(pod)

	// Simulate sensor reconnect
	sensor.Disconnect()
	sensor.Reconnect()

	// Assert that the runtime event is reconciled after reconnect
	reconciledPod, err := sensor.GetPod("test-pod", "default")
	if err != nil {
		t.Fatalf("Expected pod to be reconciled after reconnect, but got error: %v", err)
	}
	if reconciledPod == nil {
		t.Fatalf("Expected pod to be present after reconciliation, but got nil")
	}

```

- If the helper or testutils packages do not provide the methods used above (e.g., EmitKubernetesEvent, Disconnect, Reconnect, GetPod), you will need to adapt the test to use the appropriate methods for your test sensor.
- If there are more specific runtime events or reconciliation logic to validate, update the assertions to match your application's requirements.
- Remove any other references to the feature flag in this test file.
</issue_to_address>

### Comment 4
<location> `central/sensor/service/connection/connection_test.go:171` </location>
<code_context>
 }

 func (s *testSuite) TestSendDeduperStateIfSensorReconciliation() {
-	s.T().Setenv(features.SensorReconciliationOnReconnect.EnvVar(), "true")
 	s.T().Setenv(env.MaxDeduperEntriesPerMessage.EnvVar(), "2")
</code_context>

<issue_to_address>
**nitpick:** Consider renaming the test to reflect unconditional deduper state sending.

The test name should be updated to match its new behavior, since it no longer depends on the feature flag.
</issue_to_address>