diff --git a/products/workflows/frontend/WorkflowsScene.tsx b/products/workflows/frontend/WorkflowsScene.tsx
index 7aba15ff2148..9459b9a6e32f 100644
--- a/products/workflows/frontend/WorkflowsScene.tsx
+++ b/products/workflows/frontend/WorkflowsScene.tsx
@@ -1,10 +1,23 @@
-import { MakeLogicType, actions, kea, path, props, reducers, selectors, useActions, useValues } from 'kea'
+import {
+ MakeLogicType,
+ actions,
+ kea,
+ path,
+ props,
+ reducers,
+ selectors,
+ useActions,
+ useMountedLogic,
+ useValues,
+} from 'kea'
import { urlToAction } from 'kea-router'
import { LemonButton } from '@posthog/lemon-ui'
import { AccessControlAction } from 'lib/components/AccessControlAction'
+import { FEATURE_FLAGS } from 'lib/constants'
import { LemonTab, LemonTabs } from 'lib/lemon-ui/LemonTabs'
+import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
import { trackedActionToUrl } from 'lib/logic/scenes/trackedActionToUrl'
import { addProductIntent } from 'lib/utils/product-intents'
import { capitalizeFirstLetter } from 'lib/utils/strings'
@@ -17,8 +30,10 @@ import { SceneTitleSection } from '~/layout/scenes/components/SceneTitleSection'
import { ProductIntentContext, ProductKey } from '~/queries/schema/schema-general'
import { AccessControlLevel, AccessControlResourceType, Breadcrumb } from '~/types'
+import { ownSenderQuickStartLogic } from './Channels/ownSenderQuickStartLogic'
import { EmailSuspensionBanner } from './EmailSuspensionBanner'
import { workflowsEmptyState } from './emptyState/workflowsEmptyState'
+import { WorkflowsFirstRunTab } from './firstRun/WorkflowsFirstRunTab'
import { MessagingTabActions } from './MessagingTabActions'
import { messagingNavTabs } from './messagingTabs'
import { newWorkflowLogic } from './Workflows/newWorkflowLogic'
@@ -125,11 +140,13 @@ export const scene: SceneExport = {
export function WorkflowsScene(props: WorkflowsSceneProps = {}): JSX.Element {
const { currentTab } = useValues(workflowsSceneLogic(props))
const { startNewWorkflow } = useActions(newWorkflowLogic)
+ const { featureFlags } = useValues(featureFlagLogic)
+ useMountedLogic(ownSenderQuickStartLogic)
const tabs: LemonTab[] = [
{
label: 'Workflows',
key: 'workflows',
- content: = {
+ id: '019b6f44-f9a3-0000-c4a7-b8050d25d690',
+ name: 'Welcome',
+ scope: 'global',
+ starts_on: { kind: 'event', events: ['user signed up'], detail: '' },
+ tags: [],
+ actions: [],
+}
+
+describe('FirstRunAgentHelp', () => {
+ let seenEvents: string[]
+
+ beforeEach(() => {
+ seenEvents = []
+ useMocks({
+ get: {
+ '/api/projects/:team_id/hog_flow_templates/': { count: 1, results: [WELCOME] },
+ '/api/projects/:team_id/event_definitions/': () => [
+ 200,
+ {
+ count: seenEvents.length,
+ results: seenEvents.map((name) => ({ id: name, name, last_seen_at: '2026-10-01T00:00:00Z' })),
+ },
+ ],
+ '/api/projects/:team_id/property_definitions/': { count: 0, results: [] },
+ },
+ })
+ initKeaTests()
+ featureFlagLogic.actions.setFeatureFlags([], { [FEATURE_FLAGS.WORKFLOWS_FIRST_RUN]: true })
+ })
+
+ afterEach(() => {
+ cleanup()
+ jest.restoreAllMocks()
+ window.localStorage.clear()
+ })
+
+ function renderForProject(project: { seenEvents: string[] }): void {
+ seenEvents = project.seenEvents
+ render( = {
+ signup_event: {
+ type: 'info',
+ message:
+ 'You can test an email right now. To send it to real signups, your app needs to tell PostHog when someone signs up.',
+ prompt: SIGNUP_EVENT_PROMPT,
+ wizardCheck: 'Check that its changes send a "user signed up" event when someone signs up.',
+ },
+ email: {
+ type: 'warning',
+ message:
+ "People in this project have no email address yet, so they would miss your emails. Your app needs to send each user's email to PostHog.",
+ prompt: EMAIL_PROMPT,
+ wizardCheck: "Check that its changes set each user's email when your app identifies them.",
+ },
+}
+
+export function FirstRunAgentHelp(): JSX.Element | null {
+ const { missingData, wizardShown } = useValues(firstRunAgentHelpLogic)
+ const { reportPromptCopied, setWizardShown } = useActions(firstRunAgentHelpLogic)
+ const { isCloudOrDev } = useWizardCommand()
+
+ if (!missingData) {
+ return null
+ }
+ const { type, message, prompt, wizardCheck } = AGENT_HELP[missingData]
+
+ return (
+
+
+ )
+}
diff --git a/products/workflows/frontend/firstRun/FirstRunWorkflowBanner.stories.tsx b/products/workflows/frontend/firstRun/FirstRunWorkflowBanner.stories.tsx
new file mode 100644
index 000000000000..13b990d5a5a5
--- /dev/null
+++ b/products/workflows/frontend/firstRun/FirstRunWorkflowBanner.stories.tsx
@@ -0,0 +1,102 @@
+import { Meta, StoryObj } from '@storybook/react'
+import { BindLogic } from 'kea'
+
+import { FEATURE_FLAGS } from 'lib/constants'
+import { App } from 'scenes/App'
+import { urls } from 'scenes/urls'
+
+import { mswDecorator } from '~/mocks/browser'
+import { toPaginatedResponse } from '~/mocks/handlers'
+
+import welcomeEmailSequence from '../../backend/templates/welcome_email_sequence_template.json'
+import type { HogFlow } from '../Workflows/hogflows/types'
+import { workflowLogic } from '../Workflows/workflowLogic'
+import { OWN_SENDER } from './firstRunStoryFixtures'
+import { FirstRunWorkflowBanner } from './FirstRunWorkflowBanner'
+import { rememberFirstRunWorkflow } from './firstRunWorkflowStorage'
+import { withFirstRunSender } from './withFirstRunSender'
+
+const FIRST_RUN_WORKFLOW_ID = 'storybook-first-run-workflow'
+
+function firstRunWorkflow(status: HogFlow['status']): HogFlow {
+ const { id, scope, image_url, ...content } = welcomeEmailSequence as unknown as HogFlow & {
+ scope: string
+ image_url: string
+ }
+ return {
+ ...content,
+ actions: withFirstRunSender(content.actions, { id: OWN_SENDER.id! }),
+ id: FIRST_RUN_WORKFLOW_ID,
+ status,
+ version: 1,
+ created_at: '2026-10-05T12:00:00.000Z',
+ updated_at: '2026-10-05T12:00:00.000Z',
+ } as HogFlow
+}
+
+function workflowWithStatus(status: HogFlow['status']): Parameters[0] {
+ return {
+ get: {
+ '/api/environments/:team_id/hog_flows/:id/': () => [200, firstRunWorkflow(status)],
+ '/api/projects/:team_id/hog_flow_templates/': { count: 0, results: [] },
+ '/api/environments/:team_id/messaging_categories': { count: 0, results: [] },
+ '/api/projects/:team_id/integrations/': toPaginatedResponse([OWN_SENDER]),
+ },
+ patch: {
+ '/api/environments/:team_id/hog_flows/:id/': async ({ request }) => [
+ 200,
+ { ...firstRunWorkflow(status), ...((await request.json()) as Partial) },
+ ],
+ },
+ }
+}
+
+const meta: Meta = {
+ component: App,
+ title: 'Products/Workflows/First run workflow banner',
+ parameters: {
+ layout: 'fullscreen',
+ viewMode: 'story',
+ mockDate: '2026-10-05',
+ pageUrl: urls.workflow(FIRST_RUN_WORKFLOW_ID, 'workflow'),
+ featureFlags: [FEATURE_FLAGS.WORKFLOWS_FIRST_RUN],
+ testOptions: { viewport: { width: 1440, height: 900 }, waitForLoadersToDisappear: true },
+ },
+ decorators: [
+ (Story) => {
+ rememberFirstRunWorkflow(FIRST_RUN_WORKFLOW_ID)
+ return
+
+ )
+}
+
+export const Draft: Story = {
+ decorators: [mswDecorator(workflowWithStatus('draft'))],
+}
+
+export const Sending: Story = {
+ decorators: [mswDecorator(workflowWithStatus('active'))],
+}
+
+export const DraftNarrow: Story = {
+ render: () =>
+
+ )
+ }
+
+ return (
+
+
+ )
+}
diff --git a/products/workflows/frontend/firstRun/GalleryTemplateCard.tsx b/products/workflows/frontend/firstRun/GalleryTemplateCard.tsx
new file mode 100644
index 000000000000..ec760422d286
--- /dev/null
+++ b/products/workflows/frontend/firstRun/GalleryTemplateCard.tsx
@@ -0,0 +1,64 @@
+import { useActions } from 'kea'
+
+import { IconStarFilled, IconWarning } from '@posthog/icons'
+import { LemonTag } from '@posthog/lemon-ui'
+
+import { WorkflowTemplateCard } from '../Workflows/templates/WorkflowTemplateCard'
+import { WorkflowTemplateSteps } from '../Workflows/templates/WorkflowTemplateSteps'
+import { firstRunGalleryLogic, GalleryTemplate } from './firstRunGalleryLogic'
+import { TemplateStartsOnLine } from './TemplateStartsOnLine'
+
+export function GalleryTemplateCard({
+ galleryTemplate,
+ recommendedBecause,
+}: {
+ galleryTemplate: GalleryTemplate
+ recommendedBecause?: string
+}): JSX.Element {
+ const { pickTemplate } = useActions(firstRunGalleryLogic)
+ const { template, startsOn, ready } = galleryTemplate
+
+ return (
+
+ Test sent to {outcome.recipient}. Check your inbox.
+
+ )
+ }
+ if (outcome.kind === 'skipped') {
+ return (
+
+ Nothing was sent. {outcome.reason}
+
+ )
+ }
+ return (
+
+ Couldn't send the test email. Try again.
+
+ )
+}
diff --git a/products/workflows/frontend/firstRun/MakeItYoursEmailList.tsx b/products/workflows/frontend/firstRun/MakeItYoursEmailList.tsx
new file mode 100644
index 000000000000..c43f77d16d39
--- /dev/null
+++ b/products/workflows/frontend/firstRun/MakeItYoursEmailList.tsx
@@ -0,0 +1,44 @@
+import { useActions, useValues } from 'kea'
+
+import { LemonButton, LemonTag } from '@posthog/lemon-ui'
+
+import { firstRunMakeItYoursLogic } from './firstRunMakeItYoursLogic'
+
+export function MakeItYoursEmailList({ templateId }: { templateId: string }): JSX.Element {
+ const logic = firstRunMakeItYoursLogic({ templateId })
+ const { templateEmails, openEmailId, editedEmailIds } = useValues(logic)
+ const { openEmail } = useActions(logic)
+
+ return (
+
+
+ )
+}
diff --git a/products/workflows/frontend/firstRun/WorkflowsFirstRun.stories.tsx b/products/workflows/frontend/firstRun/WorkflowsFirstRun.stories.tsx
new file mode 100644
index 000000000000..52b7ddc61ee0
--- /dev/null
+++ b/products/workflows/frontend/firstRun/WorkflowsFirstRun.stories.tsx
@@ -0,0 +1,69 @@
+import { MOCK_DEFAULT_TEAM } from 'lib/api.mock'
+
+import { Meta, StoryObj } from '@storybook/react'
+import { useMountedLogic } from 'kea'
+import { useEffect } from 'react'
+
+import { FEATURE_FLAGS } from 'lib/constants'
+import { App } from 'scenes/App'
+import { teamLogic } from 'scenes/teamLogic'
+import { urls } from 'scenes/urls'
+
+import { mswDecorator } from '~/mocks/browser'
+import { EMPTY_PAGINATED_RESPONSE, toPaginatedResponse } from '~/mocks/handlers'
+
+import { globalTemplates, projectThatSends } from './firstRunStoryFixtures'
+
+const meta: Meta = {
+ component: App,
+ title: 'Products/Workflows/First run gallery',
+ parameters: {
+ layout: 'fullscreen',
+ viewMode: 'story',
+ mockDate: '2026-10-05',
+ pageUrl: urls.workflows(),
+ featureFlags: [FEATURE_FLAGS.WORKFLOWS_FIRST_RUN],
+ testOptions: { viewport: { width: 1440, height: 2400 } },
+ },
+ decorators: [
+ mswDecorator({
+ get: {
+ '/api/projects/:team_id/hog_flows/': EMPTY_PAGINATED_RESPONSE,
+ '/api/projects/:team_id/hog_flows/email_sending_suspension/': {
+ email_sending_suspended: false,
+ email_sending_suspended_at: null,
+ email_sending_suspension_reason: '',
+ },
+ '/api/projects/:team_id/hog_flow_templates/': toPaginatedResponse(globalTemplates),
+ },
+ }),
+ ],
+}
+export default meta
+
+type Story = StoryObj<{}>
+
+export const ProjectWithSignups: Story = {
+ decorators: [mswDecorator(projectThatSends(['signed_up', '$pageview', '$feature_view']))],
+}
+
+export const ProjectWithOnlyPageviews: Story = {
+ decorators: [mswDecorator(projectThatSends(['$pageview']))],
+}
+
+export const ProjectWithNoEvents: Story = {
+ decorators: [mswDecorator(projectThatSends([]))],
+ render: function ProjectWithNoEvents(): JSX.Element {
+ useMountedLogic(teamLogic)
+ useEffect(() => {
+ teamLogic.actions.loadCurrentTeamSuccess({ ...MOCK_DEFAULT_TEAM, ingested_event: false })
+ }, [])
+ return
+ Couldn't load the template. Try again, or go back to the templates.
+
+ )
+ }
+ if (galleryTemplates === null) {
+ return
+ This template is not in the gallery anymore. Pick another one.
+
+ )
+ }
+
+ const { template } = pickedTemplate
+ const hasSeveralEmails = templateEmails.length > 1
+
+ return (
+
+ recipientEmail: string
+ workflowName: string
+ teamId: number | null
+}
+
+export interface FirstRunTestSend {
+ configuration: HogFlow
+ globals: CyclotronJobInvocationGlobals
+ mock_async_functions: boolean
+ current_action_id: string
+}
+
+export function buildFirstRunTestSend({
+ email,
+ sender,
+ recipientEmail,
+ workflowName,
+ teamId,
+}: FirstRunTestSendInput): FirstRunTestSend {
+ const emailAction: HogFlowAction = {
+ id: TEST_EMAIL_ACTION_ID,
+ type: 'function_email',
+ name: 'Send test email',
+ description: '',
+ created_at: 0,
+ updated_at: 0,
+ config: {
+ template_id: 'template-email',
+ inputs: {
+ email: {
+ value: {
+ ...email,
+ // One visible recipient on a test, whatever the template carries.
+ cc: '',
+ bcc: '',
+ from: { integrationId: sender.id },
+ to: { email: recipientEmail, name: '' },
+ },
+ templating: 'liquid',
+ },
+ },
+ },
+ }
+ const edges: HogFlowEdge[] = [
+ { from: TRIGGER_NODE_ID, to: TEST_EMAIL_ACTION_ID, type: 'continue' },
+ { from: TEST_EMAIL_ACTION_ID, to: EXIT_NODE_ID, type: 'continue' },
+ ]
+ const configuration: HogFlow = {
+ ...NEW_WORKFLOW,
+ team_id: teamId ?? NEW_WORKFLOW.team_id,
+ name: workflowName,
+ actions: [NEW_WORKFLOW.actions[0], emailAction, NEW_WORKFLOW.actions[1]],
+ edges,
+ }
+ return {
+ configuration,
+ globals: createExampleEvent(teamId ?? undefined, workflowName, '$pageview', recipientEmail),
+ // A test send is a real send. Mocking it would defeat the point.
+ mock_async_functions: false,
+ current_action_id: TEST_EMAIL_ACTION_ID,
+ }
+}
diff --git a/products/workflows/frontend/firstRun/buildFirstRunWorkflow.ts b/products/workflows/frontend/firstRun/buildFirstRunWorkflow.ts
new file mode 100644
index 000000000000..f74709282b39
--- /dev/null
+++ b/products/workflows/frontend/firstRun/buildFirstRunWorkflow.ts
@@ -0,0 +1,75 @@
+import type { EmailTemplate } from 'scenes/hog-functions/email-templater/types'
+
+import { isEmailAction } from '../Workflows/hogflows/steps/types'
+import type { HogFlow, HogFlowAction, HogFlowTemplate } from '../Workflows/hogflows/types'
+import type { FirstRunSender } from './firstRunSenderLogic'
+import { withFirstRunSender } from './withFirstRunSender'
+
+export interface FirstRunWorkflowInput {
+ template: HogFlowTemplate
+ matchedEvent: string | null
+ edits: Record
+ sender: Pick | null
+ enabled: boolean
+}
+
+function withEdits(actions: HogFlowAction[], edits: Record): HogFlowAction[] {
+ return actions.map((action) =>
+ isEmailAction(action) && edits[action.id]
+ ? {
+ ...action,
+ config: {
+ ...action.config,
+ inputs: {
+ ...action.config.inputs,
+ email: { ...action.config.inputs.email, value: edits[action.id] },
+ },
+ },
+ }
+ : action
+ )
+}
+
+function triggerEvent(filters: Record | undefined): string | undefined {
+ return filters?.events?.[0]?.id
+}
+
+function withMatchedEvent(actions: HogFlowAction[], matchedEvent: string | null): HogFlowAction[] {
+ return actions.map((action) => {
+ if (action.type !== 'trigger' || action.config.type !== 'event' || !matchedEvent) {
+ return action
+ }
+ const filters = action.config.filters ?? {}
+ if (triggerEvent(filters) === matchedEvent) {
+ return action
+ }
+ const [first, ...rest] = filters.events ?? []
+ return {
+ ...action,
+ config: {
+ ...action.config,
+ filters: {
+ ...filters,
+ events: [{ ...first, id: matchedEvent, name: matchedEvent, type: 'events', order: 0 }, ...rest],
+ },
+ },
+ }
+ })
+}
+
+export function buildFirstRunWorkflow({
+ template,
+ matchedEvent,
+ edits,
+ sender,
+ enabled,
+}: FirstRunWorkflowInput): Partial {
+ const { id, team_id, created_at, updated_at, created_by, image_url, tags, scope, ...content } = template
+ const editedActions = withMatchedEvent(withEdits(template.actions, edits), matchedEvent)
+ return {
+ ...content,
+ actions: sender ? withFirstRunSender(editedActions, sender) : editedActions,
+ status: enabled ? 'active' : 'draft',
+ version: 1,
+ }
+}
diff --git a/products/workflows/frontend/firstRun/firstRunAgentHelpLogic.test.ts b/products/workflows/frontend/firstRun/firstRunAgentHelpLogic.test.ts
new file mode 100644
index 000000000000..5a34d880ff90
--- /dev/null
+++ b/products/workflows/frontend/firstRun/firstRunAgentHelpLogic.test.ts
@@ -0,0 +1,155 @@
+import { expectLogic } from 'kea-test-utils'
+import posthog from 'posthog-js'
+
+import { FEATURE_FLAGS } from 'lib/constants'
+import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
+
+import { useMocks } from '~/mocks/jest'
+import { initKeaTests } from '~/test/init'
+
+import type { HogFlowTemplateApi } from '../generated/api.schemas'
+import { firstRunAgentHelpLogic } from './firstRunAgentHelpLogic'
+
+const WELCOME = '019b6f44-f9a3-0000-c4a7-b8050d25d690'
+
+const TEMPLATES: Partial[] = [
+ {
+ id: 'onboarding',
+ name: 'Onboarding',
+ scope: 'global',
+ starts_on: { kind: 'event', events: ['$pageview'], detail: '' },
+ tags: [],
+ actions: [],
+ },
+ {
+ id: WELCOME,
+ name: 'Welcome',
+ scope: 'global',
+ starts_on: { kind: 'event', events: ['user signed up', 'signed_up'], detail: '' },
+ tags: [],
+ actions: [],
+ },
+]
+
+describe('firstRunAgentHelpLogic', () => {
+ let logic: ReturnType
+ let capture: jest.SpyInstance
+
+ let seenEvents: string[]
+ let personProperties: string[]
+ let propertyRequests: number
+
+ beforeEach(() => {
+ seenEvents = []
+ personProperties = []
+ propertyRequests = 0
+ useMocks({
+ get: {
+ '/api/projects/:team_id/hog_flow_templates/': { count: TEMPLATES.length, results: TEMPLATES },
+ '/api/projects/:team_id/event_definitions/': ({ request }) => {
+ const names = new URL(request.url).searchParams.get('names')?.split(',') ?? []
+ const seen = names.filter((name) => seenEvents.includes(name))
+ return [
+ 200,
+ {
+ count: seen.length,
+ results: seen.map((name) => ({ id: name, name, last_seen_at: '2026-10-01T00:00:00Z' })),
+ },
+ ]
+ },
+ '/api/projects/:team_id/property_definitions/': ({ request }) => {
+ propertyRequests++
+ const params = new URL(request.url).searchParams
+ const names = params.get('properties')?.split(',') ?? []
+ const definitions =
+ params.get('type') === 'person' ? names.filter((name) => personProperties.includes(name)) : []
+ return [
+ 200,
+ { count: definitions.length, results: definitions.map((name) => ({ id: name, name })) },
+ ]
+ },
+ },
+ })
+ initKeaTests()
+ featureFlagLogic.actions.setFeatureFlags([], { [FEATURE_FLAGS.WORKFLOWS_FIRST_RUN]: true })
+ capture = jest.spyOn(posthog, 'capture').mockImplementation()
+ })
+
+ async function openFirstRun(project: {
+ seenEvents: string[]
+ personProperties: string[]
+ enabled?: boolean
+ }): Promise {
+ featureFlagLogic.actions.setFeatureFlags([], { [FEATURE_FLAGS.WORKFLOWS_FIRST_RUN]: project.enabled ?? true })
+ seenEvents = project.seenEvents
+ personProperties = project.personProperties
+ logic = firstRunAgentHelpLogic()
+ logic.mount()
+ await expectLogic(logic).toFinishAllListeners()
+ }
+
+ afterEach(() => {
+ logic?.unmount()
+ jest.restoreAllMocks()
+ })
+
+ const agentHelpShownCalls = (): unknown[][] =>
+ capture.mock.calls.filter(([event]) => event === 'workflows first run agent help shown')
+
+ it.each([
+ {
+ project: 'without a signup event',
+ seenEvents: ['$pageview'],
+ personProperties: ['email'],
+ missing: 'signup_event',
+ },
+ {
+ project: 'with signups but no email property',
+ seenEvents: ['signed_up'],
+ personProperties: ['name'],
+ missing: 'email',
+ },
+ {
+ project: 'without a signup event or an email property',
+ seenEvents: [],
+ personProperties: [],
+ missing: 'signup_event',
+ },
+ {
+ project: 'with signups and an email property',
+ seenEvents: ['signed_up', '$pageview'],
+ personProperties: ['email'],
+ missing: null,
+ },
+ {
+ project: 'while first run is disabled',
+ seenEvents: ['signed_up'],
+ personProperties: [],
+ missing: null,
+ enabled: false,
+ },
+ ])('asks a project $project for help with missing data: $missing', async ({ missing, ...project }) => {
+ await openFirstRun(project)
+ if (project.enabled === false) {
+ logic.actions.loadEmailProperty()
+ await expectLogic(logic).toFinishAllListeners()
+ }
+
+ expect(logic.values.missingData).toEqual(missing)
+ expect(agentHelpShownCalls()).toEqual(missing ? [['workflows first run agent help shown', { missing }]] : [])
+ expect(propertyRequests).toEqual(project.enabled === false ? 0 : 1)
+ })
+
+ it.each([true, false])('reports a copied prompt only while first run is enabled=%s', async (enabled) => {
+ await openFirstRun({ seenEvents: ['signed_up'], personProperties: [] })
+ featureFlagLogic.actions.setFeatureFlags([], { [FEATURE_FLAGS.WORKFLOWS_FIRST_RUN]: enabled })
+
+ logic.actions.reportPromptCopied()
+
+ if (enabled) {
+ expect(capture).toHaveBeenCalledWith('workflows first run agent prompt copied', { missing: 'email' })
+ } else {
+ expect(capture).not.toHaveBeenCalledWith('workflows first run agent prompt copied', expect.anything())
+ }
+ })
+})
diff --git a/products/workflows/frontend/firstRun/firstRunAgentHelpLogic.ts b/products/workflows/frontend/firstRun/firstRunAgentHelpLogic.ts
new file mode 100644
index 000000000000..b2b8eecb139d
--- /dev/null
+++ b/products/workflows/frontend/firstRun/firstRunAgentHelpLogic.ts
@@ -0,0 +1,164 @@
+import { MakeLogicType, actions, afterMount, connect, kea, listeners, path, reducers, selectors } from 'kea'
+import { loaders } from 'kea-loaders'
+import posthog from 'posthog-js'
+
+import { projectLogic } from 'scenes/projectLogic'
+
+import { propertyDefinitionsList } from '~/generated/core/api'
+
+import { firstRunGalleryLogic, GalleryTemplate, WELCOME_SEQUENCE_TEMPLATE_ID } from './firstRunGalleryLogic'
+
+// pinned: analytics property values
+export type MissingData = 'signup_event' | 'email'
+
+const EMAIL_PERSON_PROPERTY = 'email'
+
+function findWelcomeTemplate(galleryTemplates: GalleryTemplate[] | null): GalleryTemplate | null {
+ return galleryTemplates?.find(({ template }) => template.id === WELCOME_SEQUENCE_TEMPLATE_ID) ?? null
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface firstRunAgentHelpLogicValues {
+ firstRunEnabled: boolean // firstRunGalleryLogic
+ galleryTemplates: GalleryTemplate[] | null // firstRunGalleryLogic
+ currentProjectId: number | null // projectLogic
+ hasEmailProperty: boolean | null
+ hasEmailPropertyLoading: boolean
+ missingData: MissingData | null
+ signupEventSeen: boolean | null
+ wizardShown: boolean
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface firstRunAgentHelpLogicActions {
+ loadSeenEventsSuccess: (
+ seenEvents: string[],
+ payload?: string[] | undefined
+ ) => {
+ payload?: string[]
+ seenEvents: string[]
+ } // firstRunGalleryLogic
+ loadEmailProperty: () => any
+ loadEmailPropertyFailure: (
+ error: string,
+ errorObject?: any
+ ) => {
+ error: string
+ errorObject?: any
+ }
+ loadEmailPropertySuccess: (
+ hasEmailProperty: boolean,
+ payload?: any
+ ) => {
+ hasEmailProperty: boolean
+ payload?: any
+ }
+ reportAgentHelpShown: () => {
+ value: true
+ }
+ reportPromptCopied: () => {
+ value: true
+ }
+ setWizardShown: (wizardShown: boolean) => {
+ wizardShown: boolean
+ }
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface firstRunAgentHelpLogicMeta {
+ __keaTypeGenInternalSelectorTypes: {
+ signupEventSeen: (galleryTemplates: GalleryTemplate[] | null) => boolean | null
+ missingData: (
+ signupEventSeen: boolean | null,
+ hasEmailProperty: boolean | null,
+ firstRunEnabled: any
+ ) => MissingData | null
+ }
+}
+
+export type firstRunAgentHelpLogicType = MakeLogicType<
+ firstRunAgentHelpLogicValues,
+ firstRunAgentHelpLogicActions,
+ Record,
+ firstRunAgentHelpLogicMeta
+>
+
+export const firstRunAgentHelpLogic = kea([
+ path(['products', 'workflows', 'frontend', 'firstRun', 'firstRunAgentHelpLogic']),
+ connect(() => ({
+ values: [projectLogic, ['currentProjectId'], firstRunGalleryLogic, ['galleryTemplates', 'firstRunEnabled']],
+ actions: [firstRunGalleryLogic, ['loadSeenEventsSuccess']],
+ })),
+ actions({
+ reportAgentHelpShown: true,
+ reportPromptCopied: true,
+ setWizardShown: (wizardShown: boolean) => ({ wizardShown }),
+ }),
+ loaders(({ values }) => ({
+ hasEmailProperty: [
+ null as boolean | null,
+ {
+ loadEmailProperty: async (): Promise => {
+ if (!values.firstRunEnabled) {
+ return false
+ }
+ const response = await propertyDefinitionsList(String(values.currentProjectId), {
+ type: 'person',
+ properties: EMAIL_PERSON_PROPERTY,
+ limit: 1,
+ })
+ return response.results.length > 0
+ },
+ },
+ ],
+ })),
+ reducers({
+ wizardShown: [false, { setWizardShown: (_, { wizardShown }) => wizardShown }],
+ }),
+ selectors({
+ signupEventSeen: [
+ (s) => [s.galleryTemplates],
+ (galleryTemplates: GalleryTemplate[] | null): boolean | null => {
+ const welcome = findWelcomeTemplate(galleryTemplates)
+ return welcome ? welcome.matchedEvent !== null : null
+ },
+ ],
+ missingData: [
+ (s) => [s.signupEventSeen, s.hasEmailProperty, s.firstRunEnabled],
+ (
+ signupEventSeen: boolean | null,
+ hasEmailProperty: boolean | null,
+ firstRunEnabled: boolean
+ ): MissingData | null => {
+ if (!firstRunEnabled) {
+ return null
+ }
+ if (signupEventSeen === false) {
+ return 'signup_event'
+ }
+ return signupEventSeen && hasEmailProperty === false ? 'email' : null
+ },
+ ],
+ }),
+ listeners(({ actions, values, cache }) => ({
+ loadSeenEventsSuccess: () => actions.reportAgentHelpShown(),
+ loadEmailPropertySuccess: () => actions.reportAgentHelpShown(),
+ reportAgentHelpShown: () => {
+ if (!values.missingData || cache.agentHelpReported) {
+ return
+ }
+ cache.agentHelpReported = true
+ posthog.capture('workflows first run agent help shown', { missing: values.missingData })
+ },
+ reportPromptCopied: () => {
+ if (values.firstRunEnabled) {
+ posthog.capture('workflows first run agent prompt copied', { missing: values.missingData })
+ }
+ },
+ })),
+ afterMount(({ actions, values }) => {
+ if (values.firstRunEnabled) {
+ actions.loadEmailProperty()
+ }
+ }),
+])
diff --git a/products/workflows/frontend/firstRun/firstRunGalleryLogic.test.ts b/products/workflows/frontend/firstRun/firstRunGalleryLogic.test.ts
new file mode 100644
index 000000000000..181c3b64dbf8
--- /dev/null
+++ b/products/workflows/frontend/firstRun/firstRunGalleryLogic.test.ts
@@ -0,0 +1,255 @@
+import { MOCK_DEFAULT_TEAM } from 'lib/api.mock'
+
+import { router } from 'kea-router'
+import { expectLogic } from 'kea-test-utils'
+import posthog from 'posthog-js'
+
+import { FEATURE_FLAGS } from 'lib/constants'
+import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
+import { removeProjectIdIfPresent } from 'lib/utils/kea-router'
+import { teamLogic } from 'scenes/teamLogic'
+import { urls } from 'scenes/urls'
+
+import { resumeKeaLoadersErrors, silenceKeaLoadersErrors } from '~/initKea'
+import { useMocks } from '~/mocks/jest'
+import { initKeaTests } from '~/test/init'
+
+import type { HogFlowTemplateApi } from '../generated/api.schemas'
+import { firstRunGalleryLogic } from './firstRunGalleryLogic'
+
+const WELCOME = '019b6f44-f9a3-0000-c4a7-b8050d25d690'
+
+function emailTemplate(id: string, startsOn: HogFlowTemplateApi['starts_on']): Partial {
+ return {
+ id,
+ name: id,
+ scope: 'global',
+ starts_on: startsOn,
+ tags: [],
+ actions: [],
+ }
+}
+
+const TEMPLATES: Partial[] = [
+ emailTemplate('onboarding', { kind: 'event', events: ['$pageview'], detail: 'on /onboarding' }),
+ emailTemplate('trial', { kind: 'event', events: ['trial_started'], detail: '' }),
+ emailTemplate(WELCOME, { kind: 'event', events: ['user signed up', 'signed_up', 'sign_up'], detail: '' }),
+ emailTemplate('re-engagement', { kind: 'no_event', events: ['$pageview'], detail: 'for 14 days' }),
+ emailTemplate('unused-features', { kind: 'schedule', events: [], detail: 'every 10 days' }),
+ { ...emailTemplate('slack-alert', null), name: 'A global template without email' },
+ { ...emailTemplate('team-email', null), scope: 'team' },
+]
+
+describe('firstRunGalleryLogic', () => {
+ let logic: ReturnType
+ let requestedEventNames: string[][]
+ let templateRequests: number
+ let seenEvents: string[]
+ let plannedEvents: string[]
+
+ beforeEach(() => {
+ requestedEventNames = []
+ templateRequests = 0
+ seenEvents = []
+ plannedEvents = []
+ useMocks({
+ get: {
+ '/api/projects/:team_id/hog_flow_templates/': () => {
+ templateRequests++
+ return [200, { count: TEMPLATES.length, results: TEMPLATES }]
+ },
+ '/api/projects/:team_id/event_definitions/': ({ request }) => {
+ const names = new URL(request.url).searchParams.get('names')?.split(',') ?? []
+ requestedEventNames.push(names)
+ const definitions = names
+ .filter((name) => seenEvents.includes(name) || plannedEvents.includes(name))
+ .map((name) => ({
+ id: name,
+ name,
+ last_seen_at: seenEvents.includes(name) ? '2026-10-01T00:00:00Z' : null,
+ }))
+ .reverse()
+ return [200, { count: definitions.length, results: definitions }]
+ },
+ },
+ })
+ initKeaTests()
+ featureFlagLogic.actions.setFeatureFlags([], { [FEATURE_FLAGS.WORKFLOWS_FIRST_RUN]: true })
+ })
+
+ async function openGallery(project: {
+ seenEvents: string[]
+ plannedEvents?: string[]
+ ingestedEvent: boolean
+ enabled?: boolean
+ }): Promise {
+ featureFlagLogic.actions.setFeatureFlags([], { [FEATURE_FLAGS.WORKFLOWS_FIRST_RUN]: project.enabled ?? true })
+ seenEvents = project.seenEvents
+ plannedEvents = project.plannedEvents ?? []
+ teamLogic.actions.loadCurrentTeamSuccess({ ...MOCK_DEFAULT_TEAM, ingested_event: project.ingestedEvent })
+ logic = firstRunGalleryLogic()
+ logic.mount()
+ await expectLogic(logic).toFinishAllListeners()
+ }
+
+ afterEach(() => {
+ logic?.unmount()
+ jest.restoreAllMocks()
+ })
+
+ const shownIds = (): string[] => logic.values.shownTemplates.map(({ template }) => template.id)
+
+ it.each([
+ {
+ project: 'that sends signups and pageviews',
+ seenEvents: ['signed_up', '$pageview'],
+ ingestedEvent: true,
+ recommended: WELCOME,
+ welcomeMatchedEvent: 'signed_up',
+ picked: [WELCOME, 'onboarding', 're-engagement', 'unused-features'],
+ all: [WELCOME, 'onboarding', 're-engagement', 'unused-features', 'trial'],
+ },
+ {
+ project: 'that sends only pageviews',
+ seenEvents: ['$pageview'],
+ ingestedEvent: true,
+ recommended: 'onboarding',
+ welcomeMatchedEvent: null,
+ picked: ['onboarding', 're-engagement', 'unused-features'],
+ all: ['onboarding', 're-engagement', 'unused-features', 'trial', WELCOME],
+ },
+ {
+ project: 'that sends several signup events',
+ seenEvents: ['sign_up', 'user signed up'],
+ ingestedEvent: true,
+ recommended: WELCOME,
+ welcomeMatchedEvent: 'user signed up',
+ picked: [WELCOME, 'unused-features'],
+ all: [WELCOME, 'unused-features', 'onboarding', 'trial', 're-engagement'],
+ },
+ {
+ project: 'that only planned a signup event and sends pageviews',
+ seenEvents: ['$pageview'],
+ plannedEvents: ['signed_up'],
+ ingestedEvent: true,
+ recommended: 'onboarding',
+ welcomeMatchedEvent: null,
+ picked: ['onboarding', 're-engagement', 'unused-features'],
+ all: ['onboarding', 're-engagement', 'unused-features', 'trial', WELCOME],
+ },
+ {
+ project: 'that sends only events no template starts on',
+ seenEvents: [],
+ ingestedEvent: true,
+ recommended: 'unused-features',
+ welcomeMatchedEvent: null,
+ picked: ['unused-features'],
+ all: ['unused-features', 'onboarding', 'trial', WELCOME, 're-engagement'],
+ },
+ {
+ project: 'that sends no events',
+ seenEvents: [],
+ ingestedEvent: false,
+ recommended: null,
+ welcomeMatchedEvent: null,
+ picked: ['onboarding', 'trial', WELCOME, 're-engagement', 'unused-features'],
+ all: ['onboarding', 'trial', WELCOME, 're-engagement', 'unused-features'],
+ },
+ ])(
+ 'tailors the gallery to a project $project',
+ async ({ recommended, welcomeMatchedEvent, picked, all, ...project }) => {
+ await openGallery(project)
+
+ expect(logic.values.recommendedStarter?.templateId ?? null).toEqual(recommended)
+ expect(
+ logic.values.galleryTemplates?.find(({ template }) => template.id === WELCOME)?.matchedEvent
+ ).toEqual(welcomeMatchedEvent)
+ expect(shownIds()).toEqual(picked)
+
+ logic.actions.setFilter('all')
+ expect(shownIds()).toEqual(all)
+ }
+ )
+
+ it.each([true, false])('loads template fit only while first run is enabled=%s', async (enabled) => {
+ await openGallery({ seenEvents: [], ingestedEvent: false, enabled })
+ if (!enabled) {
+ logic.actions.loadEmailTemplates()
+ await expectLogic(logic).toFinishAllListeners()
+ }
+
+ expect(templateRequests).toEqual(enabled ? 1 : 0)
+ expect(requestedEventNames).toEqual(
+ enabled ? [['$pageview', 'trial_started', 'user signed up', 'signed_up', 'sign_up']] : []
+ )
+ })
+
+ it('reports the gallery once its fit is known', async () => {
+ const capture = jest.spyOn(posthog, 'capture').mockImplementation()
+ await openGallery({ seenEvents: ['signed_up', '$pageview'], ingestedEvent: true })
+
+ expect(capture).toHaveBeenCalledWith('workflows first run gallery shown', {
+ ready_count: 4,
+ recommended_template_id: WELCOME,
+ })
+ })
+
+ it.each([
+ { pick: 'the recommended starter', templateId: WELCOME, recommended: true, ready: true, enabled: true },
+ { pick: 'another ready template', templateId: 'onboarding', recommended: false, ready: true, enabled: true },
+ { pick: 'a template that is not ready', templateId: 'trial', recommended: false, ready: false, enabled: true },
+ {
+ pick: 'a loaded template after disabling first run',
+ templateId: WELCOME,
+ recommended: true,
+ ready: true,
+ enabled: false,
+ },
+ ])('honors the flag when picking $pick', async ({ templateId, recommended, ready, enabled }) => {
+ const capture = jest.spyOn(posthog, 'capture').mockImplementation()
+ await openGallery({ seenEvents: ['signed_up', '$pageview'], ingestedEvent: true })
+ featureFlagLogic.actions.setFeatureFlags([], { [FEATURE_FLAGS.WORKFLOWS_FIRST_RUN]: enabled })
+ const originalSearchParams = router.values.searchParams
+
+ logic.actions.pickTemplate(templateId)
+
+ if (enabled) {
+ expect(capture).toHaveBeenCalledWith('workflows first run template picked', {
+ template_id: templateId,
+ recommended,
+ ready,
+ })
+ expect(removeProjectIdIfPresent(router.values.location.pathname)).toBe(urls.workflows())
+ expect(router.values.searchParams).toEqual({ template: templateId })
+ } else {
+ expect(capture).not.toHaveBeenCalledWith('workflows first run template picked', expect.anything())
+ expect(router.values.searchParams).toEqual(originalSearchParams)
+ }
+ })
+
+ it.each([
+ { failing: 'the templates request', endpoint: '/api/projects/:team_id/hog_flow_templates/' },
+ { failing: 'the event definitions request', endpoint: '/api/projects/:team_id/event_definitions/' },
+ ])('offers a retry when $failing fails, and recovers on it', async ({ endpoint }) => {
+ silenceKeaLoadersErrors()
+ let failing = true
+ const healthyResponse = endpoint.includes('templates')
+ ? { count: TEMPLATES.length, results: TEMPLATES }
+ : { count: 0, results: [] }
+ useMocks({ get: { [endpoint]: () => (failing ? [500, { detail: 'Server error' }] : [200, healthyResponse]) } })
+
+ try {
+ await openGallery({ seenEvents: [], ingestedEvent: true })
+ expect(logic.values).toMatchObject({ galleryLoadFailed: true, galleryTemplates: null })
+
+ failing = false
+ logic.actions.loadEmailTemplates()
+ await expectLogic(logic).toFinishAllListeners()
+
+ expect(logic.values.galleryLoadFailed).toBe(false)
+ expect(logic.values.galleryTemplates).toHaveLength(5)
+ } finally {
+ resumeKeaLoadersErrors()
+ }
+ })
+})
diff --git a/products/workflows/frontend/firstRun/firstRunGalleryLogic.ts b/products/workflows/frontend/firstRun/firstRunGalleryLogic.ts
new file mode 100644
index 000000000000..6406362fbe5b
--- /dev/null
+++ b/products/workflows/frontend/firstRun/firstRunGalleryLogic.ts
@@ -0,0 +1,305 @@
+import { MakeLogicType, actions, connect, kea, listeners, path, reducers, selectors, afterMount } from 'kea'
+import { loaders } from 'kea-loaders'
+import { router } from 'kea-router'
+import posthog from 'posthog-js'
+
+import { FEATURE_FLAGS } from 'lib/constants'
+import { FeatureFlagsSet, featureFlagLogic } from 'lib/logic/featureFlagLogic'
+import { projectLogic } from 'scenes/projectLogic'
+import { teamLogic } from 'scenes/teamLogic'
+import { urls } from 'scenes/urls'
+
+import type { TeamPublicType, TeamType } from '~/types'
+
+import { eventDefinitionsList } from 'products/event_definitions/frontend/generated/api'
+
+import { hogFlowTemplatesList } from '../generated/api'
+import type { HogFlowTemplateApi, HogFlowTemplateStartsOnApi } from '../generated/api.schemas'
+import type { HogFlowTemplate } from '../Workflows/hogflows/types'
+
+// pinned: the id of the global welcome sequence in products/workflows/backend/templates/
+export const WELCOME_SEQUENCE_TEMPLATE_ID = '019b6f44-f9a3-0000-c4a7-b8050d25d690'
+
+// pinned: search param on the Workflows tab that addresses Make it yours, so bookmarks and reloads return to it
+export const FIRST_RUN_TEMPLATE_PARAM = 'template'
+
+export type GalleryFilter = 'picked' | 'all'
+
+export interface StartableTemplate {
+ template: HogFlowTemplate
+ startsOn: HogFlowTemplateStartsOnApi
+}
+
+export interface GalleryTemplate extends StartableTemplate {
+ matchedEvent: string | null
+ ready: boolean
+}
+
+export interface RecommendedStarter {
+ templateId: string
+ reason: string
+}
+
+function isEmailTemplate(
+ template: HogFlowTemplateApi
+): template is HogFlowTemplateApi & { starts_on: HogFlowTemplateStartsOnApi } {
+ return template.scope === 'global' && !!template.starts_on
+}
+
+function eventsToLookUp(emailTemplates: StartableTemplate[]): string[] {
+ return [...new Set(emailTemplates.flatMap(({ startsOn }) => startsOn.events))]
+}
+
+function fitTemplate(
+ { template, startsOn }: StartableTemplate,
+ seenEvents: Set,
+ projectIngestedEvents: boolean
+): GalleryTemplate {
+ if (startsOn.kind === 'schedule') {
+ return { template, startsOn, matchedEvent: null, ready: projectIngestedEvents }
+ }
+ const matchedEvent = startsOn.events.find((event) => seenEvents.has(event)) ?? null
+ return { template, startsOn, matchedEvent, ready: matchedEvent !== null }
+}
+
+function recommend(galleryTemplates: GalleryTemplate[]): RecommendedStarter | null {
+ const welcome = galleryTemplates.find(({ template }) => template.id === WELCOME_SEQUENCE_TEMPLATE_ID)
+ if (welcome?.ready) {
+ return {
+ templateId: welcome.template.id,
+ reason: 'Every new signup gets it, and your app already sends a signup event.',
+ }
+ }
+ const firstReady = galleryTemplates.find(({ ready }) => ready)
+ return firstReady
+ ? { templateId: firstReady.template.id, reason: 'It works with the events your app sends today.' }
+ : null
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface firstRunGalleryLogicValues {
+ featureFlags: FeatureFlagsSet // featureFlagLogic
+ currentProjectId: number | null // projectLogic
+ currentTeam: TeamPublicType | TeamType | null // teamLogic
+ activeFilter: GalleryFilter
+ emailTemplates: StartableTemplate[] | null
+ emailTemplatesLoading: boolean
+ filter: GalleryFilter
+ firstRunEnabled: boolean
+ galleryLoadFailed: boolean
+ galleryTemplates: GalleryTemplate[] | null
+ readyTemplates: GalleryTemplate[]
+ recommendedStarter: RecommendedStarter | null
+ seenEvents: string[] | null
+ seenEventsLoading: boolean
+ shownTemplates: GalleryTemplate[]
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface firstRunGalleryLogicActions {
+ loadEmailTemplates: () => any
+ loadEmailTemplatesFailure: (
+ error: string,
+ errorObject?: any
+ ) => {
+ error: string
+ errorObject?: any
+ }
+ loadEmailTemplatesSuccess: (
+ emailTemplates: StartableTemplate[],
+ payload?: any
+ ) => {
+ emailTemplates: StartableTemplate[]
+ payload?: any
+ }
+ loadSeenEvents: (names: string[]) => string[]
+ loadSeenEventsFailure: (
+ error: string,
+ errorObject?: any
+ ) => {
+ error: string
+ errorObject?: any
+ }
+ loadSeenEventsSuccess: (
+ seenEvents: string[],
+ payload?: string[]
+ ) => {
+ seenEvents: string[]
+ payload?: string[]
+ }
+ pickTemplate: (templateId: string) => {
+ templateId: string
+ }
+ setFilter: (filter: GalleryFilter) => {
+ filter: GalleryFilter
+ }
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface firstRunGalleryLogicMeta {
+ __keaTypeGenInternalSelectorTypes: {
+ firstRunEnabled: (featureFlags: FeatureFlagsSet) => boolean
+ galleryTemplates: (
+ emailTemplates: StartableTemplate[] | null,
+ seenEvents: string[] | null,
+ currentTeam: TeamPublicType | TeamType | null
+ ) => GalleryTemplate[] | null
+ recommendedStarter: (galleryTemplates: GalleryTemplate[] | null) => RecommendedStarter | null
+ readyTemplates: (galleryTemplates: GalleryTemplate[] | null) => GalleryTemplate[]
+ activeFilter: (filter: GalleryFilter, readyTemplates: GalleryTemplate[]) => GalleryFilter
+ shownTemplates: (
+ galleryTemplates: GalleryTemplate[] | null,
+ recommendedStarter: RecommendedStarter | null,
+ activeFilter: GalleryFilter
+ ) => GalleryTemplate[]
+ }
+}
+
+export type firstRunGalleryLogicType = MakeLogicType<
+ firstRunGalleryLogicValues,
+ firstRunGalleryLogicActions,
+ Record,
+ firstRunGalleryLogicMeta
+>
+
+export const firstRunGalleryLogic = kea([
+ path(['products', 'workflows', 'frontend', 'firstRun', 'firstRunGalleryLogic']),
+ connect(() => ({
+ values: [projectLogic, ['currentProjectId'], teamLogic, ['currentTeam'], featureFlagLogic, ['featureFlags']],
+ })),
+ actions({
+ setFilter: (filter: GalleryFilter) => ({ filter }),
+ pickTemplate: (templateId: string) => ({ templateId }),
+ }),
+ loaders(({ values }) => ({
+ emailTemplates: [
+ null as StartableTemplate[] | null,
+ {
+ loadEmailTemplates: async (): Promise => {
+ if (!values.firstRunEnabled) {
+ return []
+ }
+ const response = await hogFlowTemplatesList(String(values.currentProjectId))
+ return response.results.filter(isEmailTemplate).map((template) => ({
+ template: template as unknown as HogFlowTemplate,
+ startsOn: template.starts_on,
+ }))
+ },
+ },
+ ],
+ seenEvents: [
+ null as string[] | null,
+ {
+ loadSeenEvents: async (names: string[]): Promise => {
+ if (!values.firstRunEnabled || names.length === 0) {
+ return []
+ }
+ const response = await eventDefinitionsList(String(values.currentProjectId), {
+ names,
+ limit: names.length,
+ })
+ // A definition can exist before its event arrives, for example one the Wizard planned.
+ return response.results.filter(({ last_seen_at }) => last_seen_at !== null).map(({ name }) => name)
+ },
+ },
+ ],
+ })),
+ reducers({
+ filter: ['picked' as GalleryFilter, { setFilter: (_, { filter }) => filter }],
+ galleryLoadFailed: [
+ false,
+ {
+ loadEmailTemplates: () => false,
+ loadEmailTemplatesFailure: () => true,
+ loadSeenEventsFailure: () => true,
+ },
+ ],
+ }),
+ selectors({
+ firstRunEnabled: [
+ (s) => [s.featureFlags],
+ (featureFlags: FeatureFlagsSet): boolean => !!featureFlags[FEATURE_FLAGS.WORKFLOWS_FIRST_RUN],
+ ],
+ galleryTemplates: [
+ (s) => [s.emailTemplates, s.seenEvents, s.currentTeam],
+ (
+ emailTemplates: StartableTemplate[] | null,
+ seenEvents: string[] | null,
+ currentTeam: TeamType | TeamPublicType | null
+ ): GalleryTemplate[] | null => {
+ if (!emailTemplates || !seenEvents) {
+ return null
+ }
+ const seen = new Set(seenEvents)
+ return emailTemplates.map((emailTemplate) =>
+ fitTemplate(emailTemplate, seen, !!currentTeam?.ingested_event)
+ )
+ },
+ ],
+ recommendedStarter: [
+ (s) => [s.galleryTemplates],
+ (galleryTemplates: GalleryTemplate[] | null): RecommendedStarter | null =>
+ galleryTemplates ? recommend(galleryTemplates) : null,
+ ],
+ readyTemplates: [
+ (s) => [s.galleryTemplates],
+ (galleryTemplates: GalleryTemplate[] | null): GalleryTemplate[] =>
+ (galleryTemplates ?? []).filter(({ ready }) => ready),
+ ],
+ activeFilter: [
+ (s) => [s.filter, s.readyTemplates],
+ (filter: GalleryFilter, readyTemplates: GalleryTemplate[]): GalleryFilter =>
+ readyTemplates.length === 0 ? 'all' : filter,
+ ],
+ shownTemplates: [
+ (s) => [s.galleryTemplates, s.recommendedStarter, s.activeFilter],
+ (
+ galleryTemplates: GalleryTemplate[] | null,
+ recommendedStarter: RecommendedStarter | null,
+ activeFilter: GalleryFilter
+ ): GalleryTemplate[] => {
+ const rank = ({ template, ready }: GalleryTemplate): number =>
+ template.id === recommendedStarter?.templateId ? 0 : ready ? 1 : 2
+ return (galleryTemplates ?? [])
+ .filter(({ ready }) => activeFilter === 'all' || ready)
+ .sort((a, b) => rank(a) - rank(b))
+ },
+ ],
+ }),
+ listeners(({ actions, values }) => ({
+ loadEmailTemplatesSuccess: ({ emailTemplates }) => {
+ if (values.firstRunEnabled) {
+ actions.loadSeenEvents(eventsToLookUp(emailTemplates))
+ }
+ },
+ loadSeenEventsSuccess: () => {
+ if (!values.firstRunEnabled) {
+ return
+ }
+ posthog.capture('workflows first run gallery shown', {
+ ready_count: values.readyTemplates.length,
+ recommended_template_id: values.recommendedStarter?.templateId ?? null,
+ })
+ },
+ pickTemplate: ({ templateId }) => {
+ if (!values.firstRunEnabled) {
+ return
+ }
+ const picked = values.galleryTemplates?.find(({ template }) => template.id === templateId)
+ if (!picked) {
+ return
+ }
+ posthog.capture('workflows first run template picked', {
+ template_id: templateId,
+ recommended: templateId === values.recommendedStarter?.templateId,
+ ready: picked.ready,
+ })
+ router.actions.push(urls.workflows(), { [FIRST_RUN_TEMPLATE_PARAM]: templateId })
+ },
+ })),
+ afterMount(({ actions, values }) => {
+ if (values.firstRunEnabled) {
+ actions.loadEmailTemplates()
+ }
+ }),
+])
diff --git a/products/workflows/frontend/firstRun/firstRunMakeItYoursLogic.test.ts b/products/workflows/frontend/firstRun/firstRunMakeItYoursLogic.test.ts
new file mode 100644
index 000000000000..7c0f58a14f45
--- /dev/null
+++ b/products/workflows/frontend/firstRun/firstRunMakeItYoursLogic.test.ts
@@ -0,0 +1,478 @@
+import { router } from 'kea-router'
+import { expectLogic } from 'kea-test-utils'
+import posthog from 'posthog-js'
+
+import { SetupTaskId, globalSetupLogic } from 'lib/components/ProductSetup'
+import { FEATURE_FLAGS } from 'lib/constants'
+import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
+import { removeProjectIdIfPresent } from 'lib/utils/kea-router'
+import { emailTemplaterLogic } from 'scenes/hog-functions/email-templater/emailTemplaterLogic'
+import type { EmailTemplate } from 'scenes/hog-functions/email-templater/types'
+import { urls } from 'scenes/urls'
+
+import { useMocks } from '~/mocks/jest'
+import { initKeaTests } from '~/test/init'
+
+import type { IntegrationConfigApi } from 'products/integrations/frontend/generated/api.schemas'
+
+import type { HogFlowTemplateApi } from '../generated/api.schemas'
+import type { HogFlow, HogFlowAction } from '../Workflows/hogflows/types'
+import { firstRunMakeItYoursLogic } from './firstRunMakeItYoursLogic'
+
+const SENDER = {
+ id: 5,
+ kind: 'email',
+ display_name: 'Sender ',
+ config: { verified: true, email: 'sender@example.com' },
+} satisfies Partial
+
+function emailAction(id: string, subject: string): HogFlowAction {
+ return {
+ id,
+ type: 'function_email',
+ name: subject,
+ description: '',
+ created_at: 0,
+ updated_at: 0,
+ config: {
+ template_id: 'template-email',
+ inputs: {
+ email: {
+ value: {
+ to: { email: '{{ person.properties.email }}', name: '' },
+ from: { name: '', email: '' },
+ subject,
+ html: ` = {
+ id: 'onboarding-sequence',
+ name: 'Onboarding sequence',
+ scope: 'global',
+ tags: [],
+ starts_on: { kind: 'event', events: ['user signed up', 'signed_up'], detail: '' },
+ actions: [
+ TRIGGER,
+ emailAction('email_last', 'Last reminder'),
+ emailAction('email_first', 'Welcome!'),
+ delayAction('delay_1', '1d'),
+ emailAction('email_second', 'Still there?'),
+ delayAction('delay_2', '2d'),
+ branchAction('branch_1'),
+ EXIT,
+ ] as unknown as HogFlowTemplateApi['actions'],
+ edges: [
+ { from: 'trigger_node', to: 'email_first', type: 'continue' },
+ { from: 'email_first', to: 'delay_1', type: 'continue' },
+ { from: 'delay_1', to: 'email_second', type: 'continue' },
+ { from: 'email_second', to: 'delay_2', type: 'continue' },
+ { from: 'delay_2', to: 'branch_1', type: 'continue' },
+ { from: 'branch_1', to: 'exit_node', type: 'continue' },
+ { from: 'branch_1', to: 'email_last', type: 'branch' },
+ { from: 'email_last', to: 'exit_node', type: 'continue' },
+ ],
+ exit_condition: 'exit_only_at_end',
+ conversion: { filters: [] },
+}
+
+const SINGLE: Partial = {
+ id: 'single-email',
+ name: 'One email',
+ scope: 'global',
+ tags: [],
+ starts_on: { kind: 'event', events: ['$pageview'], detail: '' },
+ actions: [TRIGGER, emailAction('email_only', 'Hello'), EXIT] as unknown as HogFlowTemplateApi['actions'],
+ edges: [
+ { from: 'trigger_node', to: 'email_only', type: 'continue' },
+ { from: 'email_only', to: 'exit_node', type: 'continue' },
+ ],
+}
+
+function editedEmail(subject: string): EmailTemplate {
+ return {
+ subject,
+ html: `): Record {
+ return Object.fromEntries(
+ (workflow.actions ?? [])
+ .filter((action) => action.type === 'function_email')
+ .map((action) => [action.id, action.config.inputs.email.value])
+ )
+}
+
+describe('firstRunMakeItYoursLogic', () => {
+ let logic: ReturnType
+ let integrations: Partial[]
+ let createdWorkflows: Partial[]
+ let createResponse: [number, Record]
+ let invocations: Record[]
+ let invocationResponse: Record
+ let completedSetupTasks: string[]
+
+ beforeEach(() => {
+ completedSetupTasks = []
+ integrations = [SENDER]
+ createdWorkflows = []
+ createResponse = [201, { id: 'wf-1', status: 'active' }]
+ invocations = []
+ invocationResponse = { status: 'success', logs: [], nextActionId: null }
+ useMocks({
+ get: {
+ '/api/projects/:team_id/hog_flow_templates/': { count: 2, results: [SEQUENCE, SINGLE] },
+ '/api/projects/:team_id/event_definitions/': ({ request }) => {
+ const names = new URL(request.url).searchParams.get('names')?.split(',') ?? []
+ const seen = names.filter((name) => ['signed_up', '$pageview'].includes(name))
+ return [
+ 200,
+ {
+ count: seen.length,
+ results: seen.map((name) => ({ id: name, name, last_seen_at: '2026-10-01T00:00:00Z' })),
+ },
+ ]
+ },
+ '/api/projects/:team_id/integrations/': () => [200, { results: integrations }],
+ },
+ post: {
+ '/api/projects/:team_id/hog_flows/': async ({ request }) => {
+ createdWorkflows.push((await request.json()) as Partial)
+ return createResponse
+ },
+ '/api/projects/:team_id/hog_flows/new/invocations/': async ({ request }) => {
+ invocations.push((await request.json()) as Record)
+ return [200, invocationResponse]
+ },
+ },
+ patch: {
+ '/api/projects/:team_id/': async ({ request }) => {
+ const { onboarding_tasks } = (await request.json()) as { onboarding_tasks: Record }
+ completedSetupTasks = Object.keys(onboarding_tasks).filter(
+ (taskId) => onboarding_tasks[taskId] === 'completed'
+ )
+ return [200, {}]
+ },
+ },
+ })
+ initKeaTests()
+ featureFlagLogic.actions.setFeatureFlags([], { [FEATURE_FLAGS.WORKFLOWS_FIRST_RUN]: true })
+ globalSetupLogic.mount()
+ window.POSTHOG_APP_CONTEXT!.resource_access_control = { hog_flow: 'editor' } as any
+ })
+
+ afterEach(() => {
+ logic?.unmount()
+ window.localStorage.clear()
+ })
+
+ async function open(templateId: string): Promise {
+ logic = firstRunMakeItYoursLogic({ templateId })
+ logic.mount()
+ await expectLogic(logic).toFinishAllListeners()
+ await expectLogic(logic).toMatchValues({ pickedTemplate: expect.anything() })
+ }
+
+ it('lists the emails in flow order with their timing and opens the first one', async () => {
+ await open('onboarding-sequence')
+
+ expect(logic.values.templateEmails.map(({ id, subject, timing }) => ({ id, subject, timing }))).toEqual([
+ { id: 'email_first', subject: 'Welcome!', timing: 'Right away' },
+ { id: 'email_second', subject: 'Still there?', timing: 'After 1 day' },
+ { id: 'email_last', subject: 'Last reminder', timing: 'After 3 days' },
+ ])
+ expect(logic.values.openEmail?.id).toBe('email_first')
+ expect(logic.values.openEmailPosition).toEqual({ index: 1, total: 3 })
+ })
+
+ it('keeps the edits of every email while switching between them', async () => {
+ await open('onboarding-sequence')
+
+ logic.actions.editEmail('email_first', editedEmail('Welcome!'))
+ logic.actions.openEmail('email_second')
+ logic.actions.editEmail('email_second', editedEmail('Still there?'))
+ logic.actions.openEmail('email_first')
+ await expectLogic(logic).toFinishAllListeners()
+
+ expect(logic.values.openEmail).toMatchObject({
+ id: 'email_first',
+ edited: true,
+ email: { subject: 'Welcome!', text: 'Welcome! edited' },
+ })
+ expect(logic.values.editedEmailIds).toEqual(['email_first', 'email_second'])
+ expect(logic.values.openEmailPosition).toEqual({ index: 1, total: 3 })
+ })
+
+ it.each([
+ { enabled: true, status: 'active', firstRunEnabled: true, completesLaunchTask: true },
+ { enabled: false, status: 'draft', firstRunEnabled: true, completesLaunchTask: false },
+ { enabled: false, status: 'draft', firstRunEnabled: false, completesLaunchTask: false },
+ ])(
+ 'honors first-run=$firstRunEnabled when creating a $status workflow with edits, sender and matched event',
+ async ({ enabled, status, firstRunEnabled, completesLaunchTask }) => {
+ createResponse = [201, { id: 'wf-1', status }]
+ const capture = jest.spyOn(posthog, 'capture').mockImplementation()
+ await open('onboarding-sequence')
+ logic.actions.editEmail('email_first', editedEmail('Welcome!'))
+ logic.actions.openEmail('email_last')
+ logic.actions.editEmail('email_last', editedEmail('Last reminder'))
+ logic.actions.setEnableWorkflow(enabled)
+ featureFlagLogic.actions.setFeatureFlags([], { [FEATURE_FLAGS.WORKFLOWS_FIRST_RUN]: firstRunEnabled })
+ const pathnameBefore = router.values.location.pathname
+
+ logic.actions.createWorkflow()
+ await expectLogic(logic).toFinishAllListeners()
+
+ if (!firstRunEnabled) {
+ expect(createdWorkflows).toHaveLength(0)
+ expect(router.values.location.pathname).toBe(pathnameBefore)
+ expect(window.localStorage.getItem('workflows-first-run-workflow-id')).toBeNull()
+ expect(capture).not.toHaveBeenCalledWith('workflows first run workflow created', expect.anything())
+ return
+ }
+
+ expect(createdWorkflows).toHaveLength(1)
+ const created = createdWorkflows[0]
+ expect(created).not.toHaveProperty('id')
+ expect(created).not.toHaveProperty('team_id')
+ expect(created).toMatchObject({ name: 'Onboarding sequence', status })
+ expect(emailStepsOf(created)).toEqual({
+ email_first: expect.objectContaining({ text: 'Welcome! edited', from: { integrationId: SENDER.id } }),
+ email_second: expect.objectContaining({ text: 'Still there?', from: { integrationId: SENDER.id } }),
+ email_last: expect.objectContaining({
+ text: 'Last reminder edited',
+ from: { integrationId: SENDER.id },
+ }),
+ })
+ const trigger = created.actions?.find((action) => action.type === 'trigger')
+ expect(trigger?.config).toEqual({
+ type: 'event',
+ filters: { events: [{ id: 'signed_up', name: 'signed_up', type: 'events', order: 0 }] },
+ })
+ expect(removeProjectIdIfPresent(router.values.location.pathname)).toBe(urls.workflow('wf-1', 'workflow'))
+ expect(window.localStorage.getItem('workflows-first-run-workflow-id')).toBe('wf-1')
+ expect(capture).toHaveBeenCalledWith('workflows first run workflow created', {
+ template_id: 'onboarding-sequence',
+ enabled,
+ })
+ expect(completedSetupTasks.includes(SetupTaskId.LaunchWorkflow)).toBe(completesLaunchTask)
+ }
+ )
+
+ it.each([true, false])('sends the edited email only while first run is enabled=%s', async (enabled) => {
+ const capture = jest.spyOn(posthog, 'capture').mockImplementation()
+ await open('onboarding-sequence')
+ logic.actions.openEmail('email_second')
+ await expectLogic(logic).toFinishAllListeners()
+ logic.actions.editEmail('email_second', editedEmail('Still there?'))
+ featureFlagLogic.actions.setFeatureFlags([], { [FEATURE_FLAGS.WORKFLOWS_FIRST_RUN]: enabled })
+
+ logic.actions.sendTest()
+ await expectLogic(logic).toFinishAllListeners()
+
+ if (!enabled) {
+ expect(invocations).toHaveLength(0)
+ expect(logic.values.testSendOutcome).toBeNull()
+ expect(capture).not.toHaveBeenCalledWith('workflows first run test sent', expect.anything())
+ return
+ }
+
+ expect(invocations).toHaveLength(1)
+ const [invocation] = invocations
+ expect(invocation).toMatchObject({ mock_async_functions: false, current_action_id: 'send_test_email' })
+ const emailSteps = emailStepsOf(invocation.configuration)
+ expect(emailSteps).toEqual({
+ send_test_email: expect.objectContaining({
+ text: 'Still there? edited',
+ from: { integrationId: SENDER.id },
+ to: { email: 'john.doe@posthog.com', name: '' },
+ }),
+ })
+ expect(logic.values.testSendOutcome).toEqual({ kind: 'sent', recipient: 'john.doe@posthog.com' })
+ expect(capture).toHaveBeenCalledWith('workflows first run test sent', { skipped: false })
+ expect(completedSetupTasks).toContain(SetupTaskId.SendWorkflowTestEmail)
+ })
+
+ it('shows why the worker skipped a test send', async () => {
+ const capture = jest.spyOn(posthog, 'capture').mockImplementation()
+ const reason = 'Skipping send: the recipient address has no mail server.'
+ invocationResponse = {
+ status: 'success',
+ nextActionId: null,
+ logs: [{ level: 'info', timestamp: '2026-10-05T00:00:00Z', message: reason }],
+ }
+ await open('onboarding-sequence')
+
+ logic.actions.sendTest()
+ await expectLogic(logic).toFinishAllListeners()
+
+ expect(logic.values.testSendOutcome).toEqual({ kind: 'skipped', reason })
+ expect(capture).toHaveBeenCalledWith('workflows first run test sent', { skipped: true })
+ expect(completedSetupTasks).not.toContain(SetupTaskId.SendWorkflowTestEmail)
+ })
+
+ it('without a first-run sender disables test and enable with a reason, and still creates a draft', async () => {
+ integrations = []
+ await open('onboarding-sequence')
+
+ expect(logic.values.sendTestDisabledReason).toBe('Connect an email sender first')
+ expect(logic.values.enableDisabledReason).toBe('Connect an email sender first')
+ expect(logic.values.enableWorkflow).toBe(false)
+
+ logic.actions.createWorkflow()
+ await expectLogic(logic).toFinishAllListeners()
+
+ expect(createdWorkflows[0]).toMatchObject({ status: 'draft' })
+ expect(emailStepsOf(createdWorkflows[0]).email_first.from).toEqual({ name: '', email: '' })
+ })
+
+ it('shows the server message of a rejected create and opens nothing', async () => {
+ createResponse = [400, { type: 'validation_error', detail: 'Pick at least one event.', attr: 'actions' }]
+ await open('onboarding-sequence')
+ const pathnameBefore = router.values.location.pathname
+
+ logic.actions.createWorkflow()
+ await expectLogic(logic).toFinishAllListeners()
+
+ expect(logic.values.createError).toBe('Pick at least one event.')
+ expect(logic.values.createdWorkflowLoading).toBe(false)
+ expect(router.values.location.pathname).toBe(pathnameBefore)
+ expect(window.localStorage.getItem('workflows-first-run-workflow-id')).toBeNull()
+ })
+
+ describe('while the editor still holds a canvas edit it has not exported', () => {
+ let templater: ReturnType
+
+ beforeEach(async () => {
+ useMocks({ get: { '/api/projects/:team_id/messaging_templates/': { count: 0, results: [] } } })
+ await open('onboarding-sequence')
+ templater = emailTemplaterLogic({ type: 'native_email_template', value: null, onChange: () => {} })
+ templater.mount()
+ templater.cache.pendingDesignEdit = true
+ })
+
+ afterEach(() => {
+ templater.unmount()
+ })
+
+ function editorExportsTheEdit(): void {
+ templater.cache.pendingDesignEdit = false
+ logic.actions.editEmail('email_first', editedEmail('Welcome!'))
+ }
+
+ it('switches emails only after the edit arrived, and keeps it', async () => {
+ logic.actions.openEmail('email_second')
+ await expectLogic(logic).toDispatchActions(['openEmail'])
+
+ expect(logic.values.openEmail?.id).toBe('email_first')
+
+ editorExportsTheEdit()
+ await expectLogic(logic).toFinishAllListeners()
+
+ expect(logic.values.openEmail?.id).toBe('email_second')
+ expect(logic.values.edits.email_first.text).toBe('Welcome! edited')
+ })
+
+ it.each(
+ (
+ [
+ {
+ action: 'sendTest',
+ requests: () => invocations,
+ text: (body: any) => emailStepsOf(body.configuration).send_test_email.text,
+ },
+ {
+ action: 'createWorkflow',
+ requests: () => createdWorkflows,
+ text: (body: any) => emailStepsOf(body).email_first.text,
+ },
+ ] as const
+ ).flatMap((testCase) => [
+ { ...testCase, enabled: true },
+ { ...testCase, enabled: false },
+ ])
+ )('$action waits for the edit and honors first-run=$enabled', async ({ action, requests, text, enabled }) => {
+ logic.actions[action]()
+ await expectLogic(logic).toDispatchActions([action])
+
+ expect(requests()).toHaveLength(0)
+
+ featureFlagLogic.actions.setFeatureFlags([], { [FEATURE_FLAGS.WORKFLOWS_FIRST_RUN]: enabled })
+ editorExportsTheEdit()
+ await expectLogic(logic).toFinishAllListeners()
+
+ expect(requests()).toHaveLength(enabled ? 1 : 0)
+ if (enabled) {
+ expect(text(requests()[0])).toBe('Welcome! edited')
+ }
+ })
+ })
+
+ it('disables test and create for a user without editor access to workflows', async () => {
+ window.POSTHOG_APP_CONTEXT!.resource_access_control = { hog_flow: 'viewer' } as any
+ await open('onboarding-sequence')
+
+ expect(logic.values.sendTestDisabledReason).toContain("You don't have sufficient permissions")
+ expect(logic.values.createDisabledReason).toContain("You don't have sufficient permissions")
+ })
+})
diff --git a/products/workflows/frontend/firstRun/firstRunMakeItYoursLogic.ts b/products/workflows/frontend/firstRun/firstRunMakeItYoursLogic.ts
new file mode 100644
index 000000000000..6a1ffdb91b94
--- /dev/null
+++ b/products/workflows/frontend/firstRun/firstRunMakeItYoursLogic.ts
@@ -0,0 +1,429 @@
+import {
+ BreakPointFunction,
+ LogicWrapper,
+ MakeLogicType,
+ actions,
+ connect,
+ kea,
+ key,
+ listeners,
+ path,
+ props,
+ reducers,
+ selectors,
+} from 'kea'
+import { loaders } from 'kea-loaders'
+import { router } from 'kea-router'
+import posthog from 'posthog-js'
+
+import api from 'lib/api'
+import { SetupTaskId, globalSetupLogic } from 'lib/components/ProductSetup'
+import { getAccessControlDisabledReason } from 'lib/utils/accessControlUtils'
+import { emailTemplaterLogic } from 'scenes/hog-functions/email-templater/emailTemplaterLogic'
+import type { EmailTemplate } from 'scenes/hog-functions/email-templater/types'
+import { projectLogic } from 'scenes/projectLogic'
+import { teamLogic } from 'scenes/teamLogic'
+import { urls } from 'scenes/urls'
+import { userLogic } from 'scenes/userLogic'
+
+import { AccessControlLevel, AccessControlResourceType, UserType } from '~/types'
+
+import { completeTestEmailSetupTask } from '../completeTestEmailSetupTask'
+import { hogFlowsCreate } from '../generated/api'
+import type { HogFlowApi } from '../generated/api.schemas'
+import { findTestSendSkipReason } from '../Workflows/hogflows/findTestSendSkipReason'
+import type { HogflowTestResult } from '../Workflows/hogflows/steps/types'
+import { buildFirstRunTestSend } from './buildFirstRunTestSend'
+import { buildFirstRunWorkflow } from './buildFirstRunWorkflow'
+import { GalleryTemplate, firstRunGalleryLogic } from './firstRunGalleryLogic'
+import { FirstRunSender, firstRunSenderLogic } from './firstRunSenderLogic'
+import { rememberFirstRunWorkflow } from './firstRunWorkflowStorage'
+import { TemplateEmail, listTemplateEmails } from './templateEmails'
+
+export interface FirstRunMakeItYoursLogicProps {
+ templateId: string
+}
+
+export interface OpenEmail extends TemplateEmail {
+ edited: boolean
+}
+
+export interface OpenEmailPosition {
+ index: number
+ total: number
+}
+
+// The templater exports a canvas edit 500ms after the last change and flags the wait in its cache. Switching,
+// sending or creating inside that window would act on the email without the edit, so every one of them waits.
+async function waitForPendingCanvasEdit(breakpoint: BreakPointFunction): Promise {
+ while (emailTemplaterLogic.findMounted()?.cache.pendingDesignEdit) {
+ await breakpoint(100)
+ }
+}
+
+export type TestSendOutcome =
+ | { kind: 'sent'; recipient: string }
+ | { kind: 'skipped'; reason: string }
+ | { kind: 'failed' }
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface firstRunMakeItYoursLogicValues {
+ galleryLoadFailed: boolean // firstRunGalleryLogic
+ galleryTemplates: GalleryTemplate[] | null // firstRunGalleryLogic
+ firstRunEnabled: boolean // firstRunSenderLogic
+ firstRunSender: FirstRunSender | null // firstRunSenderLogic
+ firstRunSenderLoading: boolean // firstRunSenderLogic
+ currentProjectId: number | null // projectLogic
+ currentTeamId: number | null // teamLogic
+ user: UserType | null // userLogic
+ createDisabledReason: string | null
+ createError: string | null
+ createdWorkflow: HogFlowApi | null
+ createdWorkflowLoading: boolean
+ editedEmailIds: string[]
+ edits: Record
+ enableDisabledReason: string | null
+ enableWorkflow: boolean
+ enableWorkflowChoice: boolean
+ openEmail: OpenEmail | null
+ openEmailId: string | null
+ openEmailIdOverride: string | null
+ openEmailPosition: OpenEmailPosition | null
+ pickedTemplate: GalleryTemplate | null
+ sendTestDisabledReason: string | null
+ senderDisabledReason: string | null
+ templateEmails: TemplateEmail[]
+ testSendFailed: boolean
+ testSendOutcome: TestSendOutcome | null
+ testSendResult: HogflowTestResult | null
+ testSendResultLoading: boolean
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface firstRunMakeItYoursLogicActions {
+ createWorkflow: (_: void) => void
+ createWorkflowFailure: (
+ error: string,
+ errorObject?: any
+ ) => {
+ error: string
+ errorObject?: any
+ }
+ createWorkflowSuccess: (
+ createdWorkflow: HogFlowApi | null,
+ payload?: void
+ ) => {
+ createdWorkflow: HogFlowApi | null
+ payload?: void
+ }
+ editEmail: (
+ emailId: string,
+ email: EmailTemplate
+ ) => {
+ email: EmailTemplate
+ emailId: string
+ }
+ markTestSendFailed: () => {
+ value: true
+ }
+ openEmail: (emailId: string) => {
+ emailId: string
+ }
+ sendTest: (_: void) => void
+ sendTestFailure: (
+ error: string,
+ errorObject?: any
+ ) => {
+ error: string
+ errorObject?: any
+ }
+ sendTestSuccess: (
+ testSendResult: HogflowTestResult | null,
+ payload?: void
+ ) => {
+ testSendResult: HogflowTestResult | null
+ payload?: void
+ }
+ setCreateError: (error: string) => {
+ error: string
+ }
+ setEnableWorkflow: (enabled: boolean) => {
+ enabled: boolean
+ }
+ setOpenEmailId: (emailId: string) => {
+ emailId: string
+ }
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface firstRunMakeItYoursLogicMeta {
+ key: string
+ __keaTypeGenInternalSelectorTypes: {
+ pickedTemplate: (galleryTemplates: GalleryTemplate[] | null, templateId: string) => GalleryTemplate | null
+ templateEmails: (pickedTemplate: GalleryTemplate | null) => TemplateEmail[]
+ openEmailId: (openEmailIdOverride: string | null, templateEmails: TemplateEmail[]) => string | null
+ openEmail: (
+ templateEmails: TemplateEmail[],
+ openEmailId: string | null,
+ edits: Record
+ ) => OpenEmail | null
+ openEmailPosition: (templateEmails: TemplateEmail[], openEmailId: string | null) => OpenEmailPosition | null
+ editedEmailIds: (edits: Record) => string[]
+ createDisabledReason: (firstRunEnabled: any) => string | null
+ senderDisabledReason: (firstRunSenderLoading: boolean, firstRunSender: FirstRunSender | null) => string | null
+ sendTestDisabledReason: (
+ createDisabledReason: string | null,
+ senderDisabledReason: string | null
+ ) => string | null
+ enableDisabledReason: (
+ createDisabledReason: string | null,
+ senderDisabledReason: string | null
+ ) => string | null
+ enableWorkflow: (enableWorkflowChoice: boolean, enableDisabledReason: string | null) => boolean
+ testSendOutcome: (
+ testSendResult: HogflowTestResult | null,
+ testSendFailed: boolean,
+ user: UserType | null
+ ) => TestSendOutcome | null
+ }
+}
+
+export type firstRunMakeItYoursLogicType = MakeLogicType<
+ firstRunMakeItYoursLogicValues,
+ firstRunMakeItYoursLogicActions,
+ FirstRunMakeItYoursLogicProps,
+ firstRunMakeItYoursLogicMeta
+>
+
+export const firstRunMakeItYoursLogic: LogicWrapper = kea([
+ props({} as FirstRunMakeItYoursLogicProps),
+ key((props) => props.templateId),
+ path((key) => ['products', 'workflows', 'frontend', 'firstRun', 'firstRunMakeItYoursLogic', key]),
+ connect(() => ({
+ values: [
+ firstRunGalleryLogic,
+ ['galleryTemplates', 'galleryLoadFailed'],
+ firstRunSenderLogic,
+ ['firstRunSender', 'firstRunSenderLoading', 'firstRunEnabled'],
+ projectLogic,
+ ['currentProjectId'],
+ teamLogic,
+ ['currentTeamId'],
+ userLogic,
+ ['user'],
+ ],
+ })),
+ actions({
+ openEmail: (emailId: string) => ({ emailId }),
+ setOpenEmailId: (emailId: string) => ({ emailId }),
+ editEmail: (emailId: string, email: EmailTemplate) => ({ emailId, email }),
+ setEnableWorkflow: (enabled: boolean) => ({ enabled }),
+ setCreateError: (error: string) => ({ error }),
+ markTestSendFailed: true,
+ }),
+ // The loaders catch their own errors so the screen shows them in place, instead of the generic failure toast.
+ loaders(({ values, props, actions }) => ({
+ testSendResult: [
+ null as HogflowTestResult | null,
+ {
+ sendTest: async (_: void, breakpoint): Promise => {
+ await waitForPendingCanvasEdit(breakpoint)
+ const { openEmail, firstRunSender, user, pickedTemplate } = values
+ if (!openEmail || !firstRunSender || !user?.email) {
+ return null
+ }
+ try {
+ return await api.hogFlows.createTestInvocation(
+ 'new',
+ buildFirstRunTestSend({
+ email: openEmail.email,
+ sender: firstRunSender,
+ recipientEmail: user.email,
+ workflowName: pickedTemplate?.template.name || 'Test email',
+ teamId: values.currentTeamId,
+ })
+ )
+ } catch {
+ actions.markTestSendFailed()
+ return null
+ }
+ },
+ },
+ ],
+ createdWorkflow: [
+ null as HogFlowApi | null,
+ {
+ createWorkflow: async (_: void, breakpoint): Promise => {
+ await waitForPendingCanvasEdit(breakpoint)
+ if (!values.firstRunEnabled || !values.pickedTemplate) {
+ return null
+ }
+ const workflow = buildFirstRunWorkflow({
+ template: values.pickedTemplate.template,
+ matchedEvent: values.pickedTemplate.matchedEvent,
+ edits: values.edits,
+ sender: values.firstRunSender,
+ enabled: values.enableWorkflow,
+ })
+ try {
+ const created = await hogFlowsCreate(
+ String(values.currentProjectId),
+ workflow as Parameters[1]
+ )
+ posthog.capture('workflows first run workflow created', {
+ template_id: props.templateId,
+ enabled: values.enableWorkflow,
+ })
+ return created
+ } catch (error: any) {
+ actions.setCreateError(error?.detail || error?.message || 'Something went wrong')
+ return null
+ }
+ },
+ },
+ ],
+ })),
+ reducers({
+ openEmailIdOverride: [null as string | null, { setOpenEmailId: (_, { emailId }) => emailId }],
+ edits: [
+ {} as Record,
+ { editEmail: (state, { emailId, email }) => ({ ...state, [emailId]: email }) },
+ ],
+ enableWorkflowChoice: [true, { setEnableWorkflow: (_, { enabled }) => enabled }],
+ testSendFailed: [false, { sendTest: () => false, markTestSendFailed: () => true }],
+ createError: [
+ null as string | null,
+ {
+ createWorkflow: () => null,
+ setCreateError: (_, { error }) => error,
+ },
+ ],
+ }),
+ selectors({
+ pickedTemplate: [
+ (s, p) => [s.galleryTemplates, p.templateId],
+ (galleryTemplates: GalleryTemplate[] | null, templateId: string): GalleryTemplate | null =>
+ galleryTemplates?.find(({ template }) => template.id === templateId) ?? null,
+ ],
+ templateEmails: [
+ (s) => [s.pickedTemplate],
+ (pickedTemplate: GalleryTemplate | null): TemplateEmail[] =>
+ pickedTemplate
+ ? listTemplateEmails(pickedTemplate.template.actions, pickedTemplate.template.edges)
+ : [],
+ ],
+ openEmailId: [
+ (s) => [s.openEmailIdOverride, s.templateEmails],
+ (override: string | null, templateEmails: TemplateEmail[]): string | null =>
+ templateEmails.find(({ id }) => id === override)?.id ?? templateEmails[0]?.id ?? null,
+ ],
+ openEmail: [
+ (s) => [s.templateEmails, s.openEmailId, s.edits],
+ (
+ templateEmails: TemplateEmail[],
+ openEmailId: string | null,
+ edits: Record
+ ): OpenEmail | null => {
+ const templateEmail = templateEmails.find(({ id }) => id === openEmailId)
+ if (!templateEmail) {
+ return null
+ }
+ const edit = edits[templateEmail.id]
+ return { ...templateEmail, email: edit ?? templateEmail.email, edited: !!edit }
+ },
+ ],
+ openEmailPosition: [
+ (s) => [s.templateEmails, s.openEmailId],
+ (templateEmails: TemplateEmail[], openEmailId: string | null): OpenEmailPosition | null => {
+ const index = templateEmails.findIndex(({ id }) => id === openEmailId)
+ return index === -1 ? null : { index: index + 1, total: templateEmails.length }
+ },
+ ],
+ editedEmailIds: [(s) => [s.edits], (edits: Record): string[] => Object.keys(edits)],
+ createDisabledReason: [
+ (s) => [s.firstRunEnabled],
+ (firstRunEnabled: boolean): string | null =>
+ firstRunEnabled
+ ? getAccessControlDisabledReason(AccessControlResourceType.Workflow, AccessControlLevel.Editor)
+ : 'First-run setup is not available',
+ ],
+ senderDisabledReason: [
+ (s) => [s.firstRunSenderLoading, s.firstRunSender],
+ (firstRunSenderLoading: boolean, firstRunSender: FirstRunSender | null): string | null => {
+ if (firstRunSender) {
+ return null
+ }
+ return firstRunSenderLoading ? 'Checking your email senders' : 'Connect an email sender first'
+ },
+ ],
+ sendTestDisabledReason: [
+ (s) => [s.createDisabledReason, s.senderDisabledReason],
+ (createDisabledReason: string | null, senderDisabledReason: string | null): string | null =>
+ createDisabledReason ?? senderDisabledReason,
+ ],
+ enableDisabledReason: [
+ (s) => [s.createDisabledReason, s.senderDisabledReason],
+ (createDisabledReason: string | null, senderDisabledReason: string | null): string | null =>
+ createDisabledReason ?? senderDisabledReason,
+ ],
+ enableWorkflow: [
+ (s) => [s.enableWorkflowChoice, s.enableDisabledReason],
+ (enableWorkflowChoice: boolean, enableDisabledReason: string | null): boolean =>
+ enableWorkflowChoice && !enableDisabledReason,
+ ],
+ testSendOutcome: [
+ (s) => [s.testSendResult, s.testSendFailed, s.user],
+ (
+ testSendResult: HogflowTestResult | null,
+ testSendFailed: boolean,
+ user: UserType | null
+ ): TestSendOutcome | null => {
+ if (testSendFailed) {
+ return { kind: 'failed' }
+ }
+ if (!testSendResult) {
+ return null
+ }
+ const skipReason = findTestSendSkipReason(testSendResult)
+ if (skipReason) {
+ return { kind: 'skipped', reason: skipReason }
+ }
+ if (testSendResult.status === 'success') {
+ return { kind: 'sent', recipient: user?.email ?? '' }
+ }
+ if (testSendResult.status === 'skipped') {
+ return {
+ kind: 'skipped',
+ reason:
+ testSendResult.logs?.map((log) => log.message).join(' ') ||
+ 'The email step was skipped, so nothing was sent.',
+ }
+ }
+ return { kind: 'failed' }
+ },
+ ],
+ }),
+ listeners(({ actions, values }) => ({
+ openEmail: async ({ emailId }, breakpoint) => {
+ await waitForPendingCanvasEdit(breakpoint)
+ actions.setOpenEmailId(emailId)
+ },
+ createWorkflowSuccess: ({ createdWorkflow }) => {
+ if (!createdWorkflow) {
+ return
+ }
+ rememberFirstRunWorkflow(createdWorkflow.id)
+ if (createdWorkflow.status === 'active') {
+ globalSetupLogic.findMounted()?.actions.markTaskAsCompleted(SetupTaskId.LaunchWorkflow)
+ }
+ router.actions.push(urls.workflow(createdWorkflow.id, 'workflow'))
+ },
+ sendTestSuccess: () => {
+ const outcome = values.testSendOutcome
+ if (outcome?.kind === 'sent' || outcome?.kind === 'skipped') {
+ posthog.capture('workflows first run test sent', { skipped: outcome.kind === 'skipped' })
+ }
+ completeTestEmailSetupTask(values.testSendResult)
+ },
+ })),
+])
diff --git a/products/workflows/frontend/firstRun/firstRunSenderLogic.test.ts b/products/workflows/frontend/firstRun/firstRunSenderLogic.test.ts
new file mode 100644
index 000000000000..4aa7e6c97a16
--- /dev/null
+++ b/products/workflows/frontend/firstRun/firstRunSenderLogic.test.ts
@@ -0,0 +1,71 @@
+import { expectLogic } from 'kea-test-utils'
+
+import { FEATURE_FLAGS } from 'lib/constants'
+import { integrationsLogic } from 'lib/integrations/integrationsLogic'
+import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
+
+import { useMocks } from '~/mocks/jest'
+import { initKeaTests } from '~/test/init'
+
+import type { IntegrationConfigApi } from 'products/integrations/frontend/generated/api.schemas'
+
+import { firstRunSenderLogic } from './firstRunSenderLogic'
+
+const OWN_SENDER = {
+ id: 5,
+ kind: 'email',
+ display_name: 'Sender ',
+ config: { verified: true, email: 'sender@example.com' },
+} satisfies Partial
+
+describe('firstRunSenderLogic', () => {
+ let logic: ReturnType
+ let integrations: Partial[]
+
+ beforeEach(() => {
+ integrations = []
+ useMocks({
+ get: {
+ '/api/projects/:team_id/integrations/': () => [200, { results: integrations }],
+ },
+ })
+ initKeaTests()
+ featureFlagLogic.actions.setFeatureFlags([], { [FEATURE_FLAGS.WORKFLOWS_FIRST_RUN]: true })
+ })
+
+ afterEach(() => {
+ logic?.unmount()
+ })
+
+ it('uses the first verified own email sender from the existing integrations list', async () => {
+ integrations = [
+ { id: 3, kind: 'slack', config: { verified: true } },
+ { ...OWN_SENDER, id: 4, config: { verified: false } },
+ { ...OWN_SENDER, id: 7, config: { provider: 'sandbox', verified: true } },
+ OWN_SENDER,
+ { ...OWN_SENDER, id: 6 },
+ ]
+ logic = firstRunSenderLogic()
+ logic.mount()
+
+ await expectLogic(integrationsLogic).toFinishAllListeners()
+ expect(logic.values.firstRunSender).toEqual(expect.objectContaining(OWN_SENDER))
+
+ featureFlagLogic.actions.setFeatureFlags([], {})
+ expect(logic.values.firstRunSender).toBeNull()
+ expect(logic.values.firstRunSenderLoading).toBe(false)
+ })
+
+ it.each([
+ { initialIntegrations: [] },
+ { initialIntegrations: [{ ...OWN_SENDER, config: { verified: false } }] },
+ { initialIntegrations: [{ ...OWN_SENDER, config: { provider: 'sandbox', verified: true } }] },
+ ])('requires a verified own email sender', async ({ initialIntegrations }) => {
+ integrations = initialIntegrations
+ logic = firstRunSenderLogic()
+ logic.mount()
+
+ await expectLogic(integrationsLogic).toFinishAllListeners()
+ expect(logic.values.firstRunSender).toBeNull()
+ })
+})
diff --git a/products/workflows/frontend/firstRun/firstRunSenderLogic.ts b/products/workflows/frontend/firstRun/firstRunSenderLogic.ts
new file mode 100644
index 000000000000..616c5238d311
--- /dev/null
+++ b/products/workflows/frontend/firstRun/firstRunSenderLogic.ts
@@ -0,0 +1,66 @@
+import { MakeLogicType, connect, kea, path, selectors } from 'kea'
+
+import { FEATURE_FLAGS } from 'lib/constants'
+import { integrationsLogic } from 'lib/integrations/integrationsLogic'
+import { FeatureFlagsSet, featureFlagLogic } from 'lib/logic/featureFlagLogic'
+import { isObject } from 'lib/utils/guards'
+
+import type { IntegrationConfigApi } from 'products/integrations/frontend/generated/api.schemas'
+
+import type { IntegrationType } from '../../../../frontend/src/types'
+
+export type FirstRunSender = Pick
+
+export interface firstRunSenderLogicValues {
+ featureFlags: FeatureFlagsSet
+ integrations: IntegrationType[] | null
+ integrationsLoading: boolean
+ firstRunEnabled: boolean
+ firstRunSender: FirstRunSender | null
+ firstRunSenderLoading: boolean
+}
+
+export interface firstRunSenderLogicMeta {
+ __keaTypeGenInternalSelectorTypes: {
+ firstRunEnabled: (featureFlags: FeatureFlagsSet) => boolean
+ firstRunSender: (integrations: IntegrationType[] | null, firstRunEnabled: boolean) => FirstRunSender | null
+ firstRunSenderLoading: (integrationsLoading: boolean, firstRunEnabled: boolean) => boolean
+ }
+}
+
+export type firstRunSenderLogicType = MakeLogicType<
+ firstRunSenderLogicValues,
+ Record,
+ Record,
+ firstRunSenderLogicMeta
+>
+
+export const firstRunSenderLogic = kea([
+ path(['products', 'workflows', 'frontend', 'firstRun', 'firstRunSenderLogic']),
+ connect({
+ values: [featureFlagLogic, ['featureFlags'], integrationsLogic, ['integrations', 'integrationsLoading']],
+ }),
+ selectors({
+ firstRunEnabled: [
+ (s) => [s.featureFlags],
+ (featureFlags: FeatureFlagsSet): boolean => !!featureFlags[FEATURE_FLAGS.WORKFLOWS_FIRST_RUN],
+ ],
+ firstRunSender: [
+ (s) => [s.integrations, s.firstRunEnabled],
+ (integrations: IntegrationType[] | null, firstRunEnabled: boolean): FirstRunSender | null =>
+ firstRunEnabled
+ ? (integrations?.find(
+ (sender) =>
+ sender.kind === 'email' &&
+ isObject(sender.config) &&
+ sender.config.provider !== 'sandbox' &&
+ sender.config.verified === true
+ ) ?? null)
+ : null,
+ ],
+ firstRunSenderLoading: [
+ (s) => [s.integrationsLoading, s.firstRunEnabled],
+ (loading: boolean, firstRunEnabled: boolean): boolean => firstRunEnabled && loading,
+ ],
+ }),
+])
diff --git a/products/workflows/frontend/firstRun/firstRunStoryFixtures.ts b/products/workflows/frontend/firstRun/firstRunStoryFixtures.ts
new file mode 100644
index 000000000000..abc9bcb42675
--- /dev/null
+++ b/products/workflows/frontend/firstRun/firstRunStoryFixtures.ts
@@ -0,0 +1,64 @@
+import { mswDecorator } from '~/mocks/browser'
+import { toPaginatedResponse } from '~/mocks/handlers'
+
+import type { IntegrationConfigApi } from 'products/integrations/frontend/generated/api.schemas'
+
+import announceANewFeature from '../../backend/templates/announce_a_new_feature_template.json'
+import celebrateMilestone from '../../backend/templates/celebrate-milestone.json'
+import featureAdoptionTips from '../../backend/templates/feature-adoption-tips.json'
+import heavyUsageDetected from '../../backend/templates/heavy-usage-detected.json'
+import highIntentNotification from '../../backend/templates/high-intent-notification.json'
+import onboardingStarted from '../../backend/templates/onboarding_started_but_not_completed_template.json'
+import reEngagement from '../../backend/templates/re-engagement-workflow.json'
+import trialEndingReminder from '../../backend/templates/trial-ending-reminder.json'
+import trialStartedUpgradeNudge from '../../backend/templates/trial_started_upgrade_nudge_template.json'
+import unlockingAdvancedFeatures from '../../backend/templates/unlocking_advanced_features.json'
+import unusedFeaturesEducation from '../../backend/templates/unused-features-education.json'
+import welcomeEmailSequence from '../../backend/templates/welcome_email_sequence_template.json'
+import type { HogFlowTemplateApi } from '../generated/api.schemas'
+
+// The global templates in the order the API lists them, plus one without an email step that the gallery leaves out.
+// The serializer defaults `tags` to an empty list, which some template files leave out.
+export const globalTemplates = (
+ [
+ announceANewFeature,
+ onboardingStarted,
+ trialStartedUpgradeNudge,
+ welcomeEmailSequence,
+ celebrateMilestone,
+ featureAdoptionTips,
+ heavyUsageDetected,
+ highIntentNotification,
+ reEngagement,
+ trialEndingReminder,
+ unlockingAdvancedFeatures,
+ unusedFeaturesEducation,
+ ] as unknown as HogFlowTemplateApi[]
+).map((template) => ({ ...template, tags: template.tags ?? [] }))
+
+export const WELCOME_SEQUENCE_ID = welcomeEmailSequence.id
+export const TRIAL_UPGRADE_NUDGE_ID = trialStartedUpgradeNudge.id
+export const RE_ENGAGEMENT_ID = reEngagement.id
+
+export const OWN_SENDER: Partial = {
+ id: 7,
+ kind: 'email',
+ display_name: 'Example ',
+ config: { verified: true, email: 'sender@example.com', name: 'Example' },
+ created_at: '2026-10-01T00:00:00Z',
+}
+
+export function projectThatSends(seenEvents: string[]): Parameters[0] {
+ return {
+ get: {
+ '/api/projects/:team_id/event_definitions/': ({ request }) => {
+ const names = new URL(request.url).searchParams.get('names')?.split(',') ?? []
+ const seen = names.filter((name) => seenEvents.includes(name))
+ return [
+ 200,
+ toPaginatedResponse(seen.map((name) => ({ id: name, name, last_seen_at: '2026-10-01T00:00:00Z' }))),
+ ]
+ },
+ },
+ }
+}
diff --git a/products/workflows/frontend/firstRun/firstRunWelcomeHoldLogic.ts b/products/workflows/frontend/firstRun/firstRunWelcomeHoldLogic.ts
new file mode 100644
index 000000000000..76f1f7979a00
--- /dev/null
+++ b/products/workflows/frontend/firstRun/firstRunWelcomeHoldLogic.ts
@@ -0,0 +1,73 @@
+import { MakeLogicType, afterMount, beforeUnmount, connect, kea, listeners, path, props, propsChanged } from 'kea'
+
+import { navPanelProductPushWelcomeLogic } from 'lib/components/NavPanelAdvertisement/navPanelProductPushWelcomeLogic'
+import type { ProductSetupStatus } from 'lib/components/ProductEmptyState/types'
+import { FEATURE_FLAGS } from 'lib/constants'
+import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
+
+import type { FeatureFlagsSet } from '../../../../frontend/src/lib/logic/featureFlagLogic'
+
+const WELCOME_HOLDER = 'workflows-first-run'
+
+export interface FirstRunWelcomeHoldLogicProps {
+ setupStatus: ProductSetupStatus
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface firstRunWelcomeHoldLogicValues {
+ featureFlags: FeatureFlagsSet // featureFlagLogic
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface firstRunWelcomeHoldLogicActions {
+ setFeatureFlags: (
+ flags: string[],
+ variants: Record
+ ) => {
+ flags: string[]
+ variants: Record
+ } // featureFlagLogic
+ holdWelcome: (holder: string) => {
+ holder: string
+ } // navPanelProductPushWelcomeLogic
+ releaseWelcome: (holder: string) => {
+ holder: string
+ } // navPanelProductPushWelcomeLogic
+}
+
+export type firstRunWelcomeHoldLogicType = MakeLogicType<
+ firstRunWelcomeHoldLogicValues,
+ firstRunWelcomeHoldLogicActions,
+ FirstRunWelcomeHoldLogicProps
+>
+
+function updateWelcomeHold({ actions, props, values }: firstRunWelcomeHoldLogicType): void {
+ if (
+ values.featureFlags[FEATURE_FLAGS.WORKFLOWS_FIRST_RUN] &&
+ (props.setupStatus === 'loading' || props.setupStatus === 'needs-setup')
+ ) {
+ actions.holdWelcome(WELCOME_HOLDER)
+ } else {
+ actions.releaseWelcome(WELCOME_HOLDER)
+ }
+}
+
+export const firstRunWelcomeHoldLogic = kea([
+ props({} as FirstRunWelcomeHoldLogicProps),
+ path(['products', 'workflows', 'frontend', 'firstRun', 'firstRunWelcomeHoldLogic']),
+ connect(() => ({
+ values: [featureFlagLogic, ['featureFlags']],
+ actions: [
+ navPanelProductPushWelcomeLogic,
+ ['holdWelcome', 'releaseWelcome'],
+ featureFlagLogic,
+ ['setFeatureFlags'],
+ ],
+ })),
+ listeners((logic) => ({ setFeatureFlags: () => updateWelcomeHold(logic) })),
+ afterMount(updateWelcomeHold),
+ propsChanged(updateWelcomeHold),
+ beforeUnmount(({ actions }) => {
+ actions.releaseWelcome(WELCOME_HOLDER)
+ }),
+])
diff --git a/products/workflows/frontend/firstRun/firstRunWorkflowBannerLogic.test.ts b/products/workflows/frontend/firstRun/firstRunWorkflowBannerLogic.test.ts
new file mode 100644
index 000000000000..3a501d54ddde
--- /dev/null
+++ b/products/workflows/frontend/firstRun/firstRunWorkflowBannerLogic.test.ts
@@ -0,0 +1,141 @@
+import { router } from 'kea-router'
+import { expectLogic } from 'kea-test-utils'
+
+import { globalSetupLogic } from 'lib/components/ProductSetup'
+import { FEATURE_FLAGS } from 'lib/constants'
+import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
+import { removeProjectIdIfPresent } from 'lib/utils/kea-router'
+import { urls } from 'scenes/urls'
+
+import { useMocks } from '~/mocks/jest'
+import { initKeaTests } from '~/test/init'
+
+import type { HogFlow } from '../Workflows/hogflows/types'
+import { workflowLogic } from '../Workflows/workflowLogic'
+import { firstRunWorkflowBannerLogic } from './firstRunWorkflowBannerLogic'
+import { rememberFirstRunWorkflow } from './firstRunWorkflowStorage'
+
+const FIRST_RUN_WORKFLOW_ID = 'wf-first-run'
+const OTHER_WORKFLOW_ID = 'wf-other'
+
+function workflow(id: string, status: HogFlow['status']): HogFlow {
+ return {
+ id,
+ name: 'Welcome email sequence',
+ description: 'Welcome new signups with an intro email.',
+ status,
+ version: 1,
+ trigger: { type: 'event', filters: { events: [{ id: '$pageview', type: 'events' }] } },
+ actions: [],
+ edges: [],
+ exit_condition: 'exit_only_at_end',
+ conversion: { filters: [] },
+ updated_at: '2026-10-05T00:00:00Z',
+ } as unknown as HogFlow
+}
+
+describe('firstRunWorkflowBannerLogic', () => {
+ let statuses: Record
+
+ function mountFor(id: string): ReturnType {
+ workflowLogic({ id }).mount()
+ const logic = firstRunWorkflowBannerLogic({ id })
+ logic.mount()
+ return logic
+ }
+
+ beforeEach(() => {
+ window.localStorage.clear()
+ statuses = { [FIRST_RUN_WORKFLOW_ID]: 'draft', [OTHER_WORKFLOW_ID]: 'draft' }
+ useMocks({
+ get: {
+ '/api/environments/:team_id/hog_flows/:id/': ({ params }) => [
+ 200,
+ workflow(params.id as string, statuses[params.id as string]),
+ ],
+ },
+ patch: {
+ '/api/environments/:team_id/hog_flows/:id/': async ({ params, request }) => {
+ const { status } = (await request.json()) as Partial
+ statuses[params.id as string] = status ?? statuses[params.id as string]
+ return [200, workflow(params.id as string, statuses[params.id as string])]
+ },
+ },
+ })
+ initKeaTests()
+ featureFlagLogic.mount()
+ featureFlagLogic.actions.setFeatureFlags([FEATURE_FLAGS.WORKFLOWS_FIRST_RUN], {
+ [FEATURE_FLAGS.WORKFLOWS_FIRST_RUN]: true,
+ })
+ globalSetupLogic.mount()
+ rememberFirstRunWorkflow(FIRST_RUN_WORKFLOW_ID)
+ })
+
+ it('shows the draft banner on the first-run draft and highlights Enable', async () => {
+ router.actions.push(urls.workflow(FIRST_RUN_WORKFLOW_ID, 'workflow'))
+ const logic = mountFor(FIRST_RUN_WORKFLOW_ID)
+
+ await expectLogic(logic).toFinishAllListeners().toMatchValues({ banner: 'draft' })
+ expect(globalSetupLogic.values.highlight).toEqual({
+ selector: '[data-attr="workflow-launch"]',
+ pathname: router.values.location.pathname,
+ })
+ })
+
+ it('turns into the sending banner once the header enables the workflow', async () => {
+ const logic = mountFor(FIRST_RUN_WORKFLOW_ID)
+ await expectLogic(logic).toFinishAllListeners().toMatchValues({ banner: 'draft' })
+
+ workflowLogic({ id: FIRST_RUN_WORKFLOW_ID }).actions.saveWorkflowPartial({ status: 'active' })
+
+ await expectLogic(logic).toFinishAllListeners().toMatchValues({ banner: 'sending' })
+ })
+
+ it('does not highlight Enable on a sending workflow', async () => {
+ statuses[FIRST_RUN_WORKFLOW_ID] = 'active'
+ const logic = mountFor(FIRST_RUN_WORKFLOW_ID)
+
+ await expectLogic(logic).toFinishAllListeners().toMatchValues({ banner: 'sending' })
+ expect(globalSetupLogic.values.highlight).toBeNull()
+ })
+
+ it.each([
+ ['another workflow', OTHER_WORKFLOW_ID, true],
+ ['the first-run workflow with the flag off', FIRST_RUN_WORKFLOW_ID, false],
+ ])('shows nothing on %s', async (_, id, flagOn) => {
+ if (!flagOn) {
+ featureFlagLogic.actions.setFeatureFlags([], {})
+ }
+ const logic = mountFor(id)
+
+ await expectLogic(logic).toFinishAllListeners().toMatchValues({ banner: null })
+ expect(globalSetupLogic.values.highlight).toBeNull()
+ })
+
+ it('keeps a dismissed banner dismissed after enabling and when the workflow opens again', async () => {
+ const logic = mountFor(FIRST_RUN_WORKFLOW_ID)
+ await expectLogic(logic).toFinishAllListeners().toMatchValues({ banner: 'draft' })
+
+ logic.actions.dismiss()
+ workflowLogic({ id: FIRST_RUN_WORKFLOW_ID }).actions.saveWorkflowPartial({ status: 'active' })
+ await expectLogic(logic).toFinishAllListeners().toMatchValues({ banner: null })
+
+ logic.unmount()
+ const reopened = firstRunWorkflowBannerLogic({ id: FIRST_RUN_WORKFLOW_ID })
+ reopened.mount()
+
+ await expectLogic(reopened).toFinishAllListeners().toMatchValues({ banner: null })
+ })
+
+ it('opens the Metrics tab from the sending banner', async () => {
+ statuses[FIRST_RUN_WORKFLOW_ID] = 'active'
+ const logic = mountFor(FIRST_RUN_WORKFLOW_ID)
+ await expectLogic(logic).toFinishAllListeners()
+
+ logic.actions.viewMetrics()
+
+ expect(removeProjectIdIfPresent(router.values.location.pathname)).toEqual(
+ urls.workflow(FIRST_RUN_WORKFLOW_ID, 'metrics')
+ )
+ })
+})
diff --git a/products/workflows/frontend/firstRun/firstRunWorkflowBannerLogic.ts b/products/workflows/frontend/firstRun/firstRunWorkflowBannerLogic.ts
new file mode 100644
index 000000000000..56da231dfa20
--- /dev/null
+++ b/products/workflows/frontend/firstRun/firstRunWorkflowBannerLogic.ts
@@ -0,0 +1,118 @@
+import { MakeLogicType, actions, connect, kea, key, listeners, path, props, reducers, selectors } from 'kea'
+import { router } from 'kea-router'
+import { subscriptions } from 'kea-subscriptions'
+
+import { globalSetupLogic } from 'lib/components/ProductSetup'
+import { FEATURE_FLAGS } from 'lib/constants'
+import { featureFlagLogic, FeatureFlagsSet } from 'lib/logic/featureFlagLogic'
+import { urls } from 'scenes/urls'
+
+import type { HogFlow } from '../Workflows/hogflows/types'
+import { WorkflowLogicProps, workflowLogic } from '../Workflows/workflowLogic'
+import { getFirstRunWorkflowId } from './firstRunWorkflowStorage'
+
+export type FirstRunBannerState = 'draft' | 'sending'
+
+const ENABLE_BUTTON_SELECTOR = '[data-attr="workflow-launch"]'
+
+function bannerForStatus(status: HogFlow['status']): FirstRunBannerState | null {
+ if (status === 'draft') {
+ return 'draft'
+ }
+ return status === 'active' ? 'sending' : null
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface firstRunWorkflowBannerLogicValues {
+ featureFlags: FeatureFlagsSet // featureFlagLogic
+ originalWorkflow: HogFlow | null // workflowLogic
+ banner: FirstRunBannerState | null
+ dismissed: boolean
+ firstRunWorkflowId: string | null
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface firstRunWorkflowBannerLogicActions {
+ setHighlight: (
+ selector: string,
+ pathname: string
+ ) => {
+ pathname: string
+ selector: string
+ } // globalSetupLogic
+ dismiss: () => {
+ value: true
+ }
+ viewMetrics: () => {
+ value: true
+ }
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface firstRunWorkflowBannerLogicMeta {
+ key: string
+ __keaTypeGenInternalSelectorTypes: {
+ banner: (
+ originalWorkflow: HogFlow | null,
+ firstRunWorkflowId: string | null,
+ featureFlags: FeatureFlagsSet,
+ dismissed: boolean
+ ) => FirstRunBannerState | null
+ }
+}
+
+export type firstRunWorkflowBannerLogicType = MakeLogicType<
+ firstRunWorkflowBannerLogicValues,
+ firstRunWorkflowBannerLogicActions,
+ WorkflowLogicProps,
+ firstRunWorkflowBannerLogicMeta
+>
+
+export const firstRunWorkflowBannerLogic = kea([
+ props({} as WorkflowLogicProps),
+ key((props): string => props.id ?? 'new'),
+ path((key) => ['products', 'workflows', 'frontend', 'firstRun', 'firstRunWorkflowBannerLogic', key]),
+ connect((props: WorkflowLogicProps) => ({
+ values: [workflowLogic(props), ['originalWorkflow'], featureFlagLogic, ['featureFlags']],
+ actions: [globalSetupLogic, ['setHighlight']],
+ })),
+ actions({
+ dismiss: true,
+ viewMetrics: true,
+ }),
+ reducers(() => ({
+ firstRunWorkflowId: [getFirstRunWorkflowId(), {}],
+ dismissed: [false, { persist: true }, { dismiss: () => true }],
+ })),
+ selectors({
+ banner: [
+ (s) => [s.originalWorkflow, s.firstRunWorkflowId, s.featureFlags, s.dismissed],
+ (
+ originalWorkflow: HogFlow | null,
+ firstRunWorkflowId: string | null,
+ featureFlags: FeatureFlagsSet,
+ dismissed: boolean
+ ): FirstRunBannerState | null => {
+ if (!featureFlags[FEATURE_FLAGS.WORKFLOWS_FIRST_RUN] || !originalWorkflow || dismissed) {
+ return null
+ }
+ if (!firstRunWorkflowId || originalWorkflow.id !== firstRunWorkflowId) {
+ return null
+ }
+ return bannerForStatus(originalWorkflow.status)
+ },
+ ],
+ }),
+ listeners(({ props }) => ({
+ viewMetrics: () => {
+ router.actions.push(urls.workflow(props.id ?? 'new', 'metrics'))
+ },
+ })),
+ subscriptions(({ actions }) => ({
+ banner: (banner: FirstRunBannerState | null, previousBanner: FirstRunBannerState | null | undefined) => {
+ if (banner === 'draft' && previousBanner !== 'draft') {
+ actions.setHighlight(ENABLE_BUTTON_SELECTOR, router.values.location.pathname)
+ }
+ },
+ })),
+])
diff --git a/products/workflows/frontend/firstRun/firstRunWorkflowStorage.ts b/products/workflows/frontend/firstRun/firstRunWorkflowStorage.ts
new file mode 100644
index 000000000000..760a6344c857
--- /dev/null
+++ b/products/workflows/frontend/firstRun/firstRunWorkflowStorage.ts
@@ -0,0 +1,18 @@
+// pinned: storage key, a rename would forget which workflow the first run created
+const FIRST_RUN_WORKFLOW_KEY = 'workflows-first-run-workflow-id'
+
+export function rememberFirstRunWorkflow(workflowId: string): void {
+ try {
+ window.localStorage.setItem(FIRST_RUN_WORKFLOW_KEY, workflowId)
+ } catch {
+ // Storage can be full or blocked; the first run still works without the memory.
+ }
+}
+
+export function getFirstRunWorkflowId(): string | null {
+ try {
+ return window.localStorage.getItem(FIRST_RUN_WORKFLOW_KEY)
+ } catch {
+ return null
+ }
+}
diff --git a/products/workflows/frontend/firstRun/templateEmails.ts b/products/workflows/frontend/firstRun/templateEmails.ts
new file mode 100644
index 000000000000..60b49427ce50
--- /dev/null
+++ b/products/workflows/frontend/firstRun/templateEmails.ts
@@ -0,0 +1,70 @@
+import type { EmailTemplate } from 'scenes/hog-functions/email-templater/types'
+
+import { DurationUnit, parseDuration } from '../Workflows/hogflows/steps/durations'
+import { getDurationText } from '../Workflows/hogflows/steps/stepDelayLogic'
+import { isEmailAction } from '../Workflows/hogflows/steps/types'
+import type { HogFlowAction, HogFlowEdge } from '../Workflows/hogflows/types'
+import { getOrderedActions } from '../Workflows/templates/workflowTemplateDisplay'
+
+export interface TemplateEmail {
+ id: string
+ subject: string
+ timing: string
+ email: EmailTemplate
+}
+
+const SECONDS_PER_UNIT: Record = { d: 86400, h: 3600, m: 60, s: 1 }
+
+function durationSeconds(duration: unknown): number {
+ const parsed = typeof duration === 'string' ? parseDuration(duration) : null
+ return parsed ? parsed.amount * SECONDS_PER_UNIT[parsed.unit] : 0
+}
+
+function describeTiming(seconds: number): string {
+ if (seconds <= 0) {
+ return 'Right away'
+ }
+ const unit =
+ (['d', 'h', 'm'] as DurationUnit[]).find((candidate) => seconds % SECONDS_PER_UNIT[candidate] === 0) ?? 's'
+ return `After ${getDurationText(`${seconds / SECONDS_PER_UNIT[unit]}${unit}`)}`
+}
+
+// Seconds between the trigger and each step, summed over the delays on the first path that reaches it.
+function delaysFromTrigger(actions: HogFlowAction[], edges: HogFlowEdge[]): Map {
+ const actionsById = new Map(actions.map((action) => [action.id, action]))
+ const trigger = actions.find((action) => action.type === 'trigger')
+ const delays = new Map()
+ if (!trigger) {
+ return delays
+ }
+ delays.set(trigger.id, 0)
+ const queue = [trigger.id]
+ for (let cursor = 0; cursor < queue.length; cursor++) {
+ const from = queue[cursor]
+ for (const edge of edges.filter((edge) => edge.from === from)) {
+ if (delays.has(edge.to)) {
+ continue
+ }
+ const target = actionsById.get(edge.to)
+ const ownDelay = target?.type === 'delay' ? durationSeconds(target.config.delay_duration) : 0
+ delays.set(edge.to, (delays.get(from) ?? 0) + ownDelay)
+ queue.push(edge.to)
+ }
+ }
+ return delays
+}
+
+export function listTemplateEmails(actions: HogFlowAction[], edges: HogFlowEdge[]): TemplateEmail[] {
+ const delays = delaysFromTrigger(actions, edges)
+ return getOrderedActions(actions, edges)
+ .filter(isEmailAction)
+ .map((action) => {
+ const email = action.config.inputs.email?.value as EmailTemplate
+ return {
+ id: action.id,
+ subject: email?.subject ?? '',
+ timing: describeTiming(delays.get(action.id) ?? 0),
+ email,
+ }
+ })
+}
diff --git a/products/workflows/frontend/firstRun/withFirstRunSender.test.ts b/products/workflows/frontend/firstRun/withFirstRunSender.test.ts
new file mode 100644
index 000000000000..97596e703514
--- /dev/null
+++ b/products/workflows/frontend/firstRun/withFirstRunSender.test.ts
@@ -0,0 +1,42 @@
+import welcomeSequence from '../../backend/templates/welcome_email_sequence_template.json'
+import { HogFlowActionSchema } from '../Workflows/hogflows/steps/types'
+import { withFirstRunSender } from './withFirstRunSender'
+
+describe('withFirstRunSender', () => {
+ it.each([false, true])(
+ 'assigns every email sender without changing other data (empty inputs: %s)',
+ (emptyInputs) => {
+ const actions = HogFlowActionSchema.array().parse(welcomeSequence.actions)
+ if (emptyInputs) {
+ actions.forEach((action) => {
+ if (action.type === 'function_email') {
+ action.config.inputs = {}
+ }
+ })
+ }
+ const original = structuredClone(actions)
+
+ const transformed = withFirstRunSender(actions, { id: 42 })
+ const emails = transformed.filter((action) => action.type === 'function_email')
+ expect(emails).toHaveLength(2)
+ expect(emails.map((action) => action.config.inputs.email.value.from)).toEqual([
+ { integrationId: 42 },
+ { integrationId: 42 },
+ ])
+ transformed.forEach((action, index) => {
+ const originalAction = original[index]
+ if (action.type === 'function_email' && originalAction.type === 'function_email') {
+ const { from: originalFrom, ...originalEmail } = originalAction.config.inputs.email?.value ?? {}
+ const { from: transformedFrom, ...transformedEmail } = action.config.inputs.email.value
+ expect(transformedEmail).toEqual(originalEmail)
+ expect(action.config.inputs.email.templating).toEqual(
+ originalAction.config.inputs.email?.templating
+ )
+ } else {
+ expect(action).toBe(actions[index])
+ }
+ })
+ expect(actions).toEqual(original)
+ }
+ )
+})
diff --git a/products/workflows/frontend/firstRun/withFirstRunSender.ts b/products/workflows/frontend/firstRun/withFirstRunSender.ts
new file mode 100644
index 000000000000..fa0d0e2e8870
--- /dev/null
+++ b/products/workflows/frontend/firstRun/withFirstRunSender.ts
@@ -0,0 +1,25 @@
+import type { HogFlowAction } from '../Workflows/hogflows/types'
+import type { FirstRunSender } from './firstRunSenderLogic'
+
+export function withFirstRunSender(actions: HogFlowAction[], sender: Pick): HogFlowAction[] {
+ return actions.map((action) =>
+ action.type === 'function_email'
+ ? {
+ ...action,
+ config: {
+ ...action.config,
+ inputs: {
+ ...action.config.inputs,
+ email: {
+ ...action.config.inputs.email,
+ value: {
+ ...action.config.inputs.email?.value,
+ from: { integrationId: sender.id },
+ },
+ },
+ },
+ },
+ }
+ : action
+ )
+}
diff --git a/products/workflows/frontend/generated/api.schemas.ts b/products/workflows/frontend/generated/api.schemas.ts
index 938975ebfb25..c10ecb60c45c 100644
--- a/products/workflows/frontend/generated/api.schemas.ts
+++ b/products/workflows/frontend/generated/api.schemas.ts
@@ -7,6 +7,33 @@
* PostHog API - generated
* OpenAPI spec version: 1.0.0
*/
+/**
+ * * `event` - Event
+ * * `no_event` - No event
+ * * `schedule` - Schedule
+ */
+export type HogFlowTemplateStartsOnSerializerKindEnumApi =
+ (typeof HogFlowTemplateStartsOnSerializerKindEnumApi)[keyof typeof HogFlowTemplateStartsOnSerializerKindEnumApi]
+
+export const HogFlowTemplateStartsOnSerializerKindEnumApi = {
+ Event: 'event',
+ NoEvent: 'no_event',
+ Schedule: 'schedule',
+} as const
+
+export interface HogFlowTemplateStartsOnApi {
+ /** Whether the template starts on an event, an absence of events, or a schedule.
+ *
+ * * `event` - Event
+ * * `no_event` - No event
+ * * `schedule` - Schedule */
+ kind: HogFlowTemplateStartsOnSerializerKindEnumApi
+ /** Event names that can drive the template, in order of preference. Empty for schedules. */
+ events: string[]
+ /** Short qualifier shown with the template's trigger. */
+ detail: string
+}
+
/**
* * `team` - Only team
* * `organization` - Organization
@@ -159,6 +186,8 @@ export interface HogFlowTemplateApi {
image_url?: string | null
/** Tags for filtering templates. */
tags?: string[]
+ /** What starts a global email template. Null for other templates. */
+ readonly starts_on: HogFlowTemplateStartsOnApi | null
/** Who can use the template: this project only, or every project in the organization.
*
* * `team` - Only team
@@ -236,6 +265,8 @@ export interface PatchedHogFlowTemplateApi {
image_url?: string | null
/** Tags for filtering templates. */
tags?: string[]
+ /** What starts a global email template. Null for other templates. */
+ readonly starts_on?: HogFlowTemplateStartsOnApi | null
/** Who can use the template: this project only, or every project in the organization.
*
* * `team` - Only team
diff --git a/products/workflows/frontend/testEmailSetupTask.test.ts b/products/workflows/frontend/testEmailSetupTask.test.ts
new file mode 100644
index 000000000000..ccfd229b1e9a
--- /dev/null
+++ b/products/workflows/frontend/testEmailSetupTask.test.ts
@@ -0,0 +1,173 @@
+import { MOCK_DEFAULT_TEAM } from 'lib/api.mock'
+
+import { expectLogic } from 'kea-test-utils'
+
+import { SetupTaskId, globalSetupLogic } from 'lib/components/ProductSetup'
+import { FEATURE_FLAGS } from 'lib/constants'
+import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
+import { teamLogic } from 'scenes/teamLogic'
+
+import { useMocks } from '~/mocks/jest'
+import { initKeaTests } from '~/test/init'
+import { ActivationTaskStatus, TeamType } from '~/types'
+
+import { broadcastTestSendLogic } from './Broadcasts/broadcastTestSendLogic'
+import { messageTemplateLogic } from './TemplateLibrary/messageTemplateLogic'
+import { messageTemplateTestSendLogic } from './TemplateLibrary/messageTemplateTestSendLogic'
+import { hogFlowEditorNotificationTestLogic } from './Workflows/hogflows/panel/testing/hogFlowEditorNotificationTestLogic'
+import type { HogFlowAction } from './Workflows/hogflows/types'
+import { NEW_WORKFLOW, workflowLogic } from './Workflows/workflowLogic'
+
+const EMAIL_ACTION: HogFlowAction = {
+ id: 'email_node',
+ type: 'function_email',
+ name: 'Welcome email',
+ description: '',
+ created_at: 0,
+ updated_at: 0,
+ config: {
+ template_id: 'template-email',
+ inputs: {
+ email: {
+ value: {
+ from: { integrationId: 5 },
+ to: { email: 'tester@example.com', name: '' },
+ subject: 'Welcome',
+ text: 'Hello',
+ },
+ },
+ },
+ },
+}
+
+async function sendTestEmail(
+ surface: 'template' | 'broadcast' | 'email step',
+ { mocked = false, actionId = 'email_node' }: { mocked?: boolean; actionId?: string } = {}
+): Promise {
+ if (surface === 'email step') {
+ const workflow = workflowLogic({ id: 'new' })
+ workflow.mount()
+ await expectLogic(workflow).toFinishAllListeners()
+ workflow.actions.setWorkflowValues({ actions: [...NEW_WORKFLOW.actions, EMAIL_ACTION] })
+ const logic = hogFlowEditorNotificationTestLogic({ id: 'new' })
+ logic.mount()
+ await expectLogic(logic).toFinishAllListeners()
+ logic.actions.setSelectedNodeId(actionId)
+ logic.actions.setTestInvocationValues({
+ globals: JSON.stringify({ person: { properties: { email: 'tester@example.com' } } }),
+ mock_async_functions: mocked,
+ })
+ await expectLogic(logic, () => logic.actions.submitTestInvocation()).toFinishAllListeners()
+ return
+ }
+ if (surface === 'template') {
+ const template = messageTemplateLogic({ id: 'new' })
+ template.mount()
+ template.actions.setTemplateValue('content.email.subject', 'Welcome')
+ template.actions.setTemplateValue('content.email.text', 'Hello')
+ }
+ const logic =
+ surface === 'template' ? messageTemplateTestSendLogic({ id: 'new' }) : broadcastTestSendLogic({ id: 'new' })
+ logic.mount()
+ logic.actions.setRecipientEmail('tester@example.com')
+ await expectLogic(logic, () => logic.actions.sendTestEmail()).toFinishAllListeners()
+}
+
+describe('test email quick start completion', () => {
+ let persistedTasks: Record
+ let invocationCount: number
+ beforeEach(() => {
+ localStorage.clear()
+ persistedTasks = {}
+ invocationCount = 0
+ useMocks({
+ get: {
+ '/api/projects/:team_id/integrations/': { results: [] },
+ '/api/environments/:team_id/persons/': { results: [] },
+ },
+ patch: {
+ '/api/environments/:team_id/': async ({ request }) => {
+ const body = (await request.json()) as Pick
+ persistedTasks = body.onboarding_tasks ?? {}
+ return [200, { ...MOCK_DEFAULT_TEAM, ...body }]
+ },
+ },
+ })
+ initKeaTests()
+ globalSetupLogic.mount()
+ })
+
+ describe.each(['template', 'broadcast', 'email step'] as const)('%s', (surface) => {
+ it.each([
+ { outcome: 'delivered', status: 'success', logs: [], httpStatus: 200, completed: true },
+ {
+ outcome: 'delivered with first run disabled',
+ status: 'success',
+ logs: [],
+ httpStatus: 200,
+ completed: false,
+ firstRun: false,
+ },
+ { outcome: 'skipped', status: 'skipped', logs: [], httpStatus: 200, completed: false },
+ {
+ outcome: 'declined by the email worker',
+ status: 'success',
+ logs: [
+ {
+ level: 'info',
+ message: 'Skipping send: recipient has opted out.',
+ timestamp: '2026-01-01T00:00:00Z',
+ },
+ ],
+ httpStatus: 200,
+ completed: false,
+ },
+ { outcome: 'failed', status: 'error', logs: [], httpStatus: 200, completed: false },
+ { outcome: 'rejected by the API', status: 'error', logs: [], httpStatus: 500, completed: false },
+ ])(
+ 'completes the quick start task only when the test email is delivered: $outcome',
+ async ({ status, logs, httpStatus, completed, firstRun = true }) => {
+ featureFlagLogic.actions.setFeatureFlags([], { [FEATURE_FLAGS.WORKFLOWS_FIRST_RUN]: firstRun })
+ useMocks({
+ post: {
+ '/api/environments/:team_id/hog_flows/:id/invocations/': () => {
+ invocationCount++
+ return [httpStatus, { status, nextActionId: null, logs }]
+ },
+ },
+ })
+
+ await sendTestEmail(surface)
+ await expectLogic(teamLogic).toFinishAllListeners()
+
+ expect(invocationCount).toBe(1)
+ expect(globalSetupLogic.values.optimisticTaskStatuses[SetupTaskId.SendWorkflowTestEmail]).toBe(
+ completed ? ActivationTaskStatus.COMPLETED : undefined
+ )
+ expect(persistedTasks[SetupTaskId.SendWorkflowTestEmail]).toBe(
+ completed ? ActivationTaskStatus.COMPLETED : undefined
+ )
+ }
+ )
+ })
+
+ it.each([
+ { run: 'a mocked email', mocked: true, actionId: 'email_node' },
+ { run: 'a non-email step', mocked: false, actionId: 'exit_node' },
+ ])('leaves the task incomplete after $run succeeds', async ({ mocked, actionId }) => {
+ useMocks({
+ post: {
+ '/api/environments/:team_id/hog_flows/:id/invocations/': () => {
+ invocationCount++
+ return [200, { status: 'success', nextActionId: null, logs: [] }]
+ },
+ },
+ })
+
+ await sendTestEmail('email step', { mocked, actionId })
+
+ expect(invocationCount).toBe(1)
+ expect(globalSetupLogic.values.optimisticTaskStatuses[SetupTaskId.SendWorkflowTestEmail]).toBeUndefined()
+ expect(persistedTasks[SetupTaskId.SendWorkflowTestEmail]).toBeUndefined()
+ })
+})
diff --git a/products/workflows/package.json b/products/workflows/package.json
index e250226db894..0479d19fc474 100644
--- a/products/workflows/package.json
+++ b/products/workflows/package.json
@@ -19,6 +19,7 @@
},
"devDependencies": {
"@storybook/react": "catalog:",
+ "@testing-library/dom": "*",
"@testing-library/react": "*",
"@types/papaparse": "*",
"kea-test-utils": "catalog:"
diff --git a/services/mcp/src/api/generated.ts b/services/mcp/src/api/generated.ts
index 90efd12b44fa..4226ef3a2a88 100644
--- a/services/mcp/src/api/generated.ts
+++ b/services/mcp/src/api/generated.ts
@@ -14166,6 +14166,8 @@ export namespace Schemas {
* * `configure_workflow_trigger` - configure_workflow_trigger
* * `add_workflow_action` - add_workflow_action
* * `launch_workflow` - launch_workflow
+ * * `send_workflow_test_email` - send_workflow_test_email
+ * * `send_from_own_email_domain` - send_from_own_email_domain
* * `create_first_endpoint` - create_first_endpoint
* * `configure_endpoint` - configure_endpoint
* * `test_endpoint` - test_endpoint
@@ -14237,6 +14239,8 @@ export namespace Schemas {
ConfigureWorkflowTrigger: 'configure_workflow_trigger',
AddWorkflowAction: 'add_workflow_action',
LaunchWorkflow: 'launch_workflow',
+ SendWorkflowTestEmail: 'send_workflow_test_email',
+ SendFromOwnEmailDomain: 'send_from_own_email_domain',
CreateFirstEndpoint: 'create_first_endpoint',
ConfigureEndpoint: 'configure_endpoint',
TestEndpoint: 'test_endpoint',
@@ -53528,6 +53532,33 @@ export namespace Schemas {
*/
export type HogFlowTemplateVariablesItem = {[key: string]: string};
+ /**
+ * * `event` - Event
+ * * `no_event` - No event
+ * * `schedule` - Schedule
+ */
+ export type HogFlowTemplateStartsOnSerializerKindEnum = typeof HogFlowTemplateStartsOnSerializerKindEnum[keyof typeof HogFlowTemplateStartsOnSerializerKindEnum];
+
+
+ export const HogFlowTemplateStartsOnSerializerKindEnum = {
+ Event: 'event',
+ NoEvent: 'no_event',
+ Schedule: 'schedule',
+ } as const;
+
+ export interface HogFlowTemplateStartsOn {
+ /** Whether the template starts on an event, an absence of events, or a schedule.
+ *
+ * * `event` - Event
+ * * `no_event` - No event
+ * * `schedule` - Schedule */
+ kind: HogFlowTemplateStartsOnSerializerKindEnum;
+ /** Event names that can drive the template, in order of preference. Empty for schedules. */
+ events: string[];
+ /** Short qualifier shown with the template's trigger. */
+ detail: string;
+ }
+
/**
* * `team` - Only team
* * `organization` - Organization
@@ -53587,6 +53618,8 @@ export namespace Schemas {
image_url?: string | null;
/** Tags for filtering templates. */
tags?: string[];
+ /** What starts a global email template. Null for other templates. */
+ readonly starts_on: HogFlowTemplateStartsOn | null;
/** Who can use the template: this project only, or every project in the organization.
*
* * `team` - Only team
@@ -78334,6 +78367,8 @@ export namespace Schemas {
image_url?: string | null;
/** Tags for filtering templates. */
tags?: string[];
+ /** What starts a global email template. Null for other templates. */
+ readonly starts_on?: HogFlowTemplateStartsOn | null;
/** Who can use the template: this project only, or every project in the organization.
*
* * `team` - Only team
+ {message}
+
+
+ prompt },
+ ]}
+ agentKeys={['clipboard']}
+ storageKey="workflows-first-run-agent-help"
+ variant="outline"
+ onRun={() => reportPromptCopied()}
+ data-attr="workflows-first-run-copy-agent-prompt"
+ />
+ {isCloudOrDev && (
+
+ {wizardShown && (
+
+
+
+ This workflow is not sending yet.
+
+
+
+ Your workflow is sending.
+
+
+
+ {recommendedBecause && {recommendedBecause}}
+ {template.image_url && (
+ 
+ )}
+
+ }
+ footer={
+
+
+ }
+ onClick={() => pickTemplate(template.id)}
+ data-attr={recommendedBecause ? 'first-run-recommended-template' : 'first-run-template'}
+ />
+ )
+}
diff --git a/products/workflows/frontend/firstRun/MakeItYoursActions.tsx b/products/workflows/frontend/firstRun/MakeItYoursActions.tsx
new file mode 100644
index 000000000000..794d4ba5892a
--- /dev/null
+++ b/products/workflows/frontend/firstRun/MakeItYoursActions.tsx
@@ -0,0 +1,106 @@
+import { useActions, useValues } from 'kea'
+
+import { LemonBanner, LemonButton, LemonSwitch, Link } from '@posthog/lemon-ui'
+
+import { urls } from 'scenes/urls'
+
+import { TestSendOutcome, firstRunMakeItYoursLogic } from './firstRunMakeItYoursLogic'
+
+export function MakeItYoursActions({ templateId }: { templateId: string }): JSX.Element {
+ const logic = firstRunMakeItYoursLogic({ templateId })
+ const {
+ firstRunSender,
+ firstRunSenderLoading,
+ enableWorkflow,
+ enableDisabledReason,
+ sendTestDisabledReason,
+ createDisabledReason,
+ testSendOutcome,
+ testSendResultLoading,
+ createdWorkflowLoading,
+ createError,
+ } = useValues(logic)
+ const { sendTest, createWorkflow, setEnableWorkflow } = useActions(logic)
+
+ return (
+
+ {!firstRunSender && !firstRunSenderLoading && (
+
+ No email sender is set up yet. Connect one in Channels{' '}
+ to send a test or enable the workflow.
+
+ )}
+ {testSendOutcome && sendTest()}
+ loading={testSendResultLoading}
+ disabledReason={sendTestDisabledReason}
+ data-attr="first-run-send-test"
+ >
+ {testSendOutcome?.kind === 'sent' ? 'Send another test' : 'Send me a test'}
+
+ {createError && (
+
+ Couldn't create the workflow: {createError}
+
+ )}
+ createWorkflow()}
+ loading={createdWorkflowLoading}
+ disabledReason={createDisabledReason}
+ data-attr="first-run-create-workflow"
+ >
+ {enableWorkflow ? 'Enable and open workflow' : 'Open workflow'}
+
+
+ )
+}
+
+function enableHelp(enableWorkflow: boolean, senderName: string | undefined): string {
+ if (enableWorkflow && senderName) {
+ return `It starts sending right away, from ${senderName}.`
+ }
+ if (senderName) {
+ return `It opens as a draft and sends nothing until you enable it. Then it sends from ${senderName}.`
+ }
+ return 'It opens as a draft and sends nothing until you enable it.'
+}
+
+function TestSendOutcomeBanner({ outcome }: { outcome: TestSendOutcome }): JSX.Element {
+ if (outcome.kind === 'sent') {
+ return (
+
+
+ {templateEmails.length} emails in this workflow
+
+ {templateEmails.map((email, index) => {
+ const isOpen = email.id === openEmailId
+ return (
+ openEmail(email.id)}
+ data-attr="first-run-email-list-item"
+ icon={{index + 1}}
+ sideIcon={
+ editedEmailIds.includes(email.id) ? (
+
+ Edited
+
+ ) : null
+ }
+ >
+
+ {email.subject || 'No subject'}
+ {email.timing}
+
+
+ )
+ })}
+
+ )
+}
diff --git a/products/workflows/frontend/firstRun/TemplateStartsOnLine.tsx b/products/workflows/frontend/firstRun/TemplateStartsOnLine.tsx
new file mode 100644
index 000000000000..66793e70c62c
--- /dev/null
+++ b/products/workflows/frontend/firstRun/TemplateStartsOnLine.tsx
@@ -0,0 +1,37 @@
+import { IconBolt, IconClock } from '@posthog/icons'
+import { LemonTag } from '@posthog/lemon-ui'
+
+import { PropertyKeyInfo } from 'lib/components/PropertyKeyInfo'
+import { TaxonomicFilterGroupType } from 'lib/components/TaxonomicFilter/types'
+import { capitalizeFirstLetter } from 'lib/utils/strings'
+
+import type { GalleryTemplate } from './firstRunGalleryLogic'
+
+export function TemplateStartsOnLine({ galleryTemplate }: { galleryTemplate: GalleryTemplate }): JSX.Element {
+ const { startsOn, matchedEvent } = galleryTemplate
+
+ if (startsOn.kind === 'schedule') {
+ return (
+
+
+
+ Couldn't load the template gallery. Try again, or use New workflow to start from a blank one.
+
+ ) : (
+
+ )
+}
+
+function gallerySubtitle(readyCount: number, activeFilter: GalleryFilter): string {
+ if (readyCount === 0) {
+ return 'Your app does not send the events these templates need yet. Each card says what is missing.'
+ }
+ return activeFilter === 'picked'
+ ? 'These templates work with the events your app sends today. Pick one to make it yours.'
+ : 'Templates that work with the events your app sends today come first.'
+}
diff --git a/products/workflows/frontend/firstRun/WorkflowsFirstRunMakeItYours.stories.tsx b/products/workflows/frontend/firstRun/WorkflowsFirstRunMakeItYours.stories.tsx
new file mode 100644
index 000000000000..fb0ad9c7c99d
--- /dev/null
+++ b/products/workflows/frontend/firstRun/WorkflowsFirstRunMakeItYours.stories.tsx
@@ -0,0 +1,138 @@
+import { Meta, StoryObj } from '@storybook/react'
+import { within } from '@testing-library/dom'
+
+import { FEATURE_FLAGS } from 'lib/constants'
+import { App } from 'scenes/App'
+import { urls } from 'scenes/urls'
+
+import { mswDecorator } from '~/mocks/browser'
+import { EMPTY_PAGINATED_RESPONSE, toPaginatedResponse } from '~/mocks/handlers'
+
+import { userEvent } from 'storybook/test'
+
+import { FIRST_RUN_TEMPLATE_PARAM } from './firstRunGalleryLogic'
+import {
+ RE_ENGAGEMENT_ID,
+ OWN_SENDER,
+ TRIAL_UPGRADE_NUDGE_ID,
+ WELCOME_SEQUENCE_ID,
+ globalTemplates,
+ projectThatSends,
+} from './firstRunStoryFixtures'
+
+function makeItYoursUrl(templateId: string): string {
+ return `${urls.workflows()}?${FIRST_RUN_TEMPLATE_PARAM}=${templateId}`
+}
+
+const SKIP_REASON =
+ 'Skipping send: the domain "example.com" has no reachable mail servers, so this message would hard bounce.'
+
+const meta: Meta = {
+ component: App,
+ title: 'Products/Workflows/First run make it yours',
+ parameters: {
+ layout: 'fullscreen',
+ viewMode: 'story',
+ mockDate: '2026-10-05',
+ pageUrl: makeItYoursUrl(WELCOME_SEQUENCE_ID),
+ featureFlags: [FEATURE_FLAGS.WORKFLOWS_FIRST_RUN],
+ testOptions: { viewport: { width: 1440, height: 1400 }, waitForLoadersToDisappear: true },
+ },
+ decorators: [
+ mswDecorator({
+ get: {
+ '/api/projects/:team_id/hog_flows/': EMPTY_PAGINATED_RESPONSE,
+ '/api/projects/:team_id/hog_flows/email_sending_suspension/': {
+ email_sending_suspended: false,
+ email_sending_suspended_at: null,
+ email_sending_suspension_reason: '',
+ },
+ '/api/projects/:team_id/hog_flow_templates/': toPaginatedResponse(globalTemplates),
+ '/api/projects/:team_id/integrations/': toPaginatedResponse([OWN_SENDER]),
+ '/api/projects/:team_id/messaging_templates/': EMPTY_PAGINATED_RESPONSE,
+ },
+ post: {
+ '/api/projects/:team_id/hog_flows/': [201, { id: 'wf-1', status: 'active' }],
+ '/api/projects/:team_id/hog_flows/new/invocations/': [
+ 200,
+ { status: 'success', logs: [], nextActionId: null },
+ ],
+ },
+ }),
+ mswDecorator(projectThatSends(['signed_up', '$pageview', '$feature_view'])),
+ ],
+}
+export default meta
+
+type Story = StoryObj<{}>
+
+export const TwoEmails: Story = {}
+
+export const ThreeEmails: Story = {
+ parameters: { pageUrl: makeItYoursUrl(TRIAL_UPGRADE_NUDGE_ID) },
+}
+
+export const SingleEmail: Story = {
+ parameters: { pageUrl: makeItYoursUrl(RE_ENGAGEMENT_ID) },
+}
+
+export const NoSender: Story = {
+ decorators: [mswDecorator({ get: { '/api/projects/:team_id/integrations/': EMPTY_PAGINATED_RESPONSE } })],
+}
+
+export const ViewerAccess: Story = {
+ render: function ViewerAccess(): JSX.Element {
+ ;(window as any).POSTHOG_APP_CONTEXT.resource_access_control.hog_flow = 'viewer'
+ return
+
+ Start with an email template
+ {galleryTemplates !== null && ( +{gallerySubtitle(readyTemplates.length, activeFilter)}
+ )} +
+ {[0, 1, 2].map((index) => (
+
+ )
+ ) : (
+ <>
+
+
+ size="small"
+ value={activeFilter}
+ onChange={setFilter}
+ options={[
+ {
+ value: 'picked',
+ label: `Picked for your data (${readyTemplates.length})`,
+ disabledReason:
+ readyTemplates.length === 0
+ ? 'Your app does not send the events these templates start on yet'
+ : undefined,
+ 'data-attr': 'first-run-filter-picked',
+ },
+ {
+ value: 'all',
+ label: `All email templates (${galleryTemplates.length})`,
+ 'data-attr': 'first-run-filter-all',
+ },
+ ]}
+ />
+
+ Browse all workflow templates
+
+
+
+ {shownTemplates.map((galleryTemplate) => (
+
+
+ )}
+
+
+ )
+}
diff --git a/products/workflows/frontend/firstRun/WorkflowsFirstRunTab.test.tsx b/products/workflows/frontend/firstRun/WorkflowsFirstRunTab.test.tsx
new file mode 100644
index 000000000000..1a5909f4ee49
--- /dev/null
+++ b/products/workflows/frontend/firstRun/WorkflowsFirstRunTab.test.tsx
@@ -0,0 +1,81 @@
+import '@testing-library/jest-dom'
+
+import { cleanup, render, waitFor } from '@testing-library/react'
+
+import { navPanelProductPushWelcomeLogic } from 'lib/components/NavPanelAdvertisement/navPanelProductPushWelcomeLogic'
+import { clearAllCachedHasData } from 'lib/components/ProductEmptyState/setupDetectionLogic'
+import { FEATURE_FLAGS } from 'lib/constants'
+import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
+
+import { useMocks } from '~/mocks/jest'
+import { ProductKey } from '~/queries/schema/schema-general'
+import { initKeaTests } from '~/test/init'
+
+import { WorkflowsFirstRunTab } from './WorkflowsFirstRunTab'
+
+const WELCOME = {
+ campaignId: 'campaign-1',
+ productKey: ProductKey.WORKFLOWS,
+ label: 'Workflows',
+ text: 'Message users when it matters.',
+}
+
+describe('WorkflowsFirstRunTab', () => {
+ afterEach(() => {
+ cleanup()
+ clearAllCachedHasData()
+ })
+
+ it.each([
+ {
+ project: 'without workflows',
+ workflowCount: 0,
+ shows: 'workflows-first-run-gallery',
+ enabled: true,
+ holdsWelcome: true,
+ },
+ { project: 'with a workflow', workflowCount: 1, shows: 'workflows-table', enabled: true, holdsWelcome: false },
+ {
+ project: 'without workflows when first run is off',
+ workflowCount: 0,
+ shows: 'workflows-table',
+ enabled: false,
+ holdsWelcome: false,
+ },
+ ])('shows a project $project the $shows', async ({ workflowCount, shows, enabled, holdsWelcome }) => {
+ useMocks({
+ get: {
+ '/api/projects/:team_id/hog_flows/': {
+ count: workflowCount,
+ results: [],
+ },
+ },
+ })
+ initKeaTests()
+ featureFlagLogic.actions.setFeatureFlags([], { [FEATURE_FLAGS.WORKFLOWS_FIRST_RUN]: enabled })
+ const welcomeLogic = navPanelProductPushWelcomeLogic()
+ welcomeLogic.mount()
+ welcomeLogic.actions.setPendingWelcome(WELCOME)
+
+ const { container, unmount } = render(
+
+ {/* Below 56rem the side column no longer fits beside the editor: the email list moves above it and the actions below. */}
+
+
+ Make it yours: {template.name}
+
+
+
+ {hasSeveralEmails && (
+
+
+
+ )}
+
+ {hasSeveralEmails && openEmailPosition && (
+
+ Email {openEmailPosition.index} of {openEmailPosition.total}
+
+ )}
+ {/* The template type hides the From and To fields: the first-run sender is fixed, and the
+ recipient comes from the trigger. The editor remounts per email, so a canvas export can
+ never land on the email opened after it. */}
+
+
+ editEmail(openEmail.id, value)}
+ />
+
+
+
+
+
+ )
+ }
+ if (setupStatus !== 'needs-setup') {
+ return ${subject}
`, + text: subject, + design: { body: { rows: [], values: { subject } } }, + }, + templating: 'liquid', + }, + }, + }, + } as HogFlowAction +} + +function delayAction(id: string, duration: string): HogFlowAction { + return { + id, + type: 'delay', + name: 'Delay', + description: '', + created_at: 0, + updated_at: 0, + config: { delay_duration: duration }, + } as HogFlowAction +} + +function branchAction(id: string): HogFlowAction { + return { + id, + type: 'conditional_branch', + name: 'Branch', + description: '', + created_at: 0, + updated_at: 0, + config: { conditions: [] }, + } as HogFlowAction +} + +const TRIGGER: HogFlowAction = { + id: 'trigger_node', + type: 'trigger', + name: 'Trigger', + description: '', + created_at: 0, + updated_at: 0, + config: { + type: 'event', + filters: { events: [{ id: 'user signed up', name: 'user signed up', type: 'events', order: 0 }] }, + }, +} as HogFlowAction + +const EXIT: HogFlowAction = { + id: 'exit_node', + type: 'exit', + name: 'Exit', + description: '', + created_at: 0, + updated_at: 0, + config: { reason: 'Done' }, +} as HogFlowAction + +// Three emails whose stored order differs from the flow order, with a branch on the way to the last one. +const SEQUENCE: Partial${subject} edited
`, + text: `${subject} edited`, + design: { body: { rows: [], values: { subject: `${subject} edited` } } }, + from: { integrationId: 99 }, + to: '{{ person.properties.email }}', + } as EmailTemplate +} + +function emailStepsOf(workflow: Partial