fix: align pooled chat admission with current main

ibetitsmike · Aug 18, 2026 · Aug 5, 2026 · Aug 5, 2026 · Aug 5, 2026 · Aug 5, 2026
commit d4e2eeedfa7a96fa58342d27845823a94386a1b4
diff --git a/...ool_aware_chat_acquisition_index.down.sql → ...ool_aware_chat_acquisition_index.down.sql b/...ool_aware_chat_acquisition_index.down.sql → ...ool_aware_chat_acquisition_index.down.sql
diff --git a/..._pool_aware_chat_acquisition_index.up.sql → ..._pool_aware_chat_acquisition_index.up.sql b/..._pool_aware_chat_acquisition_index.up.sql → ..._pool_aware_chat_acquisition_index.up.sql
diff --git a/coderd/database/queries.sql.go b/coderd/database/queries.sql.go
diff --git a/coderd/database/queries/chats.sql b/coderd/database/queries/chats.sql
@@ -2351,25 +2351,16 @@ candidates AS (
     ) candidate
 )
 SELECT
-    chats_expanded.*,
-    chat_heartbeats.heartbeat_at AS current_heartbeat_at,
-    NOT EXISTS (
-        SELECT 1
-        FROM chat_heartbeats current_lease
-        WHERE current_lease.chat_id = chats_expanded.id
-          AND current_lease.runner_id = chats_expanded.runner_id
-          AND current_lease.heartbeat_at > NOW() - (INTERVAL '1 second' * @stale_seconds::int)
-    ) AS heartbeat_stale
+    chats.id,
+    chats.status,
+    chats.parent_chat_id
 FROM candidates
-JOIN chats_expanded ON chats_expanded.id = candidates.id
-LEFT JOIN chat_heartbeats
-    ON chat_heartbeats.chat_id = chats_expanded.id
-    AND chat_heartbeats.runner_id = chats_expanded.runner_id
+JOIN chats ON chats.id = candidates.id
 ORDER BY
     candidates.status_priority ASC,
     candidates.pool_position ASC,
     candidates.pool_priority ASC,
-    chats_expanded.id ASC
+    chats.id ASC
 LIMIT @limit_count::int;
 
 -- name: GetChatsByIDsForRunnerSync :many

diff --git a/coderd/x/chatd/agentadmission.go b/coderd/x/chatd/agentadmission.go
@@ -12,7 +12,7 @@ const (
 	defaultMaxConcurrentSubagents  = int64(10)
 )
 
-// AgentCapacityLimiter gates chat ownership and reports the dynamic per-pool caps.
+// AgentCapacityLimiter controls chat admission and reports the current per-pool limits.
 type AgentCapacityLimiter interface {
 	// Admit runs inside the acquisition transaction so its serialization
 	// extends through the ownership write. Refused chats remain unowned.
@@ -25,7 +25,7 @@ type AgentCapacityUnlock interface {
 	Unlocked() bool
 }
 
-// AgentCapacityLimits reports the root and subagent pool capacities.
+// AgentCapacityLimits defines concurrent-agent limits for root and subagent pools.
 type AgentCapacityLimits struct {
 	Root     int64
 	Subagent int64

diff --git a/coderd/x/chatd/chatd.go b/coderd/x/chatd/chatd.go
@@ -3316,15 +3316,29 @@ func chatWatchEventSDKChat(chat database.Chat, diffStatus *codersdk.ChatDiffStat
 // publishChatPubsubEvent broadcasts a chat lifecycle event via PostgreSQL
 // pubsub so that all replicas can push updates to watching clients.
 func (p *Server) publishChatPubsubEvent(chat database.Chat, kind codersdk.ChatWatchEventKind, diffStatus *codersdk.ChatDiffStatus) {
-	p.publishChatWatchEvent(chat, codersdk.ChatWatchEvent{
+	event := codersdk.ChatWatchEvent{
 		Kind: kind,
 		Chat: chatWatchEventSDKChat(chat, diffStatus),
-	})
+	}
+	payload, err := json.Marshal(event)
+	if err != nil {
+		p.logger.Error(context.Background(), "failed to marshal chat pubsub event",
+			slog.F("chat_id", chat.ID),
+			slog.Error(err),
+		)
+		return
+	}
+	if err := p.pubsub.Publish(coderdpubsub.ChatWatchEventChannel(chat.OwnerID), payload); err != nil {
+		p.logger.Error(context.Background(), "failed to publish chat pubsub event",
+			slog.F("chat_id", chat.ID),
+			slog.F("kind", kind),
+			slog.Error(err),
+		)
+	}
 }
 
-// ChatQueuedForCapacity derives whether the chat is waiting for a
-// concurrent-agent capacity slot. It reports false when the deployment is
-// currently uncapped.
+// ChatQueuedForCapacity reports whether the chat is waiting for a
+// concurrent-agent capacity slot. Uncapped deployments always return false.
 func (p *Server) ChatQueuedForCapacity(ctx context.Context, chat database.Chat) (bool, error) {
 	limits, capped := p.agentCapacityLimiter.Limits()
 	if !capped {
@@ -3344,24 +3358,6 @@ func (p *Server) ChatQueuedForCapacity(ctx context.Context, chat database.Chat)
 	})
 }
 
-func (p *Server) publishChatWatchEvent(chat database.Chat, event codersdk.ChatWatchEvent) {
-	payload, err := json.Marshal(event)
-	if err != nil {
-		p.logger.Error(context.Background(), "failed to marshal chat pubsub event",
-			slog.F("chat_id", chat.ID),
-			slog.Error(err),
-		)
-		return
-	}
-	if err := p.pubsub.Publish(coderdpubsub.ChatWatchEventChannel(chat.OwnerID), payload); err != nil {
-		p.logger.Error(context.Background(), "failed to publish chat pubsub event",
-			slog.F("chat_id", chat.ID),
-			slog.F("kind", event.Kind),
-			slog.Error(err),
-		)
-	}
-}
-
 // PublishDiffStatusChange broadcasts a diff_status_change event for
 // the given chat so that watching clients know to re-fetch the diff
 // status. This is called from the HTTP layer after the diff status

diff --git a/coderd/x/chatd/worker.go b/coderd/x/chatd/worker.go
@@ -205,19 +205,26 @@ func (w *chatWorker) acquireOnce(ctx context.Context, workerID uuid.UUID, manage
 	}
 
 	acquired := int32(0)
-	refusedPools := map[bool]bool{}
+	rootPoolRefused := false
+	subagentPoolRefused := false
 	for _, row := range rows {
 		if acquired >= w.opts.AcquisitionBatchSize {
 			return
 		}
 		// Interrupting and requires-action chats bypass capacity so their runners
 		// can finish work or enforce the action deadline.
-		if row.Status == database.ChatStatusRunning && refusedPools[row.ParentChatID.Valid] {
+		isSubagent := row.ParentChatID.Valid
+		if row.Status == database.ChatStatusRunning &&
+			((isSubagent && subagentPoolRefused) || (!isSubagent && rootPoolRefused)) {
 			continue
 		}
 		candidateAcquired, err := w.acquireCandidateSafely(ctx, workerID, manager, row.ID)
 		if errors.Is(err, errCapacityRefused) {
-			refusedPools[row.ParentChatID.Valid] = true
+			if isSubagent {
+				subagentPoolRefused = true
+			} else {
+				rootPoolRefused = true
+			}
 			continue
 		}
 		if err != nil {

@@ -225,7 +225,9 @@ token volume. Consider:
 
 Community licenses run up to 5 agents at once.
 Additional agents queue and start automatically when capacity frees.
-Premium licenses with remaining Agent Hours remove the concurrency limit.
+Premium licenses with Agent Hours do not impose a concurrency limit unless the Agent Hours hard limit is reached.
+If the Agent Hours allocation is exhausted without a configured hard limit, Coder warns about usage but does not impose a concurrency limit.
+When the Agent Hours hard limit is reached, additional agents queue under the concurrency limit.
 Refer to [Concurrent agents](./platform-controls/index.md#concurrent-agents) for details.
 
 ### Pilot with a small group

@@ -124,10 +124,9 @@ Subtasks delegated by an agent don't count toward this limit.
 Those subtasks run in a separate pool of up to 10 concurrent subtasks.
 
 Premium deployments can purchase Agent Hours with their Premium license.
-Agent Hours are shared across the deployment, so any number of agents can run concurrently while consuming a shared pool of purchased working hours.
-This usage-based model supports enterprise workloads with variable bursts of agent activity.
-Large development teams, background automation, and API-triggered tasks can run without a concurrency limit while hours remain.
-When purchased hours are exhausted, agents queue under the concurrency limit until more hours are added.
+Agent Hours are shared across the deployment, and agents can run concurrently unless the Agent Hours hard limit is reached.
+If the Agent Hours allocation is exhausted without a configured hard limit, Coder warns about usage but does not impose a concurrency limit.
+When the Agent Hours hard limit is reached, additional agents queue under the concurrency limit.
 
 ### Spend management
 

diff --git a/enterprise/coderd/x/chatd/agentadmission.go b/enterprise/coderd/x/chatd/agentadmission.go
@@ -15,13 +15,14 @@ type agentCapacityUnlock struct {
 	entitlements *entitlements.Set
 }
 
-// Runtime-hour allocation does not enforce caps; the hard limit does.
+// The Agent Hours allocation is advisory; the hard limit restores concurrency caps.
 func (u *agentCapacityUnlock) Unlocked() bool {
 	f, ok := u.entitlements.Feature(codersdk.FeatureAgentRuntimeHours)
 	if !ok || !f.Enabled {
 		return false
 	}
 	if f.HardLimit == nil || f.Actual == nil {
+		// Missing hard limits or usage measurements leave concurrency uncapped.
 		return true
 	}
 	return *f.Actual < *f.HardLimit

diff --git a/enterprise/coderd/x/chatd/agentadmission_internal_test.go b/enterprise/coderd/x/chatd/agentadmission_internal_test.go
@@ -98,10 +98,6 @@ func TestAgentCapacityUnlock(t *testing.T) {
 			},
 		},
 		{
-			// A zero-allocation license grants the feature disabled with a
-			// zero limit. Premium licenses without agent_runtime_hours_*
-			// claims are grandfathered into the same shape, so this case
-			// pins that both stay capped.
 			name: "DisabledZeroAllocation",
 			feature: &codersdk.Feature{
 				Entitlement: codersdk.EntitlementEntitled,

@@ -421,19 +421,24 @@ export const QueuedForCapacityPremiumMember: Story = {
 	},
 };
 
-export const QueuedForCapacityPremiumExhaustedHours: Story = {
+export const QueuedForCapacityPremiumHardLimit: Story = {
 	parameters: {
 		features: [
 			"multiple_organizations",
-			{ name: "agent_runtime_hours", limit: 4000, actual: 4000 },
+			{
+				name: "agent_runtime_hours",
+				limit: 3000,
+				hard_limit: 4000,
+				actual: 4000,
+			},
 		],
 		permissions: { viewAllLicenses: true },
 	},
 	render: () => <StoryAgentChatPageView queuedForCapacity />,
 	play: async ({ canvasElement }) => {
 		const canvas = within(canvasElement);
 		const message = canvas.getByText(
-			/used all 4000 agent runtime hours included in your license/,
+			/reached the 4000-hour Agent Hours hard limit/,
 		);
 		expect(message).toBeVisible();
 		expect(message).toHaveTextContent(