fix(rate-limits): treat empty policies as unlimited

apps/api/internal/store/candidates.go

@@ -230,7 +230,7 @@ ORDER BY effective_priority ASC,
 		item.WaitingCount = maxFloat(queuedWaiting, stateWaitingCount)
 		item.LastAssignedUnix = lastAssignedUnix
 		applyRuntimeCandidateLoad(&item, runtimeCandidateLoadInput{
-			Policy:            effectiveModelRateLimitPolicy(item.PlatformRateLimitPolicy, item.RuntimeRateLimitPolicy, item.RuntimePolicyOverride, item.ModelRateLimitPolicy),
+			Policy:            effectiveModelRateLimitPolicy(item.PlatformRateLimitPolicy, item.RuntimeRateLimitPolicy, item.RuntimePolicySetID, item.RuntimePolicyOverride, item.ModelRateLimitPolicy),
 			ConcurrentActive:  concurrentActive,
 			QueuedWaiting:     queuedWaiting,
 			RPMUsed:           rpmUsed,

apps/api/internal/store/rate_limit_status.go

@@ -88,7 +88,8 @@ func (s *Store) ListModelRateLimitStatuses(ctx context.Context) ([]ModelRateLimi
 		       p.priority, p.dynamic_priority, COALESCE(p.dynamic_priority, p.priority),
 		       m.model_name, COALESCE(NULLIF(m.provider_model_name, ''), m.model_name), COALESCE(m.model_alias, ''),
 	       m.model_type, m.display_name, m.enabled,
-	       p.rate_limit_policy, COALESCE(rp.rate_limit_policy, '{}'::jsonb), COALESCE(NULLIF(m.runtime_policy_override, '{}'::jsonb), b.runtime_policy_override, '{}'::jsonb), m.rate_limit_policy,
+	       p.rate_limit_policy, COALESCE(rp.rate_limit_policy, '{}'::jsonb), COALESCE(m.runtime_policy_set_id::text, b.runtime_policy_set_id::text, ''),
+	       COALESCE(NULLIF(m.runtime_policy_override, '{}'::jsonb), b.runtime_policy_override, '{}'::jsonb), m.rate_limit_policy,
 	       COALESCE(to_char(p.cooldown_until AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"'), ''),
 	       COALESCE(to_char(m.cooldown_until AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"'), ''),
 	       COALESCE(con.active, 0)::float8,
@@ -163,6 +164,7 @@ ORDER BY p.priority ASC, m.model_name ASC`)
 		var modelTypeBytes []byte
 		var platformPolicyBytes []byte
 		var runtimePolicyBytes []byte
+		var runtimePolicySetID string
 		var runtimeOverrideBytes []byte
 		var modelPolicyBytes []byte
 		var platformDynamicPriority sql.NullInt64
@@ -193,6 +195,7 @@ ORDER BY p.priority ASC, m.model_name ASC`)
 			&item.Enabled,
 			&platformPolicyBytes,
 			&runtimePolicyBytes,
+			&runtimePolicySetID,
 			&runtimeOverrideBytes,
 			&modelPolicyBytes,
 			&platformCooldownUntil,
@@ -213,6 +216,7 @@ ORDER BY p.priority ASC, m.model_name ASC`)
 		policy := effectiveModelRateLimitPolicy(
 			decodeObject(platformPolicyBytes),
 			decodeObject(runtimePolicyBytes),
+			runtimePolicySetID,
 			decodeObject(runtimeOverrideBytes),
 			decodeObject(modelPolicyBytes),
 		)
@@ -432,13 +436,20 @@ func platformPolicyEventFromPayload(id string, taskID string, eventType string,
 	}
 }
 
-func effectiveModelRateLimitPolicy(platformPolicy map[string]any, runtimePolicy map[string]any, runtimeOverride map[string]any, modelPolicy map[string]any) map[string]any {
+func effectiveModelRateLimitPolicy(platformPolicy map[string]any, runtimePolicy map[string]any, runtimePolicySetID string, runtimeOverride map[string]any, modelPolicy map[string]any) map[string]any {
 	policy := platformPolicy
-	if hasRateLimitRules(runtimePolicy) {
+	if strings.TrimSpace(runtimePolicySetID) != "" {
+		policy = runtimePolicy
+	} else if hasRateLimitRules(runtimePolicy) {
 		policy = shallowMergeMap(policy, runtimePolicy)
 	}
-	if nested, ok := runtimeOverride["rateLimitPolicy"].(map[string]any); ok && len(nested) > 0 {
-		policy = shallowMergeMap(policy, nested)
+	if _, hasOverride := runtimeOverride["rateLimitPolicy"]; hasOverride {
+		nested, _ := runtimeOverride["rateLimitPolicy"].(map[string]any)
+		if len(nested) == 0 {
+			policy = nil
+		} else {
+			policy = shallowMergeMap(policy, nested)
+		}
 	}
 	if hasRateLimitRules(modelPolicy) {
 		policy = shallowMergeMap(policy, modelPolicy)

apps/api/internal/store/rate_limit_status_test.go

@@ -16,6 +16,7 @@ func TestEffectiveModelRateLimitPolicyTreatsModelRulesAsAuthoritative(t *testing
 			map[string]any{"metric": "tpm_total", "limit": 240000},
 			map[string]any{"metric": "concurrent", "limit": 6},
 		}},
+		"runtime-policy-1",
 		map[string]any{},
 		map[string]any{"rules": []any{
 			map[string]any{"metric": "rpm", "limit": 30},
@@ -34,6 +35,48 @@ func TestEffectiveModelRateLimitPolicyTreatsModelRulesAsAuthoritative(t *testing
 	}
 }
 
+func TestEffectiveModelRateLimitPolicyTreatsEmptyRuntimePolicyAsUnlimited(t *testing.T) {
+	policy := effectiveModelRateLimitPolicy(
+		map[string]any{"rules": []any{
+			map[string]any{"metric": "rpm", "limit": 500},
+			map[string]any{"metric": "tpm_total", "limit": 100000},
+		}},
+		map[string]any{"rules": []any{}},
+		"runtime-policy-1",
+		map[string]any{},
+		map[string]any{},
+	)
+
+	if got := rateLimitForMetric(policy, "rpm"); got != 0 {
+		t.Fatalf("expected empty runtime policy rpm to mean unlimited, got %v", got)
+	}
+	if got := rateLimitForMetric(policy, "tpm_total"); got != 0 {
+		t.Fatalf("expected empty runtime policy tpm to mean unlimited, got %v", got)
+	}
+}
+
+func TestEffectiveModelRateLimitPolicyTreatsNegativeLimitAsUnlimited(t *testing.T) {
+	policy := effectiveModelRateLimitPolicy(
+		map[string]any{"rules": []any{
+			map[string]any{"metric": "rpm", "limit": 500},
+		}},
+		map[string]any{"rules": []any{
+			map[string]any{"metric": "rpm", "limit": -1},
+		}},
+		"runtime-policy-1",
+		map[string]any{},
+		map[string]any{},
+	)
+
+	if got := rateLimitForMetric(policy, "rpm"); got != -1 {
+		t.Fatalf("expected negative runtime rpm marker to be preserved, got %v", got)
+	}
+	status := metricStatus(10, 10, 0, rateLimitForMetric(policy, "rpm"), "")
+	if status.Limited {
+		t.Fatalf("expected negative runtime rpm marker to be reported as unlimited, got %+v", status)
+	}
+}
+
 func TestPriorityDemotionRecordFromEventPayloadKeepsReason(t *testing.T) {
 	createdAt := time.Date(2026, 5, 12, 9, 30, 0, 0, time.UTC)
 	record := priorityDemotionRecordFromEventPayload("event-1", "task-1", "fallback message", map[string]any{