@@ -151,7 +151,10 @@ describe('/api/v2/chat-deployments', () => {
       workflowId: WORKFLOW_ID,
       workflow: { id: WORKFLOW_ID, name: 'Support', workspaceId: WORKSPACE_ID },
     })
-    mocks.listDeployments.mockResolvedValue({ data: [chatRow()], nextCursorKeys: null })
+    mocks.listDeployments.mockResolvedValue({
+      data: [{ chat: chatRow(), isWorkflowDeployed: true }],
+      nextCursorKeys: null,
+    })
     mocks.getLiveChatDeployment.mockResolvedValue(null)
     mocks.getIdentifierOwner.mockResolvedValue(null)
     mocks.validateChatDeployAuth.mockResolvedValue(undefined)
@@ -203,12 +206,15 @@ describe('/api/v2/chat-deployments', () => {
     it('omits the fields the admin-gated detail read carries', async () => {
       mocks.listDeployments.mockResolvedValue({
         data: [
-          chatRow({
-            authType: 'password',
-            password: 'encrypted-secret',
-            allowedEmails: ['gated@example.com'],
-            customizations: { primaryColor: '#gated', welcomeMessage: 'gated-welcome' },
-          }),
+          {
+            chat: chatRow({
+              authType: 'password',
+              password: 'encrypted-secret',
+              allowedEmails: ['gated@example.com'],
+              customizations: { primaryColor: '#gated', welcomeMessage: 'gated-welcome' },
+            }),
+            isWorkflowDeployed: true,
+          },
         ],
         nextCursorKeys: null,
       })
@@ -229,7 +235,12 @@ describe('/api/v2/chat-deployments', () => {
     /** Narrowing must not cost discovery: the mode label and identity stay. */
     it('still carries what a caller needs to decide whether to fetch the detail', async () => {
       mocks.listDeployments.mockResolvedValue({
-        data: [chatRow({ authType: 'password', password: 'encrypted-secret' })],
+        data: [
+          {
+            chat: chatRow({ authType: 'password', password: 'encrypted-secret' }),
+            isWorkflowDeployed: true,
+          },
+        ],
         nextCursorKeys: null,
       })
 
@@ -246,6 +257,17 @@ describe('/api/v2/chat-deployments', () => {
       })
     })
 
+    it('reports a configured chat inactive when its workflow is undeployed', async () => {
+      mocks.listDeployments.mockResolvedValue({
+        data: [{ chat: chatRow({ isActive: true }), isWorkflowDeployed: false }],
+        nextCursorKeys: null,
+      })
+
+      const body = await (await get()).json()
+
+      expect(body.data[0].isActive).toBe(false)
+    })
+
     it('passes the workflow and active filters to the read', async () => {
       await get(`?workspaceId=${WORKSPACE_ID}&workflowId=${WORKFLOW_ID}&isActive=false`)
 
@@ -256,7 +278,7 @@ describe('/api/v2/chat-deployments', () => {
 
     it('rejects a cursor minted under different filters', async () => {
       mocks.listDeployments.mockResolvedValue({
-        data: [chatRow()],
+        data: [{ chat: chatRow(), isWorkflowDeployed: true }],
         nextCursorKeys: [{ key: 'createdAt', value: '2026-06-12T10:30:00.000Z' }],
       })
       const cursor = (await (await get()).json()).nextCursor
 
@@ -171,7 +171,12 @@ describe('/api/v2/workflows/[workflowId]/deployments/chat', () => {
     mocks.resolveWorkflowContext.mockResolvedValue({
       ...workspaceContext,
       workflowId: WORKFLOW_ID,
-      workflow: { id: WORKFLOW_ID, name: 'Support', workspaceId: WORKSPACE_ID },
+      workflow: {
+        id: WORKFLOW_ID,
+        name: 'Support',
+        workspaceId: WORKSPACE_ID,
+        isDeployed: true,
+      },
     })
     mocks.getLiveChatDeployment.mockResolvedValue(chatRow())
     mocks.getIdentifierOwner.mockResolvedValue(null)
@@ -215,6 +220,23 @@ describe('/api/v2/workflows/[workflowId]/deployments/chat', () => {
       expect((await response.json()).error.code).toBe('NOT_FOUND')
     })
 
+    it('reports the chat inactive when its workflow is undeployed', async () => {
+      mocks.resolveWorkflowContext.mockResolvedValue({
+        ...workspaceContext,
+        workflowId: WORKFLOW_ID,
+        workflow: {
+          id: WORKFLOW_ID,
+          name: 'Support',
+          workspaceId: WORKSPACE_ID,
+          isDeployed: false,
+        },
+      })
+
+      const body = await (await get()).json()
+
+      expect(body.data.isActive).toBe(false)
+    })
+
     /** The gate configuration it carries is admin-only, unlike the workspace list. */
     it('refuses a caller below workspace admin with 403', async () => {
       mocks.resolvePermission.mockResolvedValue('write')
 
@@ -30,6 +30,15 @@ export function toChatDeploymentView(row: ChatDeploymentRow): ChatDeploymentView
   }
 }
 
+/** A chat can answer only while both it and its workflow deployment are active. */
+export function toEffectiveChatDeploymentView(
+  row: ChatDeploymentRow,
+  isWorkflowDeployed: boolean
+): ChatDeploymentView {
+  const deployment = toChatDeploymentView(row)
+  return { ...deployment, isActive: deployment.isActive && isWorkflowDeployed }
+}
+
 export interface ListChatDeploymentsInput {
   workspaceId: string
   workflowId?: string
@@ -56,7 +65,9 @@ export const listChatDeployments = defineAuthorizedWorkspaceUseCase({
       cursorKeys: input.cursorKeys,
     })
     return {
-      deployments: page.data.map(toChatDeploymentView),
+      deployments: page.data.map(({ chat, isWorkflowDeployed }) =>
+        toEffectiveChatDeploymentView(chat, isWorkflowDeployed)
+      ),
       nextCursorKeys: page.nextCursorKeys,
     }
   },
 
@@ -18,6 +18,7 @@ import { chatDeploymentOperations } from '@/lib/chat-deployments/application/ope
 import {
   type ChatDeploymentView,
   toChatDeploymentView,
+  toEffectiveChatDeploymentView,
 } from '@/lib/chat-deployments/application/read-chat-deployments'
 import {
   getChatDeploymentIdOwningIdentifier,
@@ -96,7 +97,10 @@ export const readWorkflowChatDeployment = defineAuthorizedWorkspaceUseCase({
   authorizationOptions: {},
   async execute({ context }): Promise<WorkflowChatDeploymentResult> {
     return {
-      deployment: toChatDeploymentView(requireWorkflowChatDeployment(context)),
+      deployment: toEffectiveChatDeploymentView(
+        requireWorkflowChatDeployment(context),
+        context.workflow.isDeployed
+      ),
       workspaceId: context.workspaceId,
       workflowId: context.workflowId,
     }
 
@@ -1,6 +1,6 @@
 import { db } from '@sim/db'
 import { chat, workflow } from '@sim/db/schema'
-import { and, eq, isNull } from 'drizzle-orm'
+import { and, eq, isNull, or } from 'drizzle-orm'
 import {
   type CursorKey,
   type KeysetKey,
@@ -25,7 +25,12 @@ import {
 export type ChatDeploymentRow = typeof chat.$inferSelect
 export type ChatDeploymentSortBy = 'identifier' | 'createdAt' | 'updatedAt'
 
-const chatDeploymentId = textKey<ChatDeploymentRow>(chat.id, (row) => row.id)
+export interface ChatDeploymentWithWorkflowStatus {
+  chat: ChatDeploymentRow
+  isWorkflowDeployed: boolean
+}
+
+const chatDeploymentId = textKey<ChatDeploymentWithWorkflowStatus>(chat.id, (row) => row.chat.id)
 
 /**
  * Keyset orderings for the public list's sortable fields, made total over the
@@ -34,18 +39,25 @@ const chatDeploymentId = textKey<ChatDeploymentRow>(chat.id, (row) => row.id)
  */
 const CHAT_DEPLOYMENT_SORTS = {
   identifier: [
-    textKey<ChatDeploymentRow>(chat.identifier, (row) => row.identifier),
+    textKey<ChatDeploymentWithWorkflowStatus>(chat.identifier, (row) => row.chat.identifier),
     chatDeploymentId,
   ],
   createdAt: [
-    timestampKey<ChatDeploymentRow>(chat.createdAt, (row) => row.createdAt),
+    timestampKey<ChatDeploymentWithWorkflowStatus>(chat.createdAt, (row) => row.chat.createdAt),
     chatDeploymentId,
   ],
   updatedAt: [
-    timestampKey<ChatDeploymentRow>(chat.updatedAt, (row) => row.updatedAt),
+    timestampKey<ChatDeploymentWithWorkflowStatus>(chat.updatedAt, (row) => row.chat.updatedAt),
     chatDeploymentId,
   ],
-} satisfies Record<ChatDeploymentSortBy, readonly KeysetKey<ChatDeploymentRow>[]>
+} satisfies Record<ChatDeploymentSortBy, readonly KeysetKey<ChatDeploymentWithWorkflowStatus>[]>
+
+function effectiveChatActiveFilter(isActive: boolean | undefined) {
+  if (isActive === undefined) return undefined
+  return isActive
+    ? and(eq(chat.isActive, true), eq(workflow.isDeployed, true))
+    : or(eq(chat.isActive, false), eq(workflow.isDeployed, false))
+}
 
 /** One keyset page of live chat deployments whose workflow lives in a workspace. */
 export async function listWorkspaceChatDeployments(params: {
@@ -56,13 +68,13 @@ export async function listWorkspaceChatDeployments(params: {
   sortOrder?: ListSortOrder
   limit: number
   cursorKeys?: CursorKey[]
-}): Promise<KeysetPage<ChatDeploymentRow>> {
+}): Promise<KeysetPage<ChatDeploymentWithWorkflowStatus>> {
   const { sortBy = 'createdAt', sortOrder = 'desc', limit } = params
   const keys = CHAT_DEPLOYMENT_SORTS[sortBy]
   const resumeAfter = resumeKeyset(keys, params.cursorKeys, sortOrder)
 
   const rows = await db
-    .select({ chat })
+    .select({ chat, isWorkflowDeployed: workflow.isDeployed })
     .from(chat)
     .innerJoin(workflow, eq(chat.workflowId, workflow.id))
     .where(
@@ -71,18 +83,14 @@ export async function listWorkspaceChatDeployments(params: {
         isNull(workflow.archivedAt),
         isNull(chat.archivedAt),
         params.workflowId === undefined ? undefined : eq(chat.workflowId, params.workflowId),
-        params.isActive === undefined ? undefined : eq(chat.isActive, params.isActive),
+        effectiveChatActiveFilter(params.isActive),
         resumeAfter
       )
     )
     .orderBy(...listOrderBy(keysetColumns(keys), sortOrder))
     .limit(limit + 1)
 
-  return keysetPage(
-    keys,
-    rows.map((row) => row.chat),
-    limit
-  )
+  return keysetPage(keys, rows, limit)
 }
 
 /**