Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

feat(inbox): add progressive inbox onboarding variant (#117892)

Georgiy Tarasov382f94d4b4a9
diff --git a/docs/internal/activity-logging.md b/docs/internal/activity-logging.md
index ab403aafdc25..e5c27eaeb239 100644
--- a/docs/internal/activity-logging.md
+++ b/docs/internal/activity-logging.md
@@ -135,7 +135,8 @@ Never put a credential field in that branch.
Destination activity logs record changes to `mappings` without their values.
For `inputs` they keep each key and record only whether its value changed, so the history can name the changed input.
Rows written before a field joined `field_with_masked_contents` still store its values.
-Inbox onboarding records that setup changed while masking the saved draft, including scout instructions and project evidence.
+Guided Inbox onboarding first saves a draft when the sources step is completed; opening or editing that first step keeps the draft local.
+Later setup changes are recorded while masking the saved draft, including scout instructions and project evidence.
Code that returns a row's `detail` to a user must read `ActivityLog.safe_detail`, which masks those fields in old rows too.
The activity log API, the advanced activity logs API and its exports, the notifications feed, and the PostHog AI context all do.
The `system.activity_logs` SQL table and the search filter read the stored `detail`, so old rows need rewriting to stay masked there.
diff --git a/frontend/snapshots.yml b/frontend/snapshots.yml
index 7380c583f10c..b59a8496c029 100644
--- a/frontend/snapshots.yml
+++ b/frontend/snapshots.yml
@@ -11474,6 +11474,10 @@ snapshots:
hash: v1.k794b7964.7cbc08f42385a0c5e3724905cd168889ea285773047dec630d44f44ae3214ff3.87cUu_WLwNEGkXed2dbxjbzN3Qnnq1ooUzoNQjCGRF4
scenes-app-inbox-focused-setup--github-already-connected--light:
hash: v1.k794b7964.0c4e46e52d6fd87cfda72f60455771998ed40646fd21942f80380322da453354.3sHKex8XGnDIU5-Q1CC-G9FaHEtRtR_vTBBQK3RfwsY
+ scenes-app-inbox-focused-setup--github-without-automatic-implementation--dark:
+ hash: v1.k794b7964.65add98c7b7ca1ef5c937f57e619c355e7350b680f78d2823a7fcfcb4c14b9c4.HzFGZjD0QK7T2fN0qIXfMF9bDGuHcg0wdH0h2jXMj0E
+ scenes-app-inbox-focused-setup--github-without-automatic-implementation--light:
+ hash: v1.k794b7964.11facf4293ae6eace59b5d869c8f0ff6916040f90c969a15db0186b542ca2cb1.eoht0_hDv2jDlrJIx0Bup0fYp4lUmB8bJ37BK8ZAqtY
scenes-app-inbox-focused-setup--manual-entry--dark:
hash: v1.k794b7964.ffef931600e70b99b707e8e5153406ed2489a138311b2373e5154d32952e3bc2.0nf9GadNMHxdAJLVVgXa5xYpJO0iy3OPG2E5a9s9JTU
scenes-app-inbox-focused-setup--manual-entry--light:
@@ -11483,13 +11487,25 @@ snapshots:
scenes-app-inbox-focused-setup--narrow-signals--light:
hash: v1.k794b7964.5bf7db12cc74d13fb7c4d54340713b27cbbed447a418130ca9c6b0c420640062.Pp6_ViU79ZscAecpcpkBPT0Alq_X3_4eRr2odBPpqfc
scenes-app-inbox-focused-setup--narrow-treatment-entry--dark:
- hash: v1.k794b7964.5ab62e98e2aa1f5e31365f50562f25773d809d7408fd4041df314bbb86106d82.GBtIqzkgeX7m-MJGL9lcOH5lnyJMFe0gap66WkR48aI
+ hash: v1.k794b7964.fbf9c589ba180d9ec70a405fcb12515b5c5e03152f810c08af432baec68e4dbe.Cwc8pBSd6134Krzsziodb-nuTfULUDxH3MaaTS57PWg
scenes-app-inbox-focused-setup--narrow-treatment-entry--light:
- hash: v1.k794b7964.cbd7b915414dec14f348e234143de567cf9ac097cb7f263f4d973b4f231ad485.tA2iuF30kliNInVONq5u0FHnn8vf-LFGyL182EEsy2M
+ hash: v1.k794b7964.f17a7d7a8ded09d87b729eb45b54c4c6362bf38aea18919570bead767bfc1b5f.OVhZ9WYEA9T2uqG3Mdc_AOJF8fWjfDQaSVTf6vh_OJs
scenes-app-inbox-focused-setup--no-products-enabled--dark:
hash: v1.k794b7964.764ef45e781be980c6bc60eab99aaef22e011afcccafb78586a7507c9313c345.HjJi0LKC8d2x9Qr76jCkCfYHxucQrnEH3jkQ9ro_mkQ
scenes-app-inbox-focused-setup--no-products-enabled--light:
hash: v1.k794b7964.20b18f5ab4b378c6b06c45b3de05dd4ba1783f7995d842ac40c3555a1dd450c5.Tw6tZ6X7sU3V4qVx9jmSBj4rS04FnKis1tqfTQuAhgY
+ scenes-app-inbox-focused-setup--quick-activated--dark:
+ hash: v1.k794b7964.3d8df0414c1d087d6a667af90bddbd3271f6b95adaa54fc585897716af61fd9f.u6S4EDAfiSdebn74czWvMD7KqQcsbtUqv9sUwoE5FGQ
+ scenes-app-inbox-focused-setup--quick-activated--light:
+ hash: v1.k794b7964.f6adadab19ce25a68cf6d5caa445aa92dd089693369d7c9dc6b378e37b3c2967.dNFD9VHrTi9mRU7-91C0-PTufBvRt73QTkqiJMpdHIU
+ scenes-app-inbox-focused-setup--quick-connected--dark:
+ hash: v1.k794b7964.3a1608985504e94975c5d9f921a28a0763736b7e681f155aa88eeb7adaad28f5.DH0r-gI7x-RmnIazIzqZ5mReEIFwyCLCpA6tFodA1rE
+ scenes-app-inbox-focused-setup--quick-connected--light:
+ hash: v1.k794b7964.5ae667b502e5e3a8eced166531058a89246bbd9f4faaef7a43a3ea2e465432c1.9PLqflzvIg__oGk-k8DtblIi3zmrVLRFYW3HyeC-1Gs
+ scenes-app-inbox-focused-setup--quick-entry--dark:
+ hash: v1.k794b7964.c4ccc14ca17e517451f5ed19806162fb6e79ed065c817801e63821eb3492487e.kH4_9vAE-tgHKUONOK1kywaoJ9GIQNVb9FbPnpLJtlE
+ scenes-app-inbox-focused-setup--quick-entry--light:
+ hash: v1.k794b7964.85f210a647928b29cd0341314fa0341b5f925becf91a7bfef6e13d6655c15759.8TwJ9MF9j3MxeBf5QyJXLE6nTDV5Iyht-sYiFdZdJ8Y
scenes-app-inbox-focused-setup--scouts--dark:
hash: v1.k794b7964.6fd8aa35755ed0ad8bfdee5e82fd3ae4bb2b66b185c5ad8ce8762291e9242c81.EseOEIZLSBk_G1Dlr44lR9ulG4RFO6cCcKKY8bCOLH4
scenes-app-inbox-focused-setup--scouts--light:
@@ -11499,9 +11515,9 @@ snapshots:
scenes-app-inbox-focused-setup--signals--light:
hash: v1.k794b7964.6509c25bb6925e6c47261dec8cf7098cda679b92312bf31a062142fc3e77bb12.xGsSNmODSL8UdPd4hiJhAhMHAMwhoh5SfDHNuulisOA
scenes-app-inbox-focused-setup--treatment-entry--dark:
- hash: v1.k794b7964.7994febd8948a1a7efc82e5b9c295f26541b35031c38ac4684281bee29b3041f.buzQOjSEXhdDveeZT0biMuWSs9OFKBN6jzwRsnfig14
+ hash: v1.k794b7964.9d9542307a95b0bafac23b78e96cc3ecb43342c242ba53d1b62cfd39ff8c9164.17GVEltYe-Y4Uc2C2Fpy6IFZF1AgsDb3u_7znDfeFjQ
scenes-app-inbox-focused-setup--treatment-entry--light:
- hash: v1.k794b7964.b3abf739a3d8935a5daa7653f17fbb65a6d57b7e85c23348f2c7f306264dbf70.muEj10uHcel9GGp-qDSRa2j1mFYjLK5LyAqzF_C2tDE
+ hash: v1.k794b7964.0093b8edbd72c23f2d920d20f356b5480996df0146035740c23ee5284d9162f0.Er5MgKf1V-yNehXAMLLOoKW8pTOhteg369eKYMPRV0U
scenes-app-inbox-focused-setup--treatment-reminder--dark:
hash: v1.k794b7964.80667d13f6fd3903f1e1d602332472fb82b04068c9740f2c71bd768b625c6233.F80fM8smMQBS2gdsx4T5hqd7h-Vn5hZkZh3zJRvMuBo
scenes-app-inbox-focused-setup--treatment-reminder--light:
@@ -11607,13 +11623,13 @@ snapshots:
scenes-app-inbox-scene--empty-with-many-scouts--light:
hash: v1.k794b7964.facecddc48f471398f32d48fed8287b91573105ddd2d2ce2adc18eaf649900e7.QVbf6XPS8aj7-Jrj-3T_o1fu7tZNl8ZCJqGw3yRl8Qw
scenes-app-inbox-scene--focused-onboarding--dark:
- hash: v1.k794b7964.4fcfaa0984e34489b28669ed5eb0edb6e97fc264d23ff773d1186ff3c34f57fd.GiD0odqQbMhT21w3-gYboiZG8Qq-It2y0yHpPdIA-zc
+ hash: v1.k794b7964.43cc18dec7e7ba2de1f09d084134799e6c702099d4a341a54385cc727826f61c.Rj8zuqNxa2_WADVHavBJ_cJPCM7Ddfv4eb7lMkGHrvk
scenes-app-inbox-scene--focused-onboarding--light:
- hash: v1.k794b7964.3fd7edfc3a61559d26da40b6486b4d2f712db05fd5072cbc8332f57a74849aa8.9j0sGbHDpLsWr_Bt34mOIe_lp-l9PXoUsKbK8nZRWyE
+ hash: v1.k794b7964.b0bdc77c9e9d9c45a4e1b441788f6cce267c1316a25ce1d9faeba34cf23e7697.jE8yGvuVwhJiu6e8i7mcGbnZsHYVMhOEvSNhJSs4pZE
scenes-app-inbox-scene--focused-onboarding-complete--dark:
- hash: v1.k794b7964.23f6d8d2bde65b867977db568e3dfeedc4019d90979698c8e6d454a202b3e96d.8RH2ZuOFoZM7RcXAtTaGKgavGkH7Xp2s3Wca5jmvSIE
+ hash: v1.k794b7964.414a7eecf51038fad769cfe620b23bb48b6e3df4b00b6b6d53a6605c0f586514.sfr-mU-Cqlz1Z76x8U-c4jGYcc7oeT4ph0Y4wQIpGcs
scenes-app-inbox-scene--focused-onboarding-complete--light:
- hash: v1.k794b7964.fc4381e7801f964ec92fc2efb170204180dfb80b678d39fe50e8bfc14df9705c.xy73qgq6MnEB8n_mC70uv6kWchMnAebI0Oua0N7NSCk
+ hash: v1.k794b7964.00c6338c2bdba734ec3883a530592381d92d4004245315edc2869f0ac3906239.3m-CF_ssrDqvSkbenzHSc055rtGkk88Ps3oLkPvF9Qc
scenes-app-inbox-scene--inbox--dark:
hash: v1.k794b7964.9e408067ea1f3714dcf8d9e812dde013bd58ce007872c1edadbabca46f30dae9.rsVWshwBIWY3KXFqChFMc0qts9C78Rkju8Cmq5Nofvo
scenes-app-inbox-scene--inbox--light:
diff --git a/frontend/src/lib/components/ProductEmptyState/ProductEmptyState.tsx b/frontend/src/lib/components/ProductEmptyState/ProductEmptyState.tsx
index a9f00972b56c..31eede46f9ac 100644
--- a/frontend/src/lib/components/ProductEmptyState/ProductEmptyState.tsx
+++ b/frontend/src/lib/components/ProductEmptyState/ProductEmptyState.tsx
@@ -319,7 +319,10 @@ export function ProductEmptyState({ config: baseConfig, mode, preview = false }:
// Previews read `--empty-state-accent` only, so in dark mode point that at the dark
// token here rather than asking every preview to branch on the theme itself.
// Tighter padding while stacked, where the width goes to the preview itself.
- className="flex min-w-0 flex-col justify-center gap-3 p-6 @min-[64rem]/product-empty-state:p-10 rounded-md border border-primary dark:[--empty-state-accent:var(--empty-state-accent-dark)]"
+ className={cn(
+ 'flex min-w-0 flex-col justify-center gap-3 p-6 @min-[64rem]/product-empty-state:p-10 rounded-md border border-primary dark:[--empty-state-accent:var(--empty-state-accent-dark)]',
+ config.previewClassName
+ )}
style={{
backgroundImage:
'linear-gradient(135deg, color-mix(in oklab, var(--empty-state-accent) 16%, transparent) 0%, color-mix(in oklab, var(--empty-state-accent) 5%, transparent) 45%, transparent 80%)',
diff --git a/frontend/src/lib/components/ProductEmptyState/types.ts b/frontend/src/lib/components/ProductEmptyState/types.ts
index 5d2cfbbe9c17..2a27d1a970d7 100644
--- a/frontend/src/lib/components/ProductEmptyState/types.ts
+++ b/frontend/src/lib/components/ProductEmptyState/types.ts
@@ -149,6 +149,7 @@ export interface ProductEmptyStateConfig {
manualSetupUrl?: string
/** Rendered as "<previewLabel>" with a pulsing live dot, above the preview */
previewLabel: string
+ previewClassName?: string
/** Self-animating signature preview populated with realistic fake data */
Preview: ComponentType<{ mode: ProductEmptyStateMode }>
/** Product-specific live status line (e.g. a "listening for events" indicator), rendered under the command block */
diff --git a/frontend/src/lib/constants.tsx b/frontend/src/lib/constants.tsx
index dc94fb3090de..62a69f2a5127 100644
--- a/frontend/src/lib/constants.tsx
+++ b/frontend/src/lib/constants.tsx
@@ -246,6 +246,7 @@ export const FEATURE_FLAGS = {
SCOUTS_TOOL_ACCESS: 'scouts-tool-access', // owner: #team-self-driving, gates the per-scout MCP tool list in the inbox scout settings (also checked server-side)
SELF_DRIVING_FREE_TRIAL: 'self-driving-free-trial', // owner: #team-self-driving, the org is on a Self-driving free trial: reports only, no pull requests (also checked server-side)
SELF_DRIVING_QUOTA_ENFORCEMENT: 'self-driving-quota-enforcement', // owner: #team-self-driving, gates self-driving PR-limit enforcement (also checked server-side)
+ SELF_DRIVING_UBP: 'self-driving-ubp', // owner: #team-self-driving
SELF_OPTIMISING_WORKFLOWS: 'self-optimising-workflows', // owner: #team-workflows, gates agent-suggested workflow changes (also checked server-side)
SESSION_REPLAY_BACKEND_LOGS: 'session-replay-backend-logs', // owner: #team-replay
SESSION_REPLAY_DOCTOR: 'session-replay-doctor', // owner: #team-replay
@@ -380,7 +381,7 @@ export const FEATURE_FLAGS = {
INBOX_SELF_DRIVING_EMPTY_STATE: 'inbox-self-driving-empty-state',
INBOX_SLACK_NOTIFICATIONS: 'inbox-slack-notifications', // owner: #team-self-driving, gates the Slack notifications config card in the inbox
INBOX_TIME_WINDOW: 'inbox-time-window', // owner: #team-self-driving, gates the created-in window filter on the inbox report list
- INBOX_UI_ONBOARDING: 'inbox-ui-onboarding', // owner: #team-self-driving, multivariate control/test
+ INBOX_UI_ONBOARDING: 'inbox-ui-onboarding', // owner: #team-self-driving, multivariate control/test-ui/test-github
INSIGHT_ALERTS_EMPTY_STATE_EXPERIMENT: 'insight-alerts-empty-state',
INSIGHT_DATA_CHECKS: 'insight-data-checks', // owner: @sampennington #team-product-analytics, checks the events behind an insight and shows the result on the insight page
INSIGHT_DRAG_TO_ZOOM: 'insight-drag-to-zoom', // owner: @sampennington #team-product-analytics, gates x-axis drag-to-zoom on insight charts (trends today, SQL to follow)
diff --git a/products/signals/backend/facade/onboarding.py b/products/signals/backend/facade/onboarding.py
index 39cc086a683e..40f27ced95cc 100644
--- a/products/signals/backend/facade/onboarding.py
+++ b/products/signals/backend/facade/onboarding.py
@@ -4,6 +4,7 @@ from collections.abc import Callable, Sequence
from typing import TYPE_CHECKING, Any
from django.db import transaction
+from django.db.models import F
from django.utils import timezone
import posthoganalytics
@@ -17,10 +18,12 @@ from products.replay_vision.backend.facade.api import signal_emitting_scanner_id
from products.signals.backend.models import (
AutonomyPriority,
SignalScoutConfig,
+ SignalScoutSuggestionSet,
SignalSourceConfig,
SignalTeamConfig,
signal_source_product_choices,
)
+from products.signals.backend.onboarding_analytics import InboxOnboardingAnalytics
from products.signals.backend.onboarding_completion import InboxOnboardingReconciler
from products.signals.backend.onboarding_scouts import InboxOnboardingScouts
from products.signals.backend.scout_harness.create_access import can_create_scout
@@ -61,7 +64,24 @@ class InboxOnboarding:
state = config.onboarding or {}
if any((state.get("draft") or {}).get(key) for key in ("suggestions", "activation_scouts")):
self.authorize_scouts(False)
- return {"draft": state.get("draft"), "completed_at": state.get("completed_at"), "variant": state.get("variant")}
+ jobs = dict(state.get("jobs", {}))
+ if (
+ jobs.get("recommendations") == "started"
+ and state.get("completed_at")
+ and SignalScoutSuggestionSet.objects.filter(
+ team_id=self.team.parent_team_id or self.team_id,
+ status=SignalScoutSuggestionSet.Status.FAILED,
+ last_requested_at__gte=state["completed_at"],
+ last_completed_at__gte=F("last_requested_at"),
+ ).exists()
+ ):
+ jobs["recommendations"] = "failed"
+ return {
+ "draft": state.get("draft"),
+ "completed_at": state.get("completed_at"),
+ "variant": state.get("variant"),
+ **({"jobs": jobs} if "jobs" in state else {}),
+ }
def state(self) -> dict[str, Any]:
return self._state(get_or_create_team_extension(self.team, SignalTeamConfig))
@@ -83,7 +103,7 @@ class InboxOnboarding:
"exposed_by": self.user.pk,
}
config.save(update_fields=["onboarding", "updated_at"])
- transaction.on_commit(lambda: self._report_exposure(self.user, variant), robust=True)
+ transaction.on_commit(lambda: self._report_exposure(self.user, config), robust=True)
return self._state(config)
def save_draft(self, draft: dict[str, Any]) -> dict[str, Any]:
@@ -103,8 +123,17 @@ class InboxOnboarding:
def complete(self, draft: dict[str, Any]) -> dict[str, Any]:
config = get_or_create_team_extension(self.team, SignalTeamConfig)
if (config.onboarding or {}).get("completed_at"):
+ self._enqueue_activation_jobs(config)
return self._state(config)
+ if (config.onboarding or {}).get("variant") == "test-github":
+ self.authorize_scouts(True)
+ if not any(
+ item["kind"] == "canonical" and item["skill_name"] == "signals-scout-general"
+ for item in draft["suggestions"]
+ ):
+ raise InboxOnboardingValidationError("Quick activation requires the general scout.")
+
if any(
draft.get(key) or ((config.onboarding or {}).get("draft") or {}).get(key)
for key in ("suggestions", "activation_scouts")
@@ -171,28 +200,46 @@ class InboxOnboarding:
"completed_at": timezone.now().isoformat(),
"activated_by": user.pk,
}
+ if state.get("variant") == "test-github":
+ config.onboarding["jobs"] = {"scout": "pending", "recommendations": "pending"}
config.save(
update_fields=["onboarding", "autostart_enabled", "default_autostart_priority", "updated_at"]
)
if resume_operational_scouts:
InboxOnboardingScouts.resume(scout_team_id, withheld, lambda: self.authorize_scouts(True))
- transaction.on_commit(lambda: self._report_completion(user, state.get("variant")), robust=True)
+ transaction.on_commit(lambda: self._report_completion(user, config), robust=True)
+ transaction.on_commit(lambda: self._enqueue_activation_jobs(config))
return self._state(config)
- def _capture(self, user: User, event: str, variant: str | None) -> None:
+ def _enqueue_activation_jobs(self, config: SignalTeamConfig) -> None:
+ state = config.onboarding or {}
+ if state.get("variant") != "test-github":
+ return
+ self.authorize_scouts(True)
+ from products.signals.backend.tasks import (
+ launch_inbox_onboarding_job, # noqa: PLC0415 - keep the Temporal graph off API route loading
+ )
+
+ for job, status in state.get("jobs", {}).items():
+ if status in ("pending", "failed"):
+ launch_inbox_onboarding_job.delay(self.team_id, job)
+
+ def _capture(self, user: User, event: str, properties: dict[str, object]) -> None:
posthoganalytics.capture(
distinct_id=str(user.distinct_id),
event=event,
groups=groups(team=self.team),
- properties={"project_id": self.team_id, "variant": variant, "flow_version": "ui-first-v1"},
+ properties=properties,
)
- def _report_completion(self, user: User, variant: str | None) -> None:
- self._capture(user, "self-driving onboarding completed", variant)
+ def _report_completion(self, user: User, config: SignalTeamConfig) -> None:
+ self._capture(
+ user, "self-driving onboarding completed", InboxOnboardingAnalytics.completion_properties(config, user)
+ )
- def _report_exposure(self, user: User, variant: str) -> None:
- self._capture(user, "self-driving onboarding exposed", variant)
- if variant == "control":
+ def _report_exposure(self, user: User, config: SignalTeamConfig) -> None:
+ self._capture(user, "self-driving onboarding exposed", InboxOnboardingAnalytics.properties(config, user))
+ if (config.onboarding or {}).get("variant") == "control":
from products.signals.backend.tasks import (
reconcile_inbox_onboarding, # noqa: PLC0415 - avoid task imports during API initialization
)
diff --git a/products/signals/backend/onboarding_activation.py b/products/signals/backend/onboarding_activation.py
new file mode 100644
index 000000000000..de060332636e
--- /dev/null
+++ b/products/signals/backend/onboarding_activation.py
@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from django.db import transaction
+from django.utils import timezone
+
+from posthog.event_usage import groups
+from posthog.models.team.team import Team
+from posthog.models.user import User
+from posthog.ph_client import ph_scoped_capture
+from posthog.temporal.common.client import sync_connect
+
+from products.signals.backend.models import SignalScoutConfig, SignalTeamConfig
+from products.signals.backend.onboarding_analytics import InboxOnboardingAnalytics
+from products.signals.backend.scout_harness.run_gates import check_fleet_gates, check_run_in_flight, check_spend_gates
+from products.signals.backend.scout_harness.suggestions import read_suggestion_settings, suggestions_allowed_for_team
+from products.signals.backend.temporal.agentic.scout_scheduler import start_onboarding_signals_scout_run
+from products.signals.backend.temporal.agentic.scout_suggestions import start_manual_scout_suggestions_run
+
+
+class InboxOnboardingActivation:
+ def __init__(self, team_id: int) -> None:
+ self.team_id = team_id
+
+ def _capture_status(self, config: SignalTeamConfig, job: str, status: str, reason: str | None) -> None:
+ user = User.objects.filter(pk=(config.onboarding or {}).get("activated_by")).first()
+ with ph_scoped_capture() as capture:
+ capture(
+ distinct_id=str(config.team.uuid),
+ event="self-driving onboarding job status changed",
+ groups=groups(team=config.team),
+ properties={
+ **InboxOnboardingAnalytics.properties(config, user),
+ "job": job,
+ "status": status,
+ "reason": reason,
+ },
+ )
+
+ def _record_status(self, job: str, status: str, reason: str | None = None) -> None:
+ with transaction.atomic():
+ config = SignalTeamConfig.objects.select_for_update().get(team_id=self.team_id)
+ state = config.onboarding or {}
+ if state.get("jobs", {}).get(job) == status:
+ return
+ config.onboarding = {**state, "jobs": {**state.get("jobs", {}), job: status}}
+ config.save(update_fields=["onboarding", "updated_at"])
+ transaction.on_commit(lambda: self._capture_status(config, job, status, reason), robust=True)
+
+ def _start_scout(self, team: Team) -> bool:
+ scout = (
+ SignalScoutConfig.objects.for_team(team.id)
+ .filter(skill_name="signals-scout-general", enabled=True, emit=True)
+ .first()
+ )
+ if scout is None or check_fleet_gates(team.id) or check_spend_gates(team):
+ return False
+ if check_run_in_flight(team.id, scout.skill_name):
+ return True
+ start_onboarding_signals_scout_run(sync_connect(), team_id=team.id, skill_name=scout.skill_name)
+ SignalScoutConfig.objects.for_team(team.id).filter(pk=scout.pk, last_run_at__isnull=True).update(
+ last_run_at=timezone.now()
+ )
+ return True
+
+ def _start_recommendations(self, team: Team, acting_user_id: int | None) -> bool:
+ if not suggestions_allowed_for_team(read_suggestion_settings(), team.id):
+ return False
+ start_manual_scout_suggestions_run(
+ sync_connect(), team_id=team.id, acting_user_id=acting_user_id, onboarding=True
+ )
+ return True
+
+ def run(self, job: str, *, final_attempt: bool = True) -> None:
+ if job not in ("scout", "recommendations"):
+ raise ValueError("Unknown onboarding job")
+ config = SignalTeamConfig.objects.select_related("team__parent_team", "team__organization").get(
+ team_id=self.team_id
+ )
+ state = config.onboarding or {}
+ if state.get("variant") != "test-github" or not state.get("completed_at"):
+ return
+ if state.get("jobs", {}).get(job) in ("started", "skipped"):
+ return
+ team = config.team.parent_team or config.team
+ if team.organization.is_ai_data_processing_approved is not True:
+ self._record_status(job, "skipped", "ai_consent_required")
+ return
+ try:
+ started = (
+ self._start_scout(team)
+ if job == "scout"
+ else self._start_recommendations(team, state.get("activated_by"))
+ )
+ except Exception:
+ self._record_status(job, "failed" if final_attempt else "pending", "dispatch_error")
+ raise
+ self._record_status(job, "started" if started else "skipped", None if started else "not_eligible")
diff --git a/products/signals/backend/onboarding_analytics.py b/products/signals/backend/onboarding_analytics.py
new file mode 100644
index 000000000000..9c4a8fe4b8c9
--- /dev/null
+++ b/products/signals/backend/onboarding_analytics.py
@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import posthoganalytics
+
+from posthog.event_usage import groups
+
+if TYPE_CHECKING:
+ from posthog.models.user import User
+
+ from products.signals.backend.models import SignalTeamConfig
+
+
+class InboxOnboardingAnalytics:
+ @staticmethod
+ def pricing_flag(config: SignalTeamConfig, user: User | None) -> bool | None:
+ try:
+ result = posthoganalytics.feature_enabled(
+ "self-driving-ubp",
+ str(user.distinct_id if user else config.team.uuid),
+ groups=groups(team=config.team),
+ send_feature_flag_events=False,
+ )
+ return result if isinstance(result, bool) else None
+ except Exception:
+ # A lookup failure must not put this project in the legacy-pricing cohort.
+ return None
+
+ @classmethod
+ def properties(cls, config: SignalTeamConfig, user: User | None = None) -> dict[str, object]:
+ state = config.onboarding or {}
+ draft = state.get("draft") or {}
+ variant = state.get("variant")
+ return {
+ "project_id": config.team_id,
+ "variant": variant,
+ "flow_version": "ui-first-v1",
+ "inbox_client": "cloud",
+ "setup_mode": "quick"
+ if variant == "test-github"
+ else "guided"
+ if draft or variant == "test-ui"
+ else "legacy",
+ "self_driving_ubp": cls.pricing_flag(config, user),
+ }
+
+ @classmethod
+ def completion_properties(cls, config: SignalTeamConfig, user: User | None = None) -> dict[str, object]:
+ draft = (config.onboarding or {}).get("draft") or {}
+ return {
+ **cls.properties(config, user),
+ "automatic_implementation": config.autostart_enabled,
+ "implementation_priority": config.default_autostart_priority,
+ "enabled_source_products": sorted(
+ {source["source_product"] for source in draft.get("sources", []) if source["enabled"]}
+ | ({"replay_vision"} if draft.get("scanner_ids") else set())
+ | ({"signals_scout"} if draft.get("suggestions") else set())
+ )
+ if draft
+ else None,
+ "scout_count": len(draft.get("suggestions", [])) if draft else None,
+ }
diff --git a/products/signals/backend/onboarding_completion.py b/products/signals/backend/onboarding_completion.py
index 063fff0ee1f3..ffd5e7dd8213 100644
--- a/products/signals/backend/onboarding_completion.py
+++ b/products/signals/backend/onboarding_completion.py
@@ -20,6 +20,7 @@ from posthog.ph_client import ph_scoped_capture
from products.replay_vision.backend.facade.api import has_signal_emitting_scanner
from products.signals.backend.models import SignalScoutConfig, SignalSourceConfig, SignalTeamConfig
+from products.signals.backend.onboarding_analytics import InboxOnboardingAnalytics
class RepositoryCheckUnavailable(APIException):
@@ -85,7 +86,7 @@ class InboxOnboardingReconciler:
if not state.get("completed_at"):
locked.onboarding = {**state, "completed_at": timezone.now().isoformat()}
locked.save(update_fields=["onboarding", "updated_at"])
- transaction.on_commit(lambda: self._capture(config), robust=True)
+ transaction.on_commit(lambda: self._capture(locked), robust=True)
return False
def has_repository(self) -> bool:
@@ -113,5 +114,5 @@ class InboxOnboardingReconciler:
distinct_id=str(user.distinct_id if user else config.team.uuid),
event="self-driving onboarding completed",
groups=groups(team=config.team),
- properties={"project_id": self.team_id, "variant": "control", "flow_version": "ui-first-v1"},
+ properties=InboxOnboardingAnalytics.completion_properties(config, user),
)
diff --git a/products/signals/backend/presentation/onboarding.py b/products/signals/backend/presentation/onboarding.py
index ad61ff01da94..dc4feb2b87a6 100644
--- a/products/signals/backend/presentation/onboarding.py
+++ b/products/signals/backend/presentation/onboarding.py
@@ -40,7 +40,8 @@ class InboxOnboardingStep(models.TextChoices):
class InboxOnboardingVariant(models.TextChoices):
CONTROL = "control", "Control"
- TEST = "test", "Focused steps"
+ TEST_UI = "test-ui", "Focused steps"
+ TEST_GITHUB = "test-github", "Activate and explore"
class InboxOnboardingExposureSerializer(serializers.Serializer):
@@ -89,8 +90,25 @@ class InboxOnboardingDraftSerializer(serializers.Serializer):
return suggestions
+class InboxOnboardingJobStatus(models.TextChoices):
+ PENDING = "pending", "Pending"
+ STARTED = "started", "Started"
+ SKIPPED = "skipped", "Unavailable"
+ FAILED = "failed", "Failed"
+
+
+class InboxOnboardingJobsSerializer(serializers.Serializer):
+ scout = serializers.ChoiceField(
+ choices=InboxOnboardingJobStatus.choices, help_text="Dispatch status of the first general scout run."
+ )
+ recommendations = serializers.ChoiceField(
+ choices=InboxOnboardingJobStatus.choices, help_text="Dispatch status of personalized scout recommendations."
+ )
+
+
@extend_schema_serializer(many=False)
class InboxOnboardingStateSerializer(serializers.Serializer):
+ jobs = InboxOnboardingJobsSerializer(required=False, help_text="Background work started by quick activation.")
draft = InboxOnboardingDraftSerializer(allow_null=True, help_text="Saved setup choices, without activating them.")
completed_at = serializers.DateTimeField(allow_null=True, help_text="When verified setup completed.")
variant = serializers.ChoiceField(
diff --git a/products/signals/backend/tasks.py b/products/signals/backend/tasks.py
index 161109608341..5ff82578c31a 100644
--- a/products/signals/backend/tasks.py
+++ b/products/signals/backend/tasks.py
@@ -8,7 +8,7 @@ from django.db.models import Q
from django.utils import timezone
import structlog
-from celery import shared_task
+from celery import Task, shared_task
from celery.exceptions import SoftTimeLimitExceeded
from slack_sdk.errors import SlackApiError
@@ -80,6 +80,16 @@ from products.tasks.backend.facade.repo_activity import RepositoryCommitActivity
logger = structlog.get_logger(__name__)
+@shared_task(bind=True, ignore_result=True, autoretry_for=(Exception,), retry_backoff=True, max_retries=5)
+@with_team_scope()
+def launch_inbox_onboarding_job(self: Task, team_id: int, job: str) -> None:
+ from products.signals.backend.onboarding_activation import (
+ InboxOnboardingActivation, # noqa: PLC0415 - keep the Temporal graph off task discovery
+ )
+
+ InboxOnboardingActivation(team_id).run(job, final_attempt=self.request.retries >= self.max_retries)
+
+
@shared_task(ignore_result=True, autoretry_for=(Exception,), retry_backoff=True, max_retries=5)
@with_team_scope()
def reconcile_inbox_onboarding(team_id: int, failed_checks: int = 0) -> None:
diff --git a/products/signals/backend/temporal/agentic/scout_scheduler.py b/products/signals/backend/temporal/agentic/scout_scheduler.py
index 30c16632d403..37c241b943f7 100644
--- a/products/signals/backend/temporal/agentic/scout_scheduler.py
+++ b/products/signals/backend/temporal/agentic/scout_scheduler.py
@@ -566,6 +566,23 @@ def start_manual_signals_scout_run(
)
+@async_to_sync
+async def start_onboarding_signals_scout_run(client: Client, *, team_id: int, skill_name: str) -> str:
+ workflow_id = _off_schedule_run_workflow_id("signals-scout-onboarding", team_id, skill_name)
+ try:
+ await client.start_workflow(
+ RunSignalsScoutWorkflow.run,
+ RunSignalsScoutInput(team_id=team_id, skill_name=skill_name, triggered_by=TRIGGERED_BY_MANUAL),
+ id=workflow_id,
+ task_queue=settings.VIDEO_EXPORT_TASK_QUEUE,
+ id_reuse_policy=WorkflowIDReusePolicy.REJECT_DUPLICATE,
+ id_conflict_policy=WorkflowIDConflictPolicy.USE_EXISTING,
+ )
+ except WorkflowAlreadyStartedError:
+ pass
+ return workflow_id
+
+
def trial_run_workflow_id(team_id: int, launch_id: str) -> str:
return f"signals-scout-trial-{team_id}-{launch_id}"
diff --git a/products/signals/backend/temporal/agentic/scout_suggestions.py b/products/signals/backend/temporal/agentic/scout_suggestions.py
index a03cac074fe4..69449b96a104 100644
--- a/products/signals/backend/temporal/agentic/scout_suggestions.py
+++ b/products/signals/backend/temporal/agentic/scout_suggestions.py
@@ -340,7 +340,9 @@ def manual_suggestions_workflow_id(team_id: int) -> str:
@async_to_sync
-async def start_manual_scout_suggestions_run(client: Client, *, team_id: int, acting_user_id: int | None = None) -> str:
+async def start_manual_scout_suggestions_run(
+ client: Client, *, team_id: int, acting_user_id: int | None = None, onboarding: bool = False
+) -> str:
"""Dispatch one on-demand suggestion scan for a team, bypassing the planner and its cap.
Single-flight at the Temporal server: `ALLOW_DUPLICATE` lets the stable id be reused once the
@@ -349,21 +351,27 @@ async def start_manual_scout_suggestions_run(client: Client, *, team_id: int, ac
planner state, so the coordinator treats it as this window's refresh instead of dispatching a
second scan for the same team on its next tick.
"""
- workflow_id = manual_suggestions_workflow_id(team_id)
+ workflow_id = f"scout-suggestions-onboarding-{team_id}" if onboarding else manual_suggestions_workflow_id(team_id)
settings = read_suggestion_settings()
- await client.start_workflow(
- RunScoutSuggestionsWorkflow.run,
- RunScoutSuggestionsInput(
- team_id=team_id,
- settings_json=_settings_to_json(settings),
- triggered_by="manual",
- acting_user_id=acting_user_id,
- ),
- id=workflow_id,
- task_queue=django_settings.VIDEO_EXPORT_TASK_QUEUE,
- id_reuse_policy=WorkflowIDReusePolicy.ALLOW_DUPLICATE,
- id_conflict_policy=WorkflowIDConflictPolicy.FAIL,
- )
+ try:
+ await client.start_workflow(
+ RunScoutSuggestionsWorkflow.run,
+ RunScoutSuggestionsInput(
+ team_id=team_id,
+ settings_json=_settings_to_json(settings),
+ triggered_by="manual",
+ acting_user_id=acting_user_id,
+ ),
+ id=workflow_id,
+ task_queue=django_settings.VIDEO_EXPORT_TASK_QUEUE,
+ id_reuse_policy=WorkflowIDReusePolicy.REJECT_DUPLICATE
+ if onboarding
+ else WorkflowIDReusePolicy.ALLOW_DUPLICATE,
+ id_conflict_policy=WorkflowIDConflictPolicy.USE_EXISTING if onboarding else WorkflowIDConflictPolicy.FAIL,
+ )
+ except WorkflowAlreadyStartedError:
+ if not onboarding:
+ raise
try:
await database_sync_to_async(stamp_requested, thread_sensitive=False)([team_id])
except Exception:
diff --git a/products/signals/backend/test/test_inbox_onboarding.py b/products/signals/backend/test/test_inbox_onboarding.py
index 5e8e0aaced1e..52bb285aaa75 100644
--- a/products/signals/backend/test/test_inbox_onboarding.py
+++ b/products/signals/backend/test/test_inbox_onboarding.py
@@ -1,12 +1,15 @@
from datetime import timedelta
-from posthog.test.base import APIBaseTest
-from unittest.mock import patch
+from posthog.test.base import APIBaseTest, BaseTest
+from unittest.mock import AsyncMock, MagicMock, patch
from django.utils import timezone
+from celery.exceptions import Retry
from parameterized import parameterized
from requests import Timeout
+from temporalio.common import WorkflowIDReusePolicy
+from temporalio.exceptions import WorkflowAlreadyStartedError
from posthog.egress.github.transport import GitHubRateLimitError
from posthog.egress.transport.transport import EgressBudgetExhausted
@@ -20,11 +23,17 @@ from posthog.models.team.team import Team
from posthog.models.utils import generate_random_token_personal, hash_key_value
from posthog.oauth_provenance import SANDBOX_OAUTH_APP_CLIENT_IDS
-from products.signals.backend.models import SignalScoutConfig, SignalSourceConfig, SignalTeamConfig
+from products.signals.backend.models import (
+ SignalScoutConfig,
+ SignalScoutSuggestionSet,
+ SignalSourceConfig,
+ SignalTeamConfig,
+)
+from products.signals.backend.onboarding_activation import InboxOnboardingActivation
from products.signals.backend.onboarding_completion import InboxOnboardingReconciler
from products.signals.backend.scout_harness.config_registry import register_missing_configs
from products.signals.backend.scout_harness.lazy_seed import seed_canonical_skills
-from products.signals.backend.tasks import reconcile_inbox_onboarding
+from products.signals.backend.tasks import launch_inbox_onboarding_job, reconcile_inbox_onboarding
class TestInboxOnboarding(APIBaseTest):
@@ -67,18 +76,32 @@ class TestInboxOnboarding(APIBaseTest):
assert self.source.enabled is False
assert SignalTeamConfig.objects.get(team=self.team).autostart_enabled is None
- def test_exposure_is_sticky_and_queued_once(self) -> None:
+ @parameterized.expand([("control",), ("test-ui",), ("test-github",)])
+ def test_exposure_is_sticky_and_queued_once(self, variant: str) -> None:
with (
patch("products.signals.backend.facade.onboarding.posthoganalytics.capture") as capture,
+ patch(
+ "products.signals.backend.onboarding_analytics.posthoganalytics.feature_enabled", return_value=True
+ ) as flag,
patch("products.signals.backend.tasks.reconcile_inbox_onboarding.delay") as reconcile,
self.captureOnCommitCallbacks(execute=True),
):
- first = self.client.post(f"{self.url}expose/", {"variant": "control"}, format="json")
- second = self.client.post(f"{self.url}expose/", {"variant": "test"}, format="json")
+ first = self.client.post(f"{self.url}expose/", {"variant": variant}, format="json")
+ second = self.client.post(
+ f"{self.url}expose/", {"variant": "test-ui" if variant == "control" else "control"}, format="json"
+ )
assert first.status_code == 200
- assert second.json()["variant"] == "control"
+ assert first.json()["variant"] == variant
+ assert second.json()["variant"] == variant
assert capture.call_count == 1
- reconcile.assert_called_once_with(self.team.id)
+ assert capture.call_args.kwargs["properties"]["variant"] == variant
+ assert capture.call_args.kwargs["properties"]["self_driving_ubp"] is True
+ assert flag.call_args.args == ("self-driving-ubp", str(self.user.distinct_id))
+ assert flag.call_args.kwargs["groups"]["organization"] == str(self.organization.id)
+ if variant == "control":
+ reconcile.assert_called_once_with(self.team.id)
+ else:
+ reconcile.assert_not_called()
def test_control_completion_is_verified_without_a_browser_and_only_once(self) -> None:
config = SignalTeamConfig.objects.get(team=self.team)
@@ -87,6 +110,10 @@ class TestInboxOnboarding(APIBaseTest):
with (
patch.object(InboxOnboardingReconciler, "has_repository", return_value=False) as repository,
patch("products.signals.backend.onboarding_completion.ph_scoped_capture") as capture,
+ patch(
+ "products.signals.backend.onboarding_analytics.posthoganalytics.feature_enabled",
+ side_effect=RuntimeError("Unavailable"),
+ ),
self.captureOnCommitCallbacks(execute=True),
):
assert InboxOnboardingReconciler(self.team.id).run() is True
@@ -99,6 +126,8 @@ class TestInboxOnboarding(APIBaseTest):
assert config.onboarding["completed_at"]
capture.assert_called_once()
assert capture.return_value.__enter__.return_value.call_args.kwargs["properties"]["variant"] == "control"
+ assert capture.return_value.__enter__.return_value.call_args.kwargs["properties"]["self_driving_ubp"] is None
+ assert capture.return_value.__enter__.return_value.call_args.kwargs["properties"]["setup_mode"] == "legacy"
@parameterized.expand([(False,), (True,)])
def test_control_reconciliation_waits_for_manual_activation(self, draft_saved_during_check: bool) -> None:
@@ -134,8 +163,21 @@ class TestInboxOnboarding(APIBaseTest):
config.refresh_from_db()
assert not config.onboarding.get("completed_at")
- @parameterized.expand([("github",), ("source",), ("disabled_source",), ("scanner",), ("empty",)])
+ @parameterized.expand(
+ [
+ ("github",),
+ ("source",),
+ ("disabled_source",),
+ ("scanner",),
+ ("empty",),
+ ("quick_scout",),
+ ]
+ )
def test_incomplete_setup_never_converts(self, missing: str) -> None:
+ if missing.startswith("quick_"):
+ config = SignalTeamConfig.objects.get(team=self.team)
+ config.onboarding = {"variant": "test-github"}
+ config.save()
if missing == "source":
self.source.enabled = False
self.source.save()
@@ -155,8 +197,14 @@ class TestInboxOnboarding(APIBaseTest):
assert response.status_code == 400, response.json()
assert not (SignalTeamConfig.objects.get(team=self.team).onboarding or {}).get("completed_at")
- @parameterized.expand([(None,), ("control",), ("test",)])
- def test_completion_is_durable_and_retry_safe(self, variant: str | None) -> None:
+ @parameterized.expand(
+ [(None, False), ("control", False), ("test-ui", False), ("test-github", False), ("test-github", True)]
+ )
+ def test_completion_is_durable_and_retry_safe(self, variant: str | None, automatic_implementation: bool) -> None:
+ self.draft["automatic_implementation"] = automatic_implementation
+ if variant == "test-github":
+ self.draft["suggestions"] = [self.suggestion]
+ SignalScoutConfig.objects.create(team=self.team, skill_name=self.scout_skill_name, enabled=True, emit=True)
config = SignalTeamConfig.objects.get(team=self.team)
config.onboarding = {"variant": variant}
config.save()
@@ -166,6 +214,11 @@ class TestInboxOnboarding(APIBaseTest):
return_value=object(),
),
patch("products.signals.backend.facade.onboarding.posthoganalytics.capture") as capture,
+ patch(
+ "products.signals.backend.onboarding_analytics.posthoganalytics.feature_enabled",
+ return_value=not automatic_implementation,
+ ),
+ patch("products.signals.backend.tasks.launch_inbox_onboarding_job.delay") as launch,
self.captureOnCommitCallbacks(execute=True),
):
first = self.client.post(f"{self.url}complete/", self.draft, format="json")
@@ -173,11 +226,33 @@ class TestInboxOnboarding(APIBaseTest):
assert first.status_code == 200, first.json()
assert first.json() == second.json()
config = SignalTeamConfig.objects.get(team=self.team)
- assert config.autostart_enabled is False
- assert config.default_autostart_priority == "P1"
assert config.onboarding is not None
+ if variant == "test-github":
+ assert config.onboarding["jobs"] == {"scout": "pending", "recommendations": "pending"}
+ assert {call.args for call in launch.call_args_list} == {
+ (self.team.id, "scout"),
+ (self.team.id, "recommendations"),
+ }
+ else:
+ launch.assert_not_called()
+ assert config.autostart_enabled is automatic_implementation
+ assert config.default_autostart_priority == "P1"
assert config.onboarding["activated_by"] == self.user.id
assert capture.call_args.kwargs["properties"]["variant"] == variant
+ assert capture.call_args.kwargs["properties"] == {
+ "variant": variant,
+ "project_id": self.team.id,
+ "flow_version": "ui-first-v1",
+ "inbox_client": "cloud",
+ "setup_mode": "quick" if variant == "test-github" else "guided",
+ "self_driving_ubp": not automatic_implementation,
+ "automatic_implementation": automatic_implementation,
+ "implementation_priority": "P1",
+ "enabled_source_products": ["error_tracking", "signals_scout"]
+ if variant == "test-github"
+ else ["error_tracking"],
+ "scout_count": 1 if variant == "test-github" else 0,
+ }
assert (
len(
[
@@ -189,6 +264,24 @@ class TestInboxOnboarding(APIBaseTest):
== 1
)
+ def test_completed_quick_activation_checks_scout_write_access_before_retrying_jobs(self) -> None:
+ self.draft["suggestions"] = [self.suggestion]
+ config = SignalTeamConfig.objects.get(team=self.team)
+ config.onboarding = {
+ "variant": "test-github",
+ "completed_at": timezone.now().isoformat(),
+ "draft": self.draft,
+ "jobs": {"scout": "failed", "recommendations": "failed"},
+ }
+ config.save()
+ raw = self.create_personal_api_key_with_scopes(["task:write", "signal_scout:read"])
+ self.client.logout()
+ self.client.credentials(HTTP_AUTHORIZATION=f"Bearer {raw}")
+ with patch("products.signals.backend.tasks.launch_inbox_onboarding_job.delay") as launch:
+ response = self.client.post(f"{self.url}complete/", self.draft, format="json")
+ assert response.status_code == 403, response.json()
+ launch.assert_not_called()
+
@parameterized.expand([(None, False), (True, False), (False, False), (None, True), (False, True)])
def test_scout_only_completion_respects_source_gate(self, enabled: bool | None, control: bool) -> None:
self.source.enabled = False
@@ -470,6 +563,41 @@ class TestInboxOnboarding(APIBaseTest):
config.refresh_from_db()
assert config.onboarding["draft"][field] == original
+ @parameterized.expand(
+ [
+ (False, -60, -30, "started"),
+ (False, 1, 2, "failed"),
+ (False, 1, -1, "started"),
+ (True, 1, 2, "failed"),
+ ]
+ )
+ def test_activation_state_reports_only_current_recommendation_failure(
+ self, child_project: bool, requested_offset: int, finished_offset: int, expected_status: str
+ ) -> None:
+ team = (
+ Team.objects.create(organization=self.organization, parent_team=self.team) if child_project else self.team
+ )
+ activated_at = timezone.now()
+ config, _ = SignalTeamConfig.objects.get_or_create(team=team)
+ config.onboarding = {
+ "variant": "test-github",
+ "completed_at": activated_at.isoformat(),
+ "jobs": {"scout": "started", "recommendations": "started"},
+ }
+ config.save()
+ SignalScoutSuggestionSet.objects.create(
+ team=self.team,
+ status=SignalScoutSuggestionSet.Status.FAILED,
+ generated_at=activated_at - timedelta(days=1),
+ last_requested_at=activated_at + timedelta(seconds=requested_offset),
+ last_completed_at=activated_at + timedelta(seconds=finished_offset),
+ )
+ response = self.client.get(f"/api/projects/{team.id}/signals/onboarding/")
+ assert response.status_code == 200, response.content
+ assert response.json()["jobs"] == {"scout": "started", "recommendations": expected_status}
+ config.refresh_from_db()
+ assert config.onboarding["jobs"]["recommendations"] == "started"
+
def test_background_polling_honors_github_retry_hint(self) -> None:
config = SignalTeamConfig.objects.get(team=self.team)
config.onboarding = {"variant": "control", "exposed_at": timezone.now().isoformat()}
@@ -483,3 +611,97 @@ class TestInboxOnboarding(APIBaseTest):
):
reconcile_inbox_onboarding.run(self.team.id, failed_checks=6)
assert schedule.call_args.kwargs["countdown"] == 3600
+
+
+class TestInboxOnboardingActivation(BaseTest):
+ @parameterized.expand([("scout", 0), ("scout", 5), ("recommendations", 0), ("recommendations", 5)])
+ def test_dispatch_retries_use_one_workflow_and_preserve_completed_jobs(self, job: str, retry_count: int) -> None:
+ self.organization.is_ai_data_processing_approved = True
+ self.organization.save()
+ config = SignalTeamConfig.objects.create(
+ team=self.team,
+ onboarding={
+ "variant": "test-github",
+ "completed_at": timezone.now().isoformat(),
+ "activated_by": self.user.pk,
+ "jobs": {"scout": "pending", "recommendations": "pending"},
+ },
+ )
+ SignalScoutConfig.objects.create(team=self.team, skill_name="signals-scout-general", enabled=True, emit=True)
+ client = MagicMock()
+ client.start_workflow = AsyncMock()
+ with (
+ patch("products.signals.backend.onboarding_activation.sync_connect", return_value=client),
+ patch("products.signals.backend.onboarding_activation.ph_scoped_capture") as capture,
+ patch("products.signals.backend.onboarding_analytics.posthoganalytics.feature_enabled", return_value=True),
+ self.captureOnCommitCallbacks(execute=True),
+ patch("products.signals.backend.temporal.agentic.scout_suggestions.stamp_requested"),
+ patch(
+ "posthoganalytics.get_feature_flag_payload",
+ return_value={"enabled": True, "guaranteed_team_ids": [self.team.id]},
+ ),
+ ):
+ client.start_workflow.side_effect = RuntimeError("Temporarily unavailable")
+ launch_inbox_onboarding_job.push_request(retries=retry_count)
+ try:
+ with patch.object(launch_inbox_onboarding_job, "retry", side_effect=Retry()), self.assertRaises(Retry):
+ launch_inbox_onboarding_job.run(self.team.id, job)
+ finally:
+ launch_inbox_onboarding_job.pop_request()
+ config.refresh_from_db()
+ assert config.onboarding is not None
+ assert config.onboarding["jobs"][job] == ("failed" if retry_count == 5 else "pending")
+ client.start_workflow.reset_mock(side_effect=True)
+ activation = InboxOnboardingActivation(self.team.id)
+ activation.run(job)
+ activation.run(job)
+ client.start_workflow.assert_awaited_once()
+ dispatch = client.start_workflow.call_args.kwargs
+ assert dispatch["id_reuse_policy"] == WorkflowIDReusePolicy.REJECT_DUPLICATE
+ config.refresh_from_db()
+ assert config.onboarding is not None
+ assert config.onboarding["jobs"][job] == "started"
+ config.onboarding["jobs"][job] = "pending"
+ config.save()
+ client.start_workflow.side_effect = WorkflowAlreadyStartedError(dispatch["id"], "workflow")
+ activation.run(job)
+ config.refresh_from_db()
+ assert config.onboarding is not None
+ assert config.onboarding["jobs"][job] == "started"
+ assert client.start_workflow.call_args.kwargs["id"] == dispatch["id"]
+ events = capture.return_value.__enter__.return_value.call_args_list
+ assert [event.kwargs["properties"]["status"] for event in events] == (
+ ["failed", "started", "started"] if retry_count == 5 else ["started", "started"]
+ )
+ assert all(event.kwargs["event"] == "self-driving onboarding job status changed" for event in events)
+ assert all(event.kwargs["properties"]["job"] == job for event in events)
+ assert all(event.kwargs["properties"]["setup_mode"] == "quick" for event in events)
+
+ @parameterized.expand([("scout",), ("recommendations",)])
+ def test_no_background_work_without_ai_consent(self, job: str) -> None:
+ self.organization.is_ai_data_processing_approved = False
+ self.organization.save()
+ config = SignalTeamConfig.objects.create(
+ team=self.team,
+ onboarding={
+ "variant": "test-github",
+ "completed_at": timezone.now().isoformat(),
+ "jobs": {"scout": "pending", "recommendations": "pending"},
+ },
+ )
+ with (
+ patch("products.signals.backend.onboarding_activation.sync_connect") as connect,
+ patch("products.signals.backend.onboarding_activation.ph_scoped_capture") as capture,
+ patch("products.signals.backend.onboarding_analytics.posthoganalytics.feature_enabled", return_value=None),
+ self.captureOnCommitCallbacks(execute=True),
+ ):
+ InboxOnboardingActivation(self.team.id).run(job)
+ connect.assert_not_called()
+ config.refresh_from_db()
+ assert config.onboarding is not None
+ assert config.onboarding["jobs"][job] == "skipped"
+ capture.return_value.__enter__.return_value.assert_called_once()
+ assert (
+ capture.return_value.__enter__.return_value.call_args.kwargs["properties"]["reason"]
+ == "ai_consent_required"
+ )
diff --git a/products/signals/frontend/generated/api.schemas.ts b/products/signals/frontend/generated/api.schemas.ts
index a10d69874995..8ce593ec584f 100644
--- a/products/signals/frontend/generated/api.schemas.ts
+++ b/products/signals/frontend/generated/api.schemas.ts
@@ -141,6 +141,39 @@ export interface InboxSummaryApi {
people: InboxSummaryPersonApi[] | null
}
+/**
+ * * `pending` - Pending
+ * * `started` - Started
+ * * `skipped` - Unavailable
+ * * `failed` - Failed
+ */
+export type InboxOnboardingJobStatusEnumApi =
+ (typeof InboxOnboardingJobStatusEnumApi)[keyof typeof InboxOnboardingJobStatusEnumApi]
+
+export const InboxOnboardingJobStatusEnumApi = {
+ Pending: 'pending',
+ Started: 'started',
+ Skipped: 'skipped',
+ Failed: 'failed',
+} as const
+
+export interface InboxOnboardingJobsApi {
+ /** Dispatch status of the first general scout run.
+ *
+ * * `pending` - Pending
+ * * `started` - Started
+ * * `skipped` - Unavailable
+ * * `failed` - Failed */
+ scout: InboxOnboardingJobStatusEnumApi
+ /** Dispatch status of personalized scout recommendations.
+ *
+ * * `pending` - Pending
+ * * `started` - Started
+ * * `skipped` - Unavailable
+ * * `failed` - Failed */
+ recommendations: InboxOnboardingJobStatusEnumApi
+}
+
/**
* * `signals` - Signals
* * `scouts` - Scouts
@@ -495,17 +528,21 @@ export interface InboxOnboardingDraftApi {
/**
* * `control` - Control
- * * `test` - Focused steps
+ * * `test-ui` - Focused steps
+ * * `test-github` - Activate and explore
*/
export type InboxOnboardingVariantEnumApi =
(typeof InboxOnboardingVariantEnumApi)[keyof typeof InboxOnboardingVariantEnumApi]
export const InboxOnboardingVariantEnumApi = {
Control: 'control',
- Test: 'test',
+ TestUi: 'test-ui',
+ TestGithub: 'test-github',
} as const
export interface InboxOnboardingStateApi {
+ /** Background work started by quick activation. */
+ jobs?: InboxOnboardingJobsApi
/** Saved setup choices, without activating them. */
draft: InboxOnboardingDraftApi | null
/**
@@ -516,7 +553,8 @@ export interface InboxOnboardingStateApi {
/** Variant recorded at the first eligible impression.
*
* * `control` - Control
- * * `test` - Focused steps */
+ * * `test-ui` - Focused steps
+ * * `test-github` - Activate and explore */
variant: InboxOnboardingVariantEnumApi | null
}
@@ -524,7 +562,8 @@ export interface InboxOnboardingExposureApi {
/** Assigned experiment variant at the eligible Inbox impression.
*
* * `control` - Control
- * * `test` - Focused steps */
+ * * `test-ui` - Focused steps
+ * * `test-github` - Activate and explore */
variant: InboxOnboardingVariantEnumApi
}
diff --git a/products/signals/frontend/generated/api.zod.ts b/products/signals/frontend/generated/api.zod.ts
index 7a50a46a7138..7cb848b7356b 100644
--- a/products/signals/frontend/generated/api.zod.ts
+++ b/products/signals/frontend/generated/api.zod.ts
@@ -475,10 +475,10 @@ export const SignalsOnboardingCompleteCreateBody = /* @__PURE__ */ zod.object({
export const SignalsOnboardingExposeCreateBody = /* @__PURE__ */ zod.object({
variant: zod
- .enum(['control', 'test'])
- .describe('\* `control` - Control\n\* `test` - Focused steps')
+ .enum(['control', 'test-ui', 'test-github'])
+ .describe('\* `control` - Control\n\* `test-ui` - Focused steps\n\* `test-github` - Activate and explore')
.describe(
- 'Assigned experiment variant at the eligible Inbox impression.\n\n\* `control` - Control\n\* `test` - Focused steps'
+ 'Assigned experiment variant at the eligible Inbox impression.\n\n\* `control` - Control\n\* `test-ui` - Focused steps\n\* `test-github` - Activate and explore'
),
})
diff --git a/products/signals/frontend/inbox/InboxScene.stories.tsx b/products/signals/frontend/inbox/InboxScene.stories.tsx
index 5f3fab28ea3c..901a71f159bf 100644
--- a/products/signals/frontend/inbox/InboxScene.stories.tsx
+++ b/products/signals/frontend/inbox/InboxScene.stories.tsx
@@ -311,22 +311,22 @@ export const SelfDrivingOnboarding: Story = {
}
export const FocusedOnboarding: Story = {
- parameters: { featureFlags: { [FEATURE_FLAGS.INBOX_UI_ONBOARDING]: 'test' } },
+ parameters: { featureFlags: { [FEATURE_FLAGS.INBOX_UI_ONBOARDING]: 'test-ui' } },
decorators: [
...(Array.isArray(SelfDrivingOnboarding.decorators) ? SelfDrivingOnboarding.decorators : []),
mswDecorator({
get: {
- '/api/projects/:id/signals/onboarding/': { draft: null, completed_at: null, variant: 'test' },
+ '/api/projects/:id/signals/onboarding/': { draft: null, completed_at: null, variant: 'test-ui' },
},
post: {
- '/api/projects/:id/signals/onboarding/expose/': { draft: null, completed_at: null, variant: 'test' },
+ '/api/projects/:id/signals/onboarding/expose/': { draft: null, completed_at: null, variant: 'test-ui' },
},
}),
],
}
export const FocusedOnboardingComplete: Story = {
- parameters: { featureFlags: { [FEATURE_FLAGS.INBOX_UI_ONBOARDING]: 'test' } },
+ parameters: { featureFlags: { [FEATURE_FLAGS.INBOX_UI_ONBOARDING]: 'test-ui' } },
decorators: [
...(Array.isArray(Empty.decorators) ? Empty.decorators : []),
mswDecorator({
@@ -342,7 +342,7 @@ export const FocusedOnboardingComplete: Story = {
implementation_priority: 'P1',
},
completed_at: '2026-06-11T10:00:00Z',
- variant: 'test',
+ variant: 'test-ui',
},
},
}),
diff --git a/products/signals/frontend/inbox/components/config/scouts/ScoutSuggestionCard.tsx b/products/signals/frontend/inbox/components/config/scouts/ScoutSuggestionCard.tsx
index efb8b7c2a16e..608cc4004000 100644
--- a/products/signals/frontend/inbox/components/config/scouts/ScoutSuggestionCard.tsx
+++ b/products/signals/frontend/inbox/components/config/scouts/ScoutSuggestionCard.tsx
@@ -20,8 +20,7 @@ export interface ScoutSuggestionCardProps {
}
/**
- * One suggested scout as a row: what it would watch, why it was picked for this project, and the
- * three ways to act on it. The row carries the motivation only, because the create form already
+ * The row carries the motivation only, because the create form already
* holds the draft, the schedule and the output setting, and is where editing happens. Pressing the
* body opens that form, so a person reads the offer before anything is written.
*/
@@ -54,7 +53,8 @@ export function ScoutSuggestionCard({ item, surface }: ScoutSuggestionCardProps)
return (
<div
className={cn(
- 'flex flex-col gap-2 px-3 py-2.5 @2xl:flex-row @2xl:items-start @2xl:gap-4',
+ 'flex flex-col gap-2 py-2.5 @2xl:flex-row @2xl:items-start @2xl:gap-4',
+ surface === 'onboarding' ? 'px-0' : 'px-3',
!bodyDisabled && 'transition-colors hover:bg-surface-secondary'
)}
>
@@ -154,8 +154,7 @@ function SuggestionActions({ item, surface, isBusy }: ScoutSuggestionCardProps &
loading={isBusy}
disabledReason={isCanonical ? undefined : (creationDisabledReason ?? undefined)}
onClick={() => openCreateFromSuggestion(item, surface)}
- // One width for both labels, so the group starts at the same x on every row.
- className="min-w-24 justify-center"
+ className={surface === 'onboarding' ? undefined : 'min-w-24 justify-center'}
data-attr={isCanonical ? 'scout-suggestion-turn-on' : 'scout-suggestion-create'}
>
{reviewActionLabel(item)}
@@ -170,15 +169,17 @@ function SuggestionActions({ item, surface, isBusy }: ScoutSuggestionCardProps &
>
Refine with AI
</LemonButton>
- <LemonButton
- size="xsmall"
- icon={<IconX />}
- tooltip="Dismiss. This won't be suggested again."
- disabledReason={isBusy ? 'Working on this suggestion' : undefined}
- onClick={() => dismissSuggestion(item, surface)}
- aria-label={`Dismiss ${item.title}`}
- data-attr="scout-suggestion-dismiss"
- />
+ {surface !== 'onboarding' && (
+ <LemonButton
+ size="xsmall"
+ icon={<IconX />}
+ tooltip="Dismiss. This won't be suggested again."
+ disabledReason={isBusy ? 'Working on this suggestion' : undefined}
+ onClick={() => dismissSuggestion(item, surface)}
+ aria-label={`Dismiss ${item.title}`}
+ data-attr="scout-suggestion-dismiss"
+ />
+ )}
</div>
)
}
diff --git a/products/signals/frontend/inbox/components/onboarding/InboxActivationPanel.tsx b/products/signals/frontend/inbox/components/onboarding/InboxActivationPanel.tsx
new file mode 100644
index 000000000000..4c2a54c74fa9
--- /dev/null
+++ b/products/signals/frontend/inbox/components/onboarding/InboxActivationPanel.tsx
@@ -0,0 +1,142 @@
+import { useActions, useValues } from 'kea'
+import { useEffect, useState } from 'react'
+
+import { IconCheckCircle } from '@posthog/icons'
+import { LemonButton, LemonCard, LemonTag, Link, Spinner } from '@posthog/lemon-ui'
+
+import { urls } from 'scenes/urls'
+
+import { captureInboxPanelViewed } from '../../inboxAnalytics'
+import { inboxActivationLogic } from '../../logics/inboxActivationLogic'
+import { ScoutSuggestionCard } from '../config/scouts/ScoutSuggestionCard'
+import { ScoutSuggestionCreateHost } from '../config/scouts/ScoutSuggestionCreateHost'
+
+interface InboxActivationPanelProps {
+ hasReports?: boolean
+}
+
+export function InboxActivationPanel({ hasReports = false }: InboxActivationPanelProps): JSX.Element {
+ const { savedState, sourceNames, generalScout, suggestions, recommendationsReady, pollingExpired, currentTeamId } =
+ useValues(inboxActivationLogic)
+ const [expanded, setExpanded] = useState(false)
+ const { reportRecommendationsShown } = useActions(inboxActivationLogic)
+ useEffect(() => {
+ captureInboxPanelViewed({ panel: 'onboarding' })
+ }, [currentTeamId])
+ useEffect(() => {
+ if (suggestions.length > 0) {
+ reportRecommendationsShown()
+ }
+ }, [suggestions, reportRecommendationsShown])
+ const jobs = savedState?.jobs
+ return (
+ <LemonCard hoverEffect={false} className="@container flex flex-col gap-3" data-attr="inbox-activation-panel">
+ <div className="flex flex-wrap items-center justify-between gap-3">
+ <h3 className="m-0 flex items-center gap-2 text-base">
+ <IconCheckCircle className="text-success" />
+ Your setup is complete
+ </h3>
+ <LemonButton
+ type="secondary"
+ size="small"
+ onClick={() => setExpanded(!expanded)}
+ aria-expanded={expanded}
+ data-attr="inbox-activation-explore"
+ >
+ {expanded ? 'Show less' : 'Explore what’s enabled'}
+ </LemonButton>
+ </div>
+ {(!hasReports || expanded) && (
+ <>
+ <div className="flex flex-wrap gap-2">
+ {sourceNames.map((name) => (
+ <LemonTag key={name}>{name}</LemonTag>
+ ))}
+ {generalScout?.enabled && <LemonTag type="success">General scout</LemonTag>}
+ </div>
+ <p className="m-0 text-sm text-secondary">
+ Sources alert agents to issues as they appear, so they can investigate right away. Scouts
+ explore your code and all your data to uncover issues and connect patterns. Reports arrive with
+ evidence and next steps.
+ </p>
+ {!hasReports && generalScout?.enabled && (
+ <p className="m-0 text-sm" aria-live="polite">
+ {jobs?.scout === 'pending'
+ ? 'Preparing your first general scout run.'
+ : jobs?.scout === 'started'
+ ? 'Your first general scout run has been requested. You can leave this page while it works.'
+ : jobs?.scout === 'failed'
+ ? 'Your first run could not be started. Open the general scout to try running it.'
+ : jobs?.scout === 'skipped'
+ ? 'Your first run could not start under the current project settings or limits. Review your scout settings.'
+ : 'Your general scout will run on its schedule.'}
+ </p>
+ )}
+ </>
+ )}
+ {expanded && (
+ <div className="flex flex-wrap gap-2">
+ <LemonButton
+ type="secondary"
+ size="small"
+ to={urls.inbox('settings')}
+ data-attr="inbox-activation-sources"
+ >
+ Manage sources
+ </LemonButton>
+ <LemonButton
+ type="secondary"
+ size="small"
+ to={urls.inbox('scouts')}
+ data-attr="inbox-activation-scouts"
+ >
+ Add or manage scouts
+ </LemonButton>
+ <LemonButton
+ size="small"
+ to="https://posthog.com/docs/self-driving"
+ targetBlank
+ data-attr="inbox-activation-learn"
+ >
+ How it works
+ </LemonButton>
+ </div>
+ )}
+ {suggestions.length > 0 ? (
+ <section className="flex flex-col gap-2 border-t border-primary pt-3">
+ <h4 className="m-0">Recommended for your product</h4>
+ <p className="m-0 text-sm text-secondary">Choose what you’d like to investigate next.</p>
+ <div className="divide-y divide-primary">
+ {suggestions.map((item) => (
+ <ScoutSuggestionCard key={item.id} item={item} surface="onboarding" />
+ ))}
+ </div>
+ <ScoutSuggestionCreateHost surface="onboarding" />
+ </section>
+ ) : !pollingExpired &&
+ !recommendationsReady &&
+ (jobs?.recommendations === 'pending' || jobs?.recommendations === 'started') ? (
+ <div className="flex items-center gap-2 text-sm text-secondary">
+ <Spinner />
+ <span>Preparing scout recommendations. They’ll appear here when ready.</span>
+ </div>
+ ) : jobs?.recommendations === 'failed' || jobs?.recommendations === 'skipped' || pollingExpired ? (
+ <p className="m-0 text-sm text-secondary">
+ <span>
+ {pollingExpired
+ ? 'Recommendations are not available yet. '
+ : 'Recommendations could not be prepared. '}
+ </span>
+ <Link to={urls.inbox('scouts')}>Explore scouts</Link> to choose what to investigate.
+ </p>
+ ) : null}
+ <p className="m-0 border-t border-primary pt-3 text-xs text-secondary">
+ Create or configure scouts with PostHog AI, the PostHog Slack Bot, or an agent connected through{' '}
+ <Link to="https://posthog.com/docs/model-context-protocol" target="_blank">
+ MCP
+ </Link>
+ .
+ </p>
+ </LemonCard>
+ )
+}
diff --git a/products/signals/frontend/inbox/components/onboarding/InboxOnboardingEntry.tsx b/products/signals/frontend/inbox/components/onboarding/InboxOnboardingEntry.tsx
index 6647ae8abab6..702a463bc61e 100644
--- a/products/signals/frontend/inbox/components/onboarding/InboxOnboardingEntry.tsx
+++ b/products/signals/frontend/inbox/components/onboarding/InboxOnboardingEntry.tsx
@@ -18,15 +18,16 @@ export function InboxOnboardingEntry(): JSX.Element {
experimentVariant: variant,
usesFocusedSetup,
inProgress,
+ isQuickSetup,
savedState,
savedStateLoading,
error,
} = useValues(inboxSetupLogic)
useEffect(() => {
- if (variant === 'control' || variant === 'test') {
+ if (variant === 'control' || variant === 'test-ui' || variant === 'test-github') {
expose(variant)
}
- if (variant === 'test') {
+ if (variant === 'test-ui' || variant === 'test-github') {
captureInboxWelcomeViewed()
}
}, [variant, currentTeamId, expose])
@@ -49,5 +50,5 @@ export function InboxOnboardingEntry(): JSX.Element {
</div>
)
}
- return inProgress ? <InboxSetupFlow /> : <InboxSetupEmptyState />
+ return inProgress && !isQuickSetup ? <InboxSetupFlow /> : <InboxSetupEmptyState />
}
diff --git a/products/signals/frontend/inbox/components/onboarding/InboxQuickSetupAction.tsx b/products/signals/frontend/inbox/components/onboarding/InboxQuickSetupAction.tsx
new file mode 100644
index 000000000000..721e09b7d0d0
--- /dev/null
+++ b/products/signals/frontend/inbox/components/onboarding/InboxQuickSetupAction.tsx
@@ -0,0 +1,89 @@
+import { useActions, useValues } from 'kea'
+import { combineUrl } from 'kea-router'
+import { useEffect } from 'react'
+
+import { LemonBanner, LemonButton } from '@posthog/lemon-ui'
+
+import { RestrictionScope, useRestrictedArea } from 'lib/components/RestrictedArea'
+import { TeamMembershipLevel } from 'lib/constants'
+import { integrationsLogic } from 'lib/integrations/integrationsLogic'
+import { GithubIntegration } from 'scenes/integrations/components/GithubIntegration'
+import { IntegrationAccessRequest } from 'scenes/integrations/components/IntegrationAccessRequest'
+import { urls } from 'scenes/urls'
+
+import { inboxSetupLogic } from '../../logics/inboxSetupLogic'
+import { useScoutCreateDisabledReason } from '../config/scouts/ScoutCreateModalHost'
+
+export function InboxQuickSetupAction(): JSX.Element {
+ const { startSetup, connectGithub, activateQuickSetup, resumeQuickSetup, retry } = useActions(inboxSetupLogic)
+ const { hasGithubIntegration, quickSetupReady, saving, error, shouldResumeQuickSetup, failedOperation } =
+ useValues(inboxSetupLogic)
+ const { integrations, integrationsLoading } = useValues(integrationsLogic)
+ const scoutDisabledReason = useScoutCreateDisabledReason()
+ const restrictionReason = useRestrictedArea({
+ scope: RestrictionScope.Project,
+ minimumAccessLevel: TeamMembershipLevel.Member,
+ })
+
+ useEffect(() => startSetup(), [startSetup])
+ useEffect(() => {
+ if (!restrictionReason && !scoutDisabledReason) {
+ resumeQuickSetup()
+ }
+ }, [shouldResumeQuickSetup, resumeQuickSetup, restrictionReason, scoutDisabledReason])
+
+ return (
+ <div className="flex w-full flex-col items-start gap-3">
+ {hasGithubIntegration ? (
+ <LemonButton
+ type="primary"
+ status="alt"
+ onClick={() => activateQuickSetup()}
+ loading={saving}
+ disabledReason={
+ restrictionReason ||
+ scoutDisabledReason ||
+ (!quickSetupReady ? 'Loading your available sources and general scout' : undefined)
+ }
+ data-attr="inbox-quick-activate"
+ >
+ Activate Self-Driving
+ </LemonButton>
+ ) : restrictionReason ? (
+ <IntegrationAccessRequest kind="github" name="GitHub" />
+ ) : (
+ <GithubIntegration
+ next={combineUrl(urls.inbox(), { onboarding_step: 'quick' }).url}
+ connectSurface="inbox_welcome"
+ onAuthorize={connectGithub}
+ authorizing={saving || (integrationsLoading && integrations === null)}
+ connectText="Connect GitHub"
+ emphasizeConnect
+ showPersonalConnectionHelp={false}
+ showManageButton={false}
+ integrationSuffix={<></>}
+ connectDescription=""
+ />
+ )}
+ {error && (
+ <LemonBanner type="error">
+ {error}
+ <LemonButton
+ size="small"
+ onClick={
+ failedOperation === 'scouts' || failedOperation === 'sources'
+ ? retry
+ : quickSetupReady
+ ? () => activateQuickSetup('retry')
+ : startSetup
+ }
+ loading={saving}
+ disabledReason={restrictionReason || scoutDisabledReason}
+ >
+ Retry
+ </LemonButton>
+ </LemonBanner>
+ )}
+ </div>
+ )
+}
diff --git a/products/signals/frontend/inbox/components/onboarding/InboxSetupEmptyState.tsx b/products/signals/frontend/inbox/components/onboarding/InboxSetupEmptyState.tsx
index ea34f2503ecd..9fa3affd1e2f 100644
--- a/products/signals/frontend/inbox/components/onboarding/InboxSetupEmptyState.tsx
+++ b/products/signals/frontend/inbox/components/onboarding/InboxSetupEmptyState.tsx
@@ -1,4 +1,4 @@
-import { useActions } from 'kea'
+import { useActions, useValues } from 'kea'
import * as selfDrivingPng from '@posthog/brand/hoggies/png/self-driving'
import { IconArrowRight } from '@posthog/icons'
@@ -12,12 +12,18 @@ import { IconSelfDriving } from 'lib/lemon-ui/icons'
import { ProductKey } from '~/queries/schema/schema-general'
import { inboxSetupLogic } from '../../logics/inboxSetupLogic'
+import { InboxQuickSetupAction } from './InboxQuickSetupAction'
import { InboxReportPreview } from './InboxReportPreview'
const HedgehogSelfDriving = pngHoggie(selfDrivingPng)
function SetUpSelfDrivingAction(): JSX.Element {
const { continueFromWelcome } = useActions(inboxSetupLogic)
+ const { isQuickSetup } = useValues(inboxSetupLogic)
+
+ if (isQuickSetup) {
+ return <InboxQuickSetupAction />
+ }
return (
<LemonButton
@@ -51,6 +57,7 @@ const INBOX_SETUP_EMPTY_STATE: ProductEmptyStateConfig = {
PrimaryAction: SetUpSelfDrivingAction,
docsUrl: 'https://posthog.com/docs/self-driving',
previewLabel: 'Example report',
+ previewClassName: 'w-full max-w-120 justify-self-center',
Preview: InboxReportPreview,
// An inbox that isn't set up is an empty list, so skipping would reveal nothing.
skippable: false,
diff --git a/products/signals/frontend/inbox/components/onboarding/InboxSetupFlow.stories.tsx b/products/signals/frontend/inbox/components/onboarding/InboxSetupFlow.stories.tsx
index 3caf09d0ebc4..13a1c35a3dce 100644
--- a/products/signals/frontend/inbox/components/onboarding/InboxSetupFlow.stories.tsx
+++ b/products/signals/frontend/inbox/components/onboarding/InboxSetupFlow.stories.tsx
@@ -1,6 +1,7 @@
import { MOCK_DEFAULT_TEAM } from 'lib/api.mock'
import type { Meta, StoryObj } from '@storybook/react'
+import { useValues } from 'kea'
import { FEATURE_FLAGS, TeamMembershipLevel } from 'lib/constants'
@@ -8,6 +9,8 @@ import { mswDecorator } from '~/mocks/browser'
import type { InboxOnboardingDraftApi } from '../../../generated/api.schemas'
import { mockScoutSuggestionSet, mockScoutConfigs } from '../../__mocks__/scoutConfigs'
+import { inboxSetupLogic } from '../../logics/inboxSetupLogic'
+import { InboxActivationPanel } from './InboxActivationPanel'
import { InboxOnboardingBanner } from './InboxOnboardingBanner'
import { InboxOnboardingEntry } from './InboxOnboardingEntry'
import { InboxSetupFlow } from './InboxSetupFlow'
@@ -66,7 +69,11 @@ const meta: Meta<typeof InboxSetupFlow> = {
parameters: {
layout: 'fullscreen',
mockDate: '2026-10-14',
- featureFlags: { [FEATURE_FLAGS.INBOX_UI_ONBOARDING]: 'test', [FEATURE_FLAGS.INBOX_REDESIGN]: true },
+ featureFlags: {
+ [FEATURE_FLAGS.INBOX_UI_ONBOARDING]: 'test-ui',
+ [FEATURE_FLAGS.INBOX_REDESIGN]: true,
+ [FEATURE_FLAGS.SELF_DRIVING_UBP]: true,
+ },
},
decorators: [
(Story) => (
@@ -95,7 +102,7 @@ const meta: Meta<typeof InboxSetupFlow> = {
deprecatedVersions: [],
},
},
- '/api/projects/:id/signals/onboarding/': { draft, completed_at: null, variant: 'test' },
+ '/api/projects/:id/signals/onboarding/': { draft, completed_at: null, variant: 'test-ui' },
'/api/projects/:id/signals/source_configs/': { results: [], next: null, count: 0 },
'/api/projects/:id/event_definitions/': {
results: [{ name: '$exception', last_seen_at: '2026-01-01T00:00:00Z' }],
@@ -131,7 +138,7 @@ const meta: Meta<typeof InboxSetupFlow> = {
'/api/projects/:id/signals/scout/configs/sync/': [],
'/api/projects/:id/signals/onboarding/': async ({ request }) => [
200,
- { draft: await request.json(), completed_at: null, variant: 'test' },
+ { draft: await request.json(), completed_at: null, variant: 'test-ui' },
],
},
}),
@@ -159,14 +166,14 @@ export const Scouts: Story = {
'/api/projects/:id/signals/onboarding/': {
draft: { ...draft, step: 'scouts' },
completed_at: null,
- variant: 'test',
+ variant: 'test-ui',
},
},
post: {
'/api/projects/:id/signals/onboarding/expose/': {
draft: { ...draft, step: 'scouts' },
completed_at: null,
- variant: 'test',
+ variant: 'test-ui',
},
},
}),
@@ -179,19 +186,30 @@ export const Github: Story = {
'/api/projects/:id/signals/onboarding/': {
draft: { ...draft, step: 'github' },
completed_at: null,
- variant: 'test',
+ variant: 'test-ui',
},
},
}),
],
}
+export const GithubWithoutAutomaticImplementation: Story = {
+ ...Github,
+ parameters: {
+ featureFlags: {
+ [FEATURE_FLAGS.INBOX_UI_ONBOARDING]: 'test-ui',
+ [FEATURE_FLAGS.INBOX_REDESIGN]: true,
+ [FEATURE_FLAGS.SELF_DRIVING_UBP]: false,
+ },
+ },
+}
+
export const NoProductsEnabled: Story = {
decorators: [
projectMocks(false),
mswDecorator({
get: {
- '/api/projects/:id/signals/onboarding/': { draft: null, completed_at: null, variant: 'test' },
+ '/api/projects/:id/signals/onboarding/': { draft: null, completed_at: null, variant: 'test-ui' },
'/api/projects/:id/event_definitions/': { results: [], next: null, count: 0 },
'/api/projects/:id/vision/scanners/': { results: [], next: null, count: 0 },
'/api/projects/:id/signals/scout/configs/': [
@@ -218,7 +236,7 @@ export const BuiltInScouts: Story = {
'/api/projects/:id/signals/onboarding/': {
draft: { ...draft, step: 'scouts' },
completed_at: null,
- variant: 'test',
+ variant: 'test-ui',
},
'/api/projects/:id/signals/scout/suggestions/': mockScoutSuggestionSet({
status: 'low_activity',
@@ -255,7 +273,7 @@ export const GithubAlreadyConnected: Story = {
'/api/projects/:id/signals/onboarding/': {
draft: { ...draft, step: 'github' },
completed_at: null,
- variant: 'test',
+ variant: 'test-ui',
},
'/api/projects/:id/integrations/': {
results: [
@@ -289,7 +307,7 @@ export const GithubAccessRequired: Story = {
'/api/projects/:id/signals/onboarding/': {
draft: { ...draft, step: 'github' },
completed_at: null,
- variant: 'test',
+ variant: 'test-ui',
},
},
post: { '/api/projects/:id/integrations/request_access/': {} },
@@ -301,9 +319,9 @@ export const TreatmentEntry = {
render: () => <InboxOnboardingEntry />,
decorators: [
mswDecorator({
- get: { '/api/projects/:id/signals/onboarding/': { draft: null, completed_at: null, variant: 'test' } },
+ get: { '/api/projects/:id/signals/onboarding/': { draft: null, completed_at: null, variant: 'test-ui' } },
post: {
- '/api/projects/:id/signals/onboarding/expose/': { draft: null, completed_at: null, variant: 'test' },
+ '/api/projects/:id/signals/onboarding/expose/': { draft: null, completed_at: null, variant: 'test-ui' },
},
}),
],
@@ -343,3 +361,163 @@ export const ManualEntry: Story = {
export const TreatmentReminder: Story = {
render: () => <InboxOnboardingBanner />,
}
+
+let quickActivationCompleted = false
+
+function QuickActivationPreview(): JSX.Element {
+ const { completed } = useValues(inboxSetupLogic)
+ return completed ? (
+ <div className="mx-auto max-w-4xl p-6">
+ <InboxActivationPanel />
+ </div>
+ ) : (
+ <InboxOnboardingEntry />
+ )
+}
+
+const quickGeneralScout = {
+ ...mockScoutConfigs[0],
+ skill_name: 'signals-scout-general',
+ enabled: false,
+ scout_origin: 'canonical',
+}
+
+export const QuickEntry: Story = {
+ parameters: {
+ featureFlags: { [FEATURE_FLAGS.INBOX_UI_ONBOARDING]: 'test-github', [FEATURE_FLAGS.INBOX_REDESIGN]: true },
+ },
+ render: () => <QuickActivationPreview />,
+ decorators: [
+ mswDecorator({
+ get: {
+ '/api/projects/:id/signals/onboarding/': { draft: null, completed_at: null, variant: 'test-github' },
+ '/api/projects/:id/signals/scout/configs/': [quickGeneralScout],
+ '/api/projects/:id/signals/scout/suggestions/': {
+ status: 'empty',
+ generated_at: null,
+ model: '',
+ fleet_snapshot: [],
+ items: [],
+ },
+ },
+ post: {
+ '/api/projects/:id/signals/onboarding/expose/': {
+ draft: null,
+ completed_at: null,
+ variant: 'test-github',
+ },
+ '/api/projects/:id/signals/scout/configs/sync/': [quickGeneralScout],
+ },
+ }),
+ ],
+}
+
+export const QuickConnected: Story = {
+ ...QuickEntry,
+ decorators: [
+ mswDecorator({
+ get: {
+ '/api/projects/:id/signals/onboarding/': () => ({
+ draft: null,
+ completed_at: quickActivationCompleted ? '2026-10-14T00:00:00Z' : null,
+ variant: 'test-github',
+ ...(quickActivationCompleted ? { jobs: { scout: 'started', recommendations: 'started' } } : {}),
+ }),
+ '/api/projects/:id/signals/scout/configs/': () => [
+ { ...quickGeneralScout, enabled: quickActivationCompleted, emit: true },
+ ],
+ '/api/projects/:id/signals/source_configs/': () => ({
+ results: quickActivationCompleted
+ ? [
+ {
+ id: 'source',
+ source_product: 'error_tracking',
+ source_type: 'issue_created',
+ enabled: true,
+ },
+ ]
+ : [],
+ next: null,
+ count: quickActivationCompleted ? 1 : 0,
+ }),
+ '/api/projects/:id/integrations/': {
+ results: [
+ {
+ id: 1,
+ kind: 'github',
+ config: {},
+ display_name: 'example',
+ created_at: '2026-10-14',
+ icon_url: '',
+ },
+ ],
+ next: null,
+ count: 1,
+ },
+ },
+ post: {
+ '/api/projects/:id/signals/onboarding/expose/': {
+ draft: null,
+ completed_at: null,
+ variant: 'test-github',
+ },
+ '/api/projects/:id/signals/scout/configs/sync/': [quickGeneralScout],
+ '/api/projects/:id/signals/onboarding/': async ({ request }) => [
+ 200,
+ { draft: await request.json(), completed_at: null, variant: 'test-github' },
+ ],
+ '/api/projects/:id/signals/config/': {},
+ '/api/projects/:id/signals/source_configs/': async ({ request }) => [
+ 201,
+ { ...((await request.json()) as object), id: 'source' },
+ ],
+ '/api/projects/:id/signals/scout/configs/': { ...quickGeneralScout, enabled: true, emit: true },
+ '/api/projects/:id/signals/onboarding/complete/': async ({ request }) => {
+ quickActivationCompleted = true
+ return [
+ 200,
+ {
+ draft: await request.json(),
+ completed_at: '2026-10-14T00:00:00Z',
+ variant: 'test-github',
+ jobs: { scout: 'started', recommendations: 'started' },
+ },
+ ]
+ },
+ },
+ patch: { '/api/projects/:id/vision/scanners/:scanner/': {} },
+ }),
+ ],
+}
+
+export const QuickActivated: Story = {
+ parameters: QuickEntry.parameters,
+ render: () => (
+ <div className="mx-auto max-w-4xl p-6">
+ <InboxActivationPanel />
+ </div>
+ ),
+ decorators: [
+ mswDecorator({
+ get: {
+ '/api/projects/:id/signals/scout/suggestions/': mockScoutSuggestionSet({
+ generated_at: '2026-10-14T00:00:00Z',
+ }),
+ '/api/projects/:id/signals/onboarding/': {
+ draft,
+ completed_at: '2026-10-14T00:00:00Z',
+ variant: 'test-github',
+ jobs: { scout: 'started', recommendations: 'started' },
+ },
+ '/api/projects/:id/signals/scout/configs/': [{ ...quickGeneralScout, enabled: true, emit: true }],
+ '/api/projects/:id/signals/source_configs/': {
+ results: [
+ { id: 'source', source_product: 'error_tracking', source_type: 'issue_created', enabled: true },
+ ],
+ next: null,
+ count: 1,
+ },
+ },
+ }),
+ ],
+}
diff --git a/products/signals/frontend/inbox/components/onboarding/InboxSetupFlow.tsx b/products/signals/frontend/inbox/components/onboarding/InboxSetupFlow.tsx
index 41ff07f081f9..a27d7bd23920 100644
--- a/products/signals/frontend/inbox/components/onboarding/InboxSetupFlow.tsx
+++ b/products/signals/frontend/inbox/components/onboarding/InboxSetupFlow.tsx
@@ -15,13 +15,18 @@ import { InboxSetupScoutsStep } from './InboxSetupScoutsStep'
import { InboxSetupSourcesStep } from './InboxSetupSourcesStep'
export function InboxSetupFlow(): JSX.Element {
- const { draft, ready, saving, error, activationDisabledReason, isFinalStep, sourceSetupSource } =
+ const { draft, ready, saving, error, activationDisabledReason, isFinalStep, sourceSetupSource, currentTeamId } =
useValues(inboxSetupLogic)
- const { startSetup, goToStep, activate, retry } = useActions(inboxSetupLogic)
+ const { startSetup, goToStep, activate, retry, reportStepViewed } = useActions(inboxSetupLogic)
useMountedLogic(scoutSuggestionsLogic)
useEffect(() => {
startSetup()
}, [startSetup])
+ useEffect(() => {
+ if (ready) {
+ reportStepViewed()
+ }
+ }, [ready, draft.step, currentTeamId, reportStepViewed])
const isScoutsStep = draft.step === 'scouts'
return (
<div className={cn('@container w-full', isScoutsStep && 'h-full')}>
diff --git a/products/signals/frontend/inbox/components/onboarding/InboxSetupGithubStep.tsx b/products/signals/frontend/inbox/components/onboarding/InboxSetupGithubStep.tsx
index 4e972f08b3c8..09e472f7c0df 100644
--- a/products/signals/frontend/inbox/components/onboarding/InboxSetupGithubStep.tsx
+++ b/products/signals/frontend/inbox/components/onboarding/InboxSetupGithubStep.tsx
@@ -3,7 +3,8 @@ import { combineUrl } from 'kea-router'
import { GuidedWizardSection } from 'lib/components/GuidedWizard/GuidedWizardSection'
import { RestrictionScope, useRestrictedArea } from 'lib/components/RestrictedArea'
-import { TeamMembershipLevel } from 'lib/constants'
+import { FEATURE_FLAGS, TeamMembershipLevel } from 'lib/constants'
+import { featureFlagLogic } from 'lib/logic/featureFlagLogic'
import { GithubIntegration } from 'scenes/integrations/components/GithubIntegration'
import { IntegrationAccessRequest } from 'scenes/integrations/components/IntegrationAccessRequest'
import { urls } from 'scenes/urls'
@@ -13,6 +14,7 @@ import { InboxSetupImplementation } from './InboxSetupImplementation'
export function InboxSetupGithubStep(): JSX.Element {
const { hasGithubIntegration, saving } = useValues(inboxSetupLogic)
+ const { featureFlags } = useValues(featureFlagLogic)
const { connectGithub } = useActions(inboxSetupLogic)
const restrictionReason = useRestrictedArea({
scope: RestrictionScope.Project,
@@ -41,7 +43,7 @@ export function InboxSetupGithubStep(): JSX.Element {
/>
)}
</GuidedWizardSection>
- <InboxSetupImplementation />
+ {featureFlags[FEATURE_FLAGS.SELF_DRIVING_UBP] && <InboxSetupImplementation />}
</>
)
}
diff --git a/products/signals/frontend/inbox/components/tabs/ReportsTab.tsx b/products/signals/frontend/inbox/components/tabs/ReportsTab.tsx
index d95f6a5f8461..90b10029eef0 100644
--- a/products/signals/frontend/inbox/components/tabs/ReportsTab.tsx
+++ b/products/signals/frontend/inbox/components/tabs/ReportsTab.tsx
@@ -13,6 +13,7 @@ import { isRankingSortField } from '../../filterOptions'
import { captureInboxViewed } from '../../inboxAnalytics'
import { inboxSceneLogic } from '../../inboxSceneLogic'
import { inboxTaskKickoffLogic } from '../../inboxTaskKickoffLogic'
+import { inboxActivationVisibilityLogic } from '../../logics/inboxActivationVisibilityLogic'
import { inboxFiltersLogic, isDefaultStateFilter } from '../../logics/inboxFiltersLogic'
import type { InboxRankingSortField } from '../../logics/inboxFiltersLogic'
import { reportListLogic, sectionListLogicProps } from '../../logics/reportListLogic'
@@ -30,6 +31,7 @@ import { ReportCard } from '../cards/ReportCard'
import { ReportContextMenu } from '../cards/ReportContextMenu'
import { InboxWaitingForWork } from '../emptyState/InboxWaitingForWork'
import { InboxMcpBanner } from '../InboxMcpBanner'
+import { InboxActivationPanel } from '../onboarding/InboxActivationPanel'
import { SelfDrivingInstallingHint } from '../SelfDrivingInstallingHint'
import { InboxBulkSelectionBar } from '../shell/InboxBulkSelectionBar'
import { InboxReportFilters } from '../shell/InboxReportFilters'
@@ -231,6 +233,7 @@ function emptyListCopy(scope: InboxScope, narrowed: boolean): string {
* selection are shared across all of them.
*/
export function ReportsTab(): JSX.Element {
+ const { showActivationPanel: showActivation } = useValues(inboxActivationVisibilityLogic)
const { isStaff } = useValues(inboxSceneLogic)
// The row context menus dispatch to this logic and unmount when a menu closes; pinning it here
// keeps an in-flight create-PR listener alive past the click that closed the menu.
@@ -374,9 +377,12 @@ export function ReportsTab(): JSX.Element {
</div>
<InboxBulkSelectionBar reports={rows.map(({ report }) => report)} />
<InboxMcpBanner />
+ {showActivation && <InboxActivationPanel hasReports={!inboxIsEmpty && rows.length > 0} />}
{inboxIsEmpty ? (
- <ReportsEmptyState />
+ showActivation ? null : (
+ <ReportsEmptyState />
+ )
) : showFirstLoadSkeleton ? (
// Hold the rows until every selected state's first page has settled: the states
// load in parallel, and painting the fastest one first would let the slower ones
diff --git a/products/signals/frontend/inbox/inboxAnalytics.ts b/products/signals/frontend/inbox/inboxAnalytics.ts
index 95f6df320e59..e4e75421cb9d 100644
--- a/products/signals/frontend/inbox/inboxAnalytics.ts
+++ b/products/signals/frontend/inbox/inboxAnalytics.ts
@@ -218,10 +218,10 @@ export function discussQuestionProperties(params: {
export type InboxReportActionOutcome = 'success' | 'failure' | 'blocked' | 'limited'
/**
- * Panels that replace the report list and so never fire `Inbox viewed`. `config` is the Settings
- * tab; the value predates the rename and stays so the panel breakdown reads continuously.
+ * `config` is the Settings tab; the value predates the rename and stays so the panel breakdown
+ * reads continuously. The onboarding panel can appear alongside the report list.
*/
-export type InboxPanelName = 'runs' | 'config' | 'scratchpad' | 'findings' | 'triage'
+export type InboxPanelName = 'runs' | 'config' | 'scratchpad' | 'findings' | 'triage' | 'onboarding'
/** A panel read that carries its own timeout, named so each one's stall rate reads separately. */
export type InboxPanelLoad = 'scout_notes' | 'scout_memory'
@@ -773,12 +773,14 @@ export function captureSignalSourceConnected(params: {
sourceType: string
isFirstConnection: boolean
viaSetupWizard: boolean
+ setupMode?: 'guided' | 'quick'
}): void {
captureInboxEvent(INBOX_EVENTS.SOURCE_CONNECTED, {
source_product: params.sourceProduct,
source_type: params.sourceType,
is_first_connection: params.isFirstConnection,
via_setup_wizard: params.viaSetupWizard,
+ ...(params.setupMode ? { setup_mode: params.setupMode } : {}),
})
}
@@ -1211,7 +1213,7 @@ export function captureScoutCreatePathSwitched(params: {
}
/** Where a suggestion card was rendered: the strip above the roster, or the empty state's body. */
-export type ScoutSuggestionSurface = 'strip' | 'empty_state'
+export type ScoutSuggestionSurface = 'strip' | 'empty_state' | 'onboarding'
/** Which offer a suggestion card makes. Mirrors the API's `kind`. */
export type ScoutSuggestionKind = 'canonical' | 'custom'
diff --git a/products/signals/frontend/inbox/logics/inboxActivationLogic.test.ts b/products/signals/frontend/inbox/logics/inboxActivationLogic.test.ts
new file mode 100644
index 000000000000..2523044980bd
--- /dev/null
+++ b/products/signals/frontend/inbox/logics/inboxActivationLogic.test.ts
@@ -0,0 +1,131 @@
+import { expectLogic } from 'kea-test-utils'
+import posthog from 'posthog-js'
+
+import { useMocks } from '~/mocks/jest'
+import { initKeaTests } from '~/test/init'
+
+import type { InboxOnboardingStateApi, ScoutSuggestionSetApi } from '../../generated/api.schemas'
+import { mockScoutSuggestionSet } from '../__mocks__/scoutConfigs'
+import { inboxActivationLogic } from './inboxActivationLogic'
+import { inboxSetupLogic } from './inboxSetupLogic'
+import { REFRESH_POLL_TIMEOUT_MS, scoutSuggestionsLogic } from './scoutSuggestionsLogic'
+
+const ACTIVATED_AT = Date.parse('2026-10-01T12:00:00Z')
+
+describe('Inbox activation progress', () => {
+ let logic: ReturnType<typeof inboxActivationLogic.build>
+ let state: InboxOnboardingStateApi
+ let batch: ScoutSuggestionSetApi
+ let unmount: () => void
+ let stateReads: number
+
+ beforeEach(() => {
+ initKeaTests()
+ jest.useFakeTimers({
+ doNotFake: ['setTimeout', 'clearTimeout', 'setImmediate', 'clearImmediate', 'nextTick', 'queueMicrotask'],
+ })
+ jest.setSystemTime(ACTIVATED_AT)
+ stateReads = 0
+ state = {
+ variant: 'test-github',
+ completed_at: new Date(ACTIVATED_AT).toISOString(),
+ draft: null,
+ jobs: { scout: 'pending', recommendations: 'started' },
+ }
+ batch = mockScoutSuggestionSet({ generated_at: new Date(ACTIVATED_AT - 60_000).toISOString() })
+ useMocks({
+ get: {
+ '/api/projects/:id/signals/onboarding/': () => {
+ stateReads++
+ return [200, state]
+ },
+ '/api/projects/:id/signals/scout/suggestions/': () => [200, batch],
+ '/api/projects/:id/signals/scout/configs/': [],
+ '/api/projects/:id/signals/source_configs/': { results: [], next: null },
+ '/api/projects/:id/vision/scanners/': { results: [], next: null },
+ },
+ })
+ logic = inboxActivationLogic()
+ unmount = logic.mount()
+ })
+
+ afterEach(() => {
+ unmount()
+ jest.restoreAllMocks()
+ jest.useRealTimers()
+ })
+
+ async function settle(): Promise<void> {
+ await expectLogic(inboxSetupLogic).toFinishAllListeners()
+ await expectLogic(scoutSuggestionsLogic).toFinishAllListeners()
+ }
+
+ it('hides old recommendations and keeps polling until scout dispatch settles', async () => {
+ const capture = jest.spyOn(posthog, 'capture')
+ await settle()
+ logic.actions.reportRecommendationsShown()
+ expect(capture.mock.calls.filter(([event]) => event === 'Scout suggestions shown')).toHaveLength(0)
+ expect(logic.values.suggestions).toEqual([])
+ batch = { ...batch, generated_at: new Date(ACTIVATED_AT + 1000).toISOString() }
+ await jest.advanceTimersByTimeAsync(10_000)
+ await settle()
+ expect(logic.values.recommendationsReady).toBe(true)
+ expect(logic.values.suggestions).toEqual(batch.items)
+ logic.actions.reportRecommendationsShown()
+ logic.actions.reportRecommendationsShown()
+ expect(capture.mock.calls.filter(([event]) => event === 'Scout suggestions shown')).toEqual([
+ [
+ 'Scout suggestions shown',
+ expect.objectContaining({
+ surface: 'onboarding',
+ suggestion_count: batch.items.length,
+ inbox_client: 'cloud',
+ }),
+ undefined,
+ ],
+ ])
+ state = { ...state, jobs: { scout: 'failed', recommendations: 'started' } }
+ await jest.advanceTimersByTimeAsync(10_000)
+ await settle()
+ expect(logic.values.savedState?.jobs?.scout).toBe('failed')
+ const settledReads = stateReads
+ await jest.advanceTimersByTimeAsync(20_000)
+ await settle()
+ expect(stateReads).toBe(settledReads)
+ })
+
+ it.each([
+ ['a failed recommendation generation', 'test-github', { scout: 'started', recommendations: 'failed' }],
+ ['guided setup without background jobs', 'test-ui', undefined],
+ ] as const)('stops polling %s without showing the previous batch', async (_name, variant, jobs) => {
+ await settle()
+ state = { ...state, variant, jobs }
+ await jest.advanceTimersByTimeAsync(10_000)
+ await settle()
+ expect(logic.values.savedState?.jobs?.recommendations).toBe(jobs?.recommendations)
+ expect(logic.values.suggestions).toEqual([])
+ const readsAfterFailure = stateReads
+ await jest.advanceTimersByTimeAsync(20_000)
+ await settle()
+ expect(stateReads).toBe(readsAfterFailure)
+ expect(logic.values.pollingExpired).toBe(false)
+ })
+
+ it('polls beyond fifteen minutes and reads once more at the workflow deadline', async () => {
+ await settle()
+ jest.setSystemTime(ACTIVATED_AT + 20 * 60_000)
+ await jest.advanceTimersByTimeAsync(10_000)
+ await settle()
+ expect(logic.values.pollingExpired).toBe(false)
+ const readsBeforeDeadline = stateReads
+ batch = { ...batch, generated_at: new Date(ACTIVATED_AT + 30 * 60_000).toISOString() }
+ jest.setSystemTime(ACTIVATED_AT + REFRESH_POLL_TIMEOUT_MS)
+ await jest.advanceTimersByTimeAsync(10_000)
+ await settle()
+ expect(stateReads).toBe(readsBeforeDeadline + 1)
+ expect(logic.values.suggestions).toEqual(batch.items)
+ expect(logic.values.pollingExpired).toBe(true)
+ await jest.advanceTimersByTimeAsync(20_000)
+ expect(stateReads).toBe(readsBeforeDeadline + 1)
+ })
+})
diff --git a/products/signals/frontend/inbox/logics/inboxActivationLogic.ts b/products/signals/frontend/inbox/logics/inboxActivationLogic.ts
new file mode 100644
index 000000000000..81fc22dfcdb9
--- /dev/null
+++ b/products/signals/frontend/inbox/logics/inboxActivationLogic.ts
@@ -0,0 +1,184 @@
+import { MakeLogicType, actions, afterMount, connect, kea, listeners, selectors, path, reducers } from 'kea'
+
+import type {
+ InboxOnboardingStateApi,
+ ScoutSuggestionItemApi,
+ ScoutSuggestionSetApi,
+} from '../../generated/api.schemas'
+import { AGENT_ROSTER_GROUPS } from '../components/config/agentRosterMeta'
+import { signalSourcesLogic } from '../signalSourcesLogic'
+import type { SignalSourceConfig } from '../types'
+import { inboxSetupLogic } from './inboxSetupLogic'
+import { scoutFleetLogic } from './scoutFleetLogic'
+import type { SignalScoutConfig } from './scoutFleetLogic'
+import { REFRESH_POLL_TIMEOUT_MS, scoutSuggestionsLogic } from './scoutSuggestionsLogic'
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface inboxActivationLogicValues {
+ currentTeamId: number | null // inboxSetupLogic
+ savedState: InboxOnboardingStateApi | null // inboxSetupLogic
+ scoutConfigs: SignalScoutConfig[] | null // scoutFleetLogic
+ availableSuggestions: ScoutSuggestionItemApi[] // scoutSuggestionsLogic
+ suggestionSet: ScoutSuggestionSetApi | null // scoutSuggestionsLogic
+ suggestionSetLoading: boolean // scoutSuggestionsLogic
+ hasEmittingScanner: boolean | null // signalSourcesLogic
+ sourceConfigs: SignalSourceConfig[] | null // signalSourcesLogic
+ generalScout: SignalScoutConfig | null
+ pollingExpired: boolean
+ recommendationsReady: boolean
+ sourceNames: string[]
+ suggestions: ScoutSuggestionItemApi[]
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface inboxActivationLogicActions {
+ loadSetup: () => any // inboxSetupLogic
+ setSavedState: (state: InboxOnboardingStateApi) => {
+ state: InboxOnboardingStateApi
+ } // inboxSetupLogic
+ loadScoutConfigs: (_?: void | undefined) => void // scoutFleetLogic
+ loadSuggestions: (_?: void | undefined) => void // scoutSuggestionsLogic
+ reportSuggestionsShown: (surface: import('../inboxAnalytics').ScoutSuggestionSurface) => {
+ surface: import('../inboxAnalytics').ScoutSuggestionSurface
+ } // scoutSuggestionsLogic
+ loadSourceConfigs: () => any // signalSourcesLogic
+ loadVisionScanners: () => any // signalSourcesLogic
+ refresh: () => {
+ value: true
+ }
+ reportRecommendationsShown: () => {
+ value: true
+ }
+ setPollingExpired: () => {
+ value: true
+ }
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface inboxActivationLogicMeta {
+ __keaTypeGenInternalSelectorTypes: {
+ suggestions: (
+ availableSuggestions: ScoutSuggestionItemApi[],
+ recommendationsReady: boolean
+ ) => ScoutSuggestionItemApi[]
+ sourceNames: (sourceConfigs: SignalSourceConfig[] | null, hasEmittingScanner: boolean | null) => string[]
+ generalScout: (
+ scoutConfigs: import('../../generated/api.schemas').SignalScoutConfigApi[] | null
+ ) => SignalScoutConfig | null
+ recommendationsReady: (
+ suggestionSet: ScoutSuggestionSetApi | null,
+ savedState: InboxOnboardingStateApi | null
+ ) => boolean
+ }
+}
+
+export type inboxActivationLogicType = MakeLogicType<
+ inboxActivationLogicValues,
+ inboxActivationLogicActions,
+ Record<string, any>,
+ inboxActivationLogicMeta
+>
+
+export const inboxActivationLogic = kea<inboxActivationLogicType>([
+ path(['products', 'signals', 'inbox', 'inboxActivationLogic']),
+ connect({
+ values: [
+ inboxSetupLogic,
+ ['savedState', 'currentTeamId'],
+ signalSourcesLogic,
+ ['sourceConfigs', 'hasEmittingScanner'],
+ scoutFleetLogic,
+ ['scoutConfigs'],
+ scoutSuggestionsLogic,
+ ['suggestionSet', 'suggestionSetLoading', 'suggestions as availableSuggestions'],
+ ],
+ actions: [
+ inboxSetupLogic,
+ ['loadSetup', 'setSavedState'],
+ signalSourcesLogic,
+ ['loadSourceConfigs', 'loadVisionScanners'],
+ scoutFleetLogic,
+ ['loadScoutConfigs'],
+ scoutSuggestionsLogic,
+ ['loadSuggestions', 'reportSuggestionsShown'],
+ ],
+ }),
+ actions({ refresh: true, setPollingExpired: true, reportRecommendationsShown: true }),
+ reducers({ pollingExpired: [false, { setPollingExpired: () => true }] }),
+ selectors({
+ suggestions: [
+ (s) => [s.availableSuggestions, s.recommendationsReady],
+ (suggestions: ScoutSuggestionItemApi[], ready: boolean): ScoutSuggestionItemApi[] =>
+ ready ? suggestions : [],
+ ],
+ sourceNames: [
+ (s) => [s.sourceConfigs, s.hasEmittingScanner],
+ (configs: SignalSourceConfig[] | null, replay: boolean | null): string[] =>
+ AGENT_ROSTER_GROUPS.flatMap((group) => group.agents)
+ .filter((source) =>
+ source.source === 'replay_vision'
+ ? replay
+ : configs?.some(
+ (config) => config.source_product === source.sourceProduct && config.enabled
+ )
+ )
+ .map((source) => source.label),
+ ],
+ generalScout: [
+ (s) => [s.scoutConfigs],
+ (configs: SignalScoutConfig[] | null): SignalScoutConfig | null =>
+ configs?.find((config) => config.skill_name === 'signals-scout-general') ?? null,
+ ],
+ recommendationsReady: [
+ (s) => [s.suggestionSet, s.savedState],
+ (set: ScoutSuggestionSetApi | null, state: InboxOnboardingStateApi | null): boolean =>
+ !!set?.generated_at &&
+ !!state?.completed_at &&
+ new Date(set.generated_at) >= new Date(state.completed_at),
+ ],
+ }),
+ listeners(({ actions, values, cache }) => ({
+ reportRecommendationsShown: () => {
+ const batch = values.suggestionSet?.generated_at
+ if (values.suggestions.length > 0 && batch && cache.shownBatch !== batch) {
+ actions.reportSuggestionsShown('onboarding')
+ cache.shownBatch = batch
+ }
+ },
+ refresh: () => {
+ actions.loadSetup()
+ if (!values.suggestionSetLoading) {
+ actions.loadSuggestions()
+ }
+ },
+ })),
+ afterMount(({ actions, values, cache }) => {
+ actions.loadSourceConfigs()
+ actions.loadVisionScanners()
+ actions.loadScoutConfigs()
+ actions.refresh()
+ cache.disposables.add(() => {
+ const interval = setInterval(() => {
+ const completedAt = values.savedState?.completed_at
+ const jobs = values.savedState?.jobs
+ const recommendationsSettled =
+ values.recommendationsReady ||
+ (!!completedAt && !jobs?.recommendations) ||
+ jobs?.recommendations === 'failed' ||
+ jobs?.recommendations === 'skipped'
+ if (jobs?.scout !== 'pending' && recommendationsSettled) {
+ cache.disposables.dispose('activation')
+ return
+ }
+ if (completedAt && Date.now() - new Date(completedAt).valueOf() >= REFRESH_POLL_TIMEOUT_MS) {
+ actions.refresh()
+ actions.setPollingExpired()
+ cache.disposables.dispose('activation')
+ return
+ }
+ actions.refresh()
+ }, 10_000)
+ return () => clearInterval(interval)
+ }, 'activation')
+ }),
+])
diff --git a/products/signals/frontend/inbox/logics/inboxActivationVisibilityLogic.test.ts b/products/signals/frontend/inbox/logics/inboxActivationVisibilityLogic.test.ts
new file mode 100644
index 000000000000..d1a452075a99
--- /dev/null
+++ b/products/signals/frontend/inbox/logics/inboxActivationVisibilityLogic.test.ts
@@ -0,0 +1,92 @@
+import { expectLogic } from 'kea-test-utils'
+
+import { useMocks } from '~/mocks/jest'
+import { initKeaTests } from '~/test/init'
+
+import type { InboxOnboardingStateApi } from '../../generated/api.schemas'
+import { inboxActivationVisibilityLogic } from './inboxActivationVisibilityLogic'
+import { inboxSetupLogic } from './inboxSetupLogic'
+
+const ACTIVATED_AT = Date.parse('2026-10-01T12:00:00Z')
+const SEVEN_DAYS = 7 * 24 * 60 * 60_000
+
+describe('Inbox activation panel visibility', () => {
+ let logic: ReturnType<typeof inboxActivationVisibilityLogic.build>
+ let state: InboxOnboardingStateApi
+ let reportCount: number
+ let reportRequests: URLSearchParams[]
+ let unmount: (() => void) | undefined
+
+ beforeEach(() => {
+ localStorage.clear()
+ initKeaTests()
+ state = { variant: 'test-github', completed_at: new Date(ACTIVATED_AT).toISOString(), draft: null }
+ reportCount = 0
+ reportRequests = []
+ unmount = undefined
+ jest.spyOn(Date, 'now').mockReturnValue(ACTIVATED_AT)
+ useMocks({
+ get: {
+ '/api/projects/:id/signals/onboarding/': () => [200, state],
+ '/api/projects/:id/signals/reports/': ({ request }) => {
+ reportRequests.push(new URL(request.url).searchParams)
+ return [200, { count: reportCount, results: [], next: null, previous: null }]
+ },
+ },
+ })
+ logic = inboxActivationVisibilityLogic()
+ })
+
+ afterEach(() => {
+ unmount?.()
+ jest.restoreAllMocks()
+ })
+
+ async function checkVisibility(age: number): Promise<void> {
+ jest.mocked(Date.now).mockReturnValue(ACTIVATED_AT + age)
+ unmount ??= logic.mount()
+ await expectLogic(inboxSetupLogic).toFinishAllListeners()
+ await expectLogic(logic, () => logic.actions.checkVisibility()).toFinishAllListeners()
+ }
+
+ describe.each(['test-github', 'test-ui'] as const)('%s', (variant) => {
+ it.each<[string, number, number, boolean]>([
+ ['before seven days with reports', SEVEN_DAYS - 1, 1, true],
+ ['at seven days with reports', SEVEN_DAYS, 1, false],
+ ['after seven days without reports', SEVEN_DAYS + 60_000, 0, true],
+ ])('%s', async (_name, age, count, visible) => {
+ state = { ...state, variant }
+ reportCount = count
+ await checkVisibility(age)
+ expect(logic.values.showActivationPanel).toBe(visible)
+ if (age < SEVEN_DAYS) {
+ expect(reportRequests).toHaveLength(0)
+ } else {
+ expect(reportRequests.length).toBeGreaterThan(0)
+ expect(Object.fromEntries(reportRequests[0])).toEqual({
+ count_only: 'true',
+ scope: 'entire_project',
+ status: 'ready,resolved,pending_input,suppressed',
+ })
+ }
+ })
+ })
+
+ it('hides when the first report arrives after seven days and stops requesting counts', async () => {
+ await checkVisibility(SEVEN_DAYS)
+ expect(logic.values.showActivationPanel).toBe(true)
+ reportCount = 1
+ await checkVisibility(SEVEN_DAYS + 60_000)
+ expect(logic.values.showActivationPanel).toBe(false)
+ const requestsAfterHiding = reportRequests.length
+ await checkVisibility(SEVEN_DAYS + 120_000)
+ expect(reportRequests).toHaveLength(requestsAfterHiding)
+ })
+
+ it.each(['control', null] as const)('does not show the panel or check reports for %s', async (variant) => {
+ state = { ...state, variant }
+ await checkVisibility(SEVEN_DAYS)
+ expect(logic.values.showActivationPanel).toBe(false)
+ expect(reportRequests).toHaveLength(0)
+ })
+})
diff --git a/products/signals/frontend/inbox/logics/inboxActivationVisibilityLogic.ts b/products/signals/frontend/inbox/logics/inboxActivationVisibilityLogic.ts
new file mode 100644
index 000000000000..11bff7813d19
--- /dev/null
+++ b/products/signals/frontend/inbox/logics/inboxActivationVisibilityLogic.ts
@@ -0,0 +1,139 @@
+import { MakeLogicType, actions, afterMount, connect, kea, listeners, path, reducers, selectors } from 'kea'
+import { loaders } from 'kea-loaders'
+
+import { signalsReportsList } from '../../generated/api'
+import type { InboxOnboardingStateApi } from '../../generated/api.schemas'
+import { inboxSetupLogic } from './inboxSetupLogic'
+
+interface GeneratedReports {
+ teamId: number
+ count: number
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface inboxActivationVisibilityLogicValues {
+ completed: boolean // inboxSetupLogic
+ currentTeamId: number | null // inboxSetupLogic
+ isTreatment: boolean // inboxSetupLogic
+ savedState: InboxOnboardingStateApi | null // inboxSetupLogic
+ activationPeriodElapsed: boolean
+ generatedReports: GeneratedReports | null
+ generatedReportsLoading: boolean
+ now: number
+ showActivationPanel: boolean
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface inboxActivationVisibilityLogicActions {
+ loadSetupSuccess: (
+ savedState: InboxOnboardingStateApi,
+ payload?: any
+ ) => {
+ payload?: any
+ savedState: InboxOnboardingStateApi
+ } // inboxSetupLogic
+ setSavedState: (state: InboxOnboardingStateApi) => {
+ state: InboxOnboardingStateApi
+ } // inboxSetupLogic
+ checkVisibility: (now?: number) => {
+ now: number
+ }
+ loadGeneratedReports: () => any
+ loadGeneratedReportsFailure: (
+ error: string,
+ errorObject?: any
+ ) => {
+ error: string
+ errorObject?: any
+ }
+ loadGeneratedReportsSuccess: (
+ generatedReports: GeneratedReports | null,
+ payload?: any
+ ) => {
+ generatedReports: GeneratedReports | null
+ payload?: any
+ }
+}
+
+// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
+export interface inboxActivationVisibilityLogicMeta {
+ __keaTypeGenInternalSelectorTypes: {
+ activationPeriodElapsed: (savedState: InboxOnboardingStateApi | null, now: number) => boolean
+ showActivationPanel: (
+ isTreatment: boolean,
+ completed: boolean,
+ activationPeriodElapsed: boolean,
+ currentTeamId: number | null,
+ generatedReports: GeneratedReports | null
+ ) => boolean
+ }
+}
+
+export type inboxActivationVisibilityLogicType = MakeLogicType<
+ inboxActivationVisibilityLogicValues,
+ inboxActivationVisibilityLogicActions,
+ Record<string, any>,
+ inboxActivationVisibilityLogicMeta
+>
+
+export const inboxActivationVisibilityLogic = kea<inboxActivationVisibilityLogicType>([
+ path(['products', 'signals', 'inbox', 'inboxActivationVisibilityLogic']),
+ connect({
+ values: [inboxSetupLogic, ['savedState', 'currentTeamId', 'isTreatment', 'completed']],
+ actions: [inboxSetupLogic, ['setSavedState', 'loadSetupSuccess']],
+ }),
+ actions({ checkVisibility: (now: number = Date.now()) => ({ now }) }),
+ loaders(({ values }) => ({
+ generatedReports: [
+ null as GeneratedReports | null,
+ {
+ loadGeneratedReports: async (): Promise<GeneratedReports | null> => {
+ const teamId = values.currentTeamId
+ if (!teamId) {
+ return null
+ }
+ const response = await signalsReportsList(String(teamId), {
+ count_only: true,
+ scope: 'entire_project',
+ status: 'ready,resolved,pending_input,suppressed',
+ })
+ return { teamId, count: response.count }
+ },
+ },
+ ],
+ })),
+ reducers(() => ({ now: [Date.now(), { checkVisibility: (_, { now }) => now }] })),
+ selectors({
+ activationPeriodElapsed: [
+ (s) => [s.savedState, s.now],
+ (state: InboxOnboardingStateApi | null, now: number): boolean =>
+ !!state?.completed_at && now - Date.parse(state.completed_at) >= 7 * 24 * 60 * 60_000,
+ ],
+ showActivationPanel: [
+ (s) => [s.isTreatment, s.completed, s.activationPeriodElapsed, s.currentTeamId, s.generatedReports],
+ (
+ treatment: boolean,
+ completed: boolean,
+ elapsed: boolean,
+ teamId: number | null,
+ reports: GeneratedReports | null
+ ): boolean => treatment && completed && !(elapsed && reports?.teamId === teamId && reports.count > 0),
+ ],
+ }),
+ listeners(({ actions, values }) => ({
+ checkVisibility: () => {
+ if (values.showActivationPanel && values.activationPeriodElapsed && !values.generatedReportsLoading) {
+ actions.loadGeneratedReports()
+ }
+ },
+ setSavedState: () => actions.checkVisibility(),
+ loadSetupSuccess: () => actions.checkVisibility(),
+ })),
+ afterMount(({ actions, cache }) => {
+ cache.disposables.add(() => {
+ actions.checkVisibility()
+ const interval = setInterval(() => actions.checkVisibility(), 60_000)
+ return () => clearInterval(interval)
+ }, 'activationVisibility')
+ }),
+])
diff --git a/products/signals/frontend/inbox/logics/inboxSetupLogic.test.ts b/products/signals/frontend/inbox/logics/inboxSetupLogic.test.ts
index 2a9219c67d9a..855e89767e5c 100644
--- a/products/signals/frontend/inbox/logics/inboxSetupLogic.test.ts
+++ b/products/signals/frontend/inbox/logics/inboxSetupLogic.test.ts
@@ -37,7 +37,7 @@ const draft: InboxOnboardingDraftApi = {
describe('focused Inbox setup', () => {
let logic: ReturnType<typeof inboxSetupLogic.build>
let savedDraft: InboxOnboardingDraftApi | null
- let variant: 'control' | 'test' | null
+ let variant: 'control' | 'test-ui' | 'test-github' | null
let sources: SignalSourceConfigApi[]
let failCompletion: boolean
let createdSources: number
@@ -53,7 +53,7 @@ describe('focused Inbox setup', () => {
beforeEach(() => {
initKeaTests()
savedDraft = { ...draft }
- variant = 'test'
+ variant = 'test-ui'
sources = []
createdSources = 0
warehouseConnected = false
@@ -123,6 +123,11 @@ describe('focused Inbox setup', () => {
},
},
post: {
+ '/api/projects/:id/signals/onboarding/expose/': async ({ request }) => {
+ const assignment = (await request.json()) as { variant: typeof variant }
+ variant ??= assignment.variant
+ return [200, { draft: savedDraft, completed_at: null, variant }]
+ },
'/api/projects/:id/signals/scout/configs/sync/': ({ request }) => {
expect(new URL(request.url).searchParams.get('surface')).toBe('onboarding')
return [200, canonicalScouts]
@@ -173,7 +178,10 @@ describe('focused Inbox setup', () => {
'/api/projects/:id/signals/source_configs/:source/': () => [200, sources[0]],
},
})
- featureFlagLogic.actions.setFeatureFlags([], { [FEATURE_FLAGS.INBOX_UI_ONBOARDING]: 'test' })
+ featureFlagLogic.actions.setFeatureFlags([], {
+ [FEATURE_FLAGS.SELF_DRIVING_UBP]: true,
+ [FEATURE_FLAGS.INBOX_UI_ONBOARDING]: 'test-ui',
+ })
logic = inboxSetupLogic()
logic.mount()
})
@@ -184,23 +192,104 @@ describe('focused Inbox setup', () => {
jest.useRealTimers()
})
- it.each(['control', null, 'test'] as const)(
+ it.each([
+ ['button', true, null],
+ ['github_return', true, null],
+ ['button', false, null],
+ ['github_return', false, null],
+ ['button', true, true],
+ ['button', false, false],
+ ] as const)(
+ 'activates through %s with usage-based pricing %s and saved implementation %s',
+ async (entry, usageBasedPricing, savedImplementation) => {
+ const capture = jest.spyOn(posthog, 'capture')
+ variant = entry === 'github_return' ? 'test-github' : null
+ featureFlagLogic.actions.setFeatureFlags([], {
+ [FEATURE_FLAGS.SELF_DRIVING_UBP]: usageBasedPricing,
+ [FEATURE_FLAGS.INBOX_UI_ONBOARDING]: 'test-github',
+ })
+ savedDraft =
+ savedImplementation === null ? null : { ...draft, automatic_implementation: savedImplementation }
+ failCompletion = false
+ hasEvents = true
+ canonicalScouts = [
+ {
+ ...mockScoutConfigs[0],
+ skill_name: 'signals-scout-general',
+ enabled: false,
+ scout_origin: 'canonical',
+ },
+ ]
+ const refresh = jest.spyOn(signalsApi, 'signalsScoutSuggestionsRefresh')
+ logic.actions.startSetup()
+ await waitFor(() => expect(logic.values.quickSetupReady).toBe(true))
+ expect(logic.values.isQuickSetup).toBe(true)
+ if (savedImplementation !== null) {
+ expect(logic.values.savedState?.draft?.automatic_implementation).toBe(savedImplementation)
+ }
+ if (entry === 'github_return') {
+ router.actions.replace(router.values.location.pathname, { onboarding_step: 'quick' })
+ expect(logic.values.shouldResumeQuickSetup).toBe(true)
+ logic.actions.resumeQuickSetup()
+ logic.actions.resumeQuickSetup()
+ } else {
+ logic.actions.activateQuickSetup()
+ logic.actions.activateQuickSetup()
+ }
+ await waitFor(() => expect(logic.values.completed).toBe(true))
+ expect(enabledScouts).toEqual(['signals-scout-general'])
+ expect(logic.values.savedState?.draft?.automatic_implementation).toBe(!usageBasedPricing)
+ expect(logic.values.savedState?.draft?.suggestions.map((item) => item.skill_name)).toEqual([
+ 'signals-scout-general',
+ ])
+ expect(sources).toEqual(
+ expect.arrayContaining([expect.objectContaining({ source_product: 'signals_scout', enabled: true })])
+ )
+ expect(router.values.searchParams.onboarding_step).toBeUndefined()
+ expect(refresh).not.toHaveBeenCalled()
+ const requests = capture.mock.calls.filter(
+ ([event]) => event === 'self-driving onboarding activation requested'
+ )
+ expect(requests).toEqual([
+ [
+ 'self-driving onboarding activation requested',
+ expect.objectContaining({
+ variant: 'test-github',
+ setup_mode: 'quick',
+ flow_version: 'ui-first-v1',
+ inbox_client: 'cloud',
+ activation_source: entry,
+ self_driving_ubp: usageBasedPricing,
+ automatic_implementation: !usageBasedPricing,
+ }),
+ ],
+ ])
+ expect(
+ capture.mock.calls.filter(
+ ([event, properties]) =>
+ event === 'Signal source connected' && properties?.source_product === 'signals_scout'
+ )
+ ).toHaveLength(1)
+ }
+ )
+
+ it.each(['control', null, 'test-ui'] as const)(
'opens setup and preserves the %s assignment through resume and activation',
async (assignment) => {
variant = assignment
savedDraft = null
- featureFlagLogic.actions.setFeatureFlags(
- [],
- assignment ? { [FEATURE_FLAGS.INBOX_UI_ONBOARDING]: assignment } : {}
- )
+ featureFlagLogic.actions.setFeatureFlags([], {
+ [FEATURE_FLAGS.SELF_DRIVING_UBP]: true,
+ ...(assignment ? { [FEATURE_FLAGS.INBOX_UI_ONBOARDING]: assignment } : {}),
+ })
await expectLogic(logic, () => logic.actions.loadSetup()).toFinishAllListeners()
- expect(logic.values.usesFocusedSetup).toBe(assignment === 'test')
+ expect(logic.values.usesFocusedSetup).toBe(assignment === 'test-ui')
expect(logic.values.inProgress).toBe(false)
const capture = jest.spyOn(posthog, 'capture')
const onboarding = inboxOnboardingLogic()
onboarding.mount()
try {
- if (assignment === 'test') {
+ if (assignment === 'test-ui') {
await expectLogic(logic, () => logic.actions.continueFromWelcome()).toFinishAllListeners()
await expectLogic(logic, () => logic.actions.continueFromWelcome()).toFinishAllListeners()
} else {
@@ -209,9 +298,45 @@ describe('focused Inbox setup', () => {
expect(logic.values.usesFocusedSetup).toBe(true)
expect(logic.values.inProgress).toBe(true)
expect(onboarding.values.onboardingMode).toBe('takeover')
- expect(router.values.searchParams.onboarding_step).toBe('signals')
+ expect(router.values.searchParams.onboarding_step).toBeUndefined()
+ await expectLogic(logic, () => logic.actions.startSetup()).toFinishAllListeners()
+ logic.actions.reportStepViewed()
+ logic.actions.reportStepViewed()
+ expect(capture.mock.calls.filter(([event]) => event === 'self-driving onboarding step viewed')).toEqual(
+ [
+ [
+ 'self-driving onboarding step viewed',
+ expect.objectContaining({ step: 'signals', setup_mode: 'guided' }),
+ ],
+ ]
+ )
+ await expectLogic(logic, () =>
+ logic.actions.patchDraft({ sources: draft.sources })
+ ).toFinishAllListeners()
+ expect(savedDraft).toBeNull()
+ expect(
+ capture.mock.calls.filter(([event]) => event === 'self-driving onboarding started')
+ ).toHaveLength(0)
+ onboarding.unmount()
+ logic.unmount()
+ router.actions.replace('/inbox')
+ logic = inboxSetupLogic()
+ logic.mount()
+ await expectLogic(logic, () => logic.actions.loadSetup()).toFinishAllListeners()
+ expect(logic.values.inProgress).toBe(false)
+ expect(logic.values.draft.step).toBe('signals')
+ onboarding.mount()
+ await expectLogic(logic, () => logic.actions.openSetup()).toFinishAllListeners()
await expectLogic(logic, () => logic.actions.startSetup()).toFinishAllListeners()
await expectLogic(logic, () => logic.actions.goToStep('github')).toFinishAllListeners()
+ expect(savedDraft).toMatchObject({ step: 'github' })
+ logic.actions.reportStepViewed()
+ await expectLogic(logic, () => logic.actions.goToStep('signals')).toFinishAllListeners()
+ logic.actions.reportStepViewed()
+ expect(
+ capture.mock.calls.filter(([event]) => event === 'self-driving onboarding step completed')
+ ).toEqual([['self-driving onboarding step completed', expect.objectContaining({ step: 'signals' })]])
+ await expectLogic(logic, () => logic.actions.goToStep('github')).toFinishAllListeners()
await expectLogic(logic, () =>
logic.actions.patchDraft({ sources: draft.sources })
).toFinishAllListeners()
@@ -224,7 +349,7 @@ describe('focused Inbox setup', () => {
)
expect(
capture.mock.calls.filter(([event]) => event === 'self-driving onboarding welcome continued')
- ).toHaveLength(assignment === 'test' ? 1 : 0)
+ ).toHaveLength(assignment === 'test-ui' ? 1 : 0)
} finally {
onboarding.unmount()
capture.mockRestore()
@@ -239,15 +364,32 @@ describe('focused Inbox setup', () => {
expect(logic.values.draft.step).toBe('github')
expect(logic.values.experimentVariant).toBe(assignment)
await expectLogic(logic, () => logic.actions.startSetup()).toFinishAllListeners()
+ const resumedCapture = jest.spyOn(posthog, 'capture')
+ logic.actions.reportStepViewed()
+ expect(resumedCapture).toHaveBeenCalledWith(
+ 'self-driving onboarding step viewed',
+ expect.objectContaining({
+ step: 'github',
+ implementation_toggle_shown: true,
+ })
+ )
failCompletion = false
await expectLogic(logic, () => logic.actions.activate()).toFinishAllListeners()
expect(logic.values.completed).toBe(true)
expect(logic.values.inProgress).toBe(false)
expect(logic.values.experimentVariant).toBe(assignment)
+ expect(resumedCapture).toHaveBeenCalledWith(
+ 'self-driving onboarding step completed',
+ expect.objectContaining({ step: 'github' })
+ )
}
)
- it('keeps partially activated setup open and retries without creating another source', async () => {
+ it.each([true, false])('retries partial activation with usage-based pricing %s', async (usageBasedPricing) => {
+ featureFlagLogic.actions.setFeatureFlags([], {
+ [FEATURE_FLAGS.SELF_DRIVING_UBP]: usageBasedPricing,
+ [FEATURE_FLAGS.INBOX_UI_ONBOARDING]: 'test-ui',
+ })
const capture = jest.spyOn(posthog, 'capture')
await expectLogic(logic, () => logic.actions.startSetup()).toFinishAllListeners()
expect(logic.values.activationDisabledReason).toBeUndefined()
@@ -255,17 +397,42 @@ describe('focused Inbox setup', () => {
await expectLogic(logic, () => logic.actions.activate()).toFinishAllListeners()
expect(logic.values.completed).toBe(false)
expect(logic.values.inProgress).toBe(true)
- expect(logic.values.draft).toEqual(draft)
+ expect(logic.values.draft).toEqual({ ...draft, automatic_implementation: !usageBasedPricing })
expect(logic.values.error).toBeTruthy()
expect(createdSources).toBe(1)
failCompletion = false
await expectLogic(logic, () => logic.actions.retry()).toFinishAllListeners()
- expect(savedDraft?.automatic_implementation).toBe(false)
+ expect(savedDraft?.automatic_implementation).toBe(!usageBasedPricing)
expect(logic.values.completed).toBe(true)
expect(logic.values.inProgress).toBe(false)
expect(createdSources).toBe(1)
expect(capture.mock.calls.filter(([event]) => event === 'self-driving onboarding started')).toHaveLength(1)
+ expect(capture.mock.calls.filter(([event]) => event === 'Signal source connected')).toEqual([
+ [
+ 'Signal source connected',
+ expect.objectContaining({
+ source_product: 'error_tracking',
+ is_first_connection: true,
+ setup_mode: 'guided',
+ }),
+ undefined,
+ ],
+ ])
+ expect(capture.mock.calls.filter(([event]) => event === 'self-driving onboarding failed')).toEqual([
+ [
+ 'self-driving onboarding failed',
+ expect.objectContaining({
+ failed_operation: 'activation',
+ step: 'github',
+ flow_version: 'ui-first-v1',
+ }),
+ ],
+ ])
+ expect(capture).toHaveBeenCalledWith(
+ 'self-driving onboarding activation requested',
+ expect.objectContaining({ activation_source: 'retry' })
+ )
capture.mockRestore()
})
@@ -501,11 +668,12 @@ describe('focused Inbox setup', () => {
)
it('batches rapid edits without locking the form', async () => {
+ const capture = jest.spyOn(posthog, 'capture')
await expectLogic(logic, () => logic.actions.startSetup()).toFinishAllListeners()
const save = jest.spyOn(signalsApi, 'signalsOnboardingCreate').mockImplementation(async (_, draft) => ({
draft,
completed_at: null,
- variant: 'test',
+ variant: 'test-ui',
}))
jest.useFakeTimers()
logic.actions.patchDraft({ automatic_implementation: true })
@@ -518,6 +686,19 @@ describe('focused Inbox setup', () => {
await jest.advanceTimersByTimeAsync(1)
expect(save).toHaveBeenCalledTimes(1)
expect(save.mock.calls[0][1]).toMatchObject({ automatic_implementation: true, implementation_priority: 'P2' })
+ expect(
+ capture.mock.calls.filter(([event]) => event === 'self-driving onboarding implementation changed')
+ ).toEqual([
+ [
+ 'self-driving onboarding implementation changed',
+ expect.objectContaining({
+ previous_value: false,
+ new_value: true,
+ setup_mode: 'guided',
+ self_driving_ubp: true,
+ }),
+ ],
+ ])
})
it('serializes saves and keeps newer edits while navigation waits for them', async () => {
@@ -545,11 +726,11 @@ describe('focused Inbox setup', () => {
logic.actions.goToStep('scouts')
expect(save).toHaveBeenCalledTimes(1)
expect(logic.values.saving).toBe(true)
- finishFirst({ draft: save.mock.calls[0][1], completed_at: null, variant: 'test' })
+ finishFirst({ draft: save.mock.calls[0][1], completed_at: null, variant: 'test-ui' })
await waitFor(() => expect(save).toHaveBeenCalledTimes(2))
expect(logic.values.draft).toMatchObject({ automatic_implementation: false, implementation_priority: 'P2' })
expect(router.values.searchParams.onboarding_step).not.toBe('scouts')
- finishSecond({ draft: save.mock.calls[1][1], completed_at: null, variant: 'test' })
+ finishSecond({ draft: save.mock.calls[1][1], completed_at: null, variant: 'test-ui' })
await expectLogic(logic).toFinishAllListeners()
expect(save).toHaveBeenCalledTimes(2)
expect(logic.values.saving).toBe(false)
@@ -583,7 +764,7 @@ describe('focused Inbox setup', () => {
logic.actions.connectGithub('/authorize-github')
expect(assign).not.toHaveBeenCalled()
expect(logic.values.saving).toBe(true)
- finish({ draft: save.mock.calls[1][1], completed_at: null, variant: 'test' })
+ finish({ draft: save.mock.calls[1][1], completed_at: null, variant: 'test-ui' })
await expectLogic(logic).toFinishAllListeners()
expect(logic.values.error).toBeNull()
expect(assign).toHaveBeenCalledWith('/authorize-github')
diff --git a/products/signals/frontend/inbox/logics/inboxSetupLogic.ts b/products/signals/frontend/inbox/logics/inboxSetupLogic.ts
index 0e220c695598..5f9b2ae67345 100644
--- a/products/signals/frontend/inbox/logics/inboxSetupLogic.ts
+++ b/products/signals/frontend/inbox/logics/inboxSetupLogic.ts
@@ -43,12 +43,14 @@ import type {
} from '../../generated/api.schemas'
import type { InboxOnboardingStepEnumApi } from '../../generated/api.schemas'
import type { AgentRosterSource } from '../components/config/agentRosterMeta'
+import { captureSignalSourceConnected } from '../inboxAnalytics'
import { signalSourcesLogic, WAREHOUSE_SOURCE_SETUP, type WarehouseBackedSource } from '../signalSourcesLogic'
import type { SourceProductStatus } from '../signalSourcesLogic'
import type { SignalSourceConfig } from '../types'
import { newInboxSetupDraft, reconcileInboxSetupDraft, selectedSourceCount, setupSources } from '../utils/inboxSetup'
import type { InboxSetupSource } from '../utils/inboxSetup'
import { inboxSetupDefaultScouts, inboxSetupScoutChoices } from '../utils/inboxSetupScouts'
+import { quickInboxSetupDraft } from '../utils/quickInboxSetup'
import { DEFAULT_SUGGESTION_INTERVAL_MINUTES } from '../utils/scoutSuggestions'
import { scoutFleetLogic } from './scoutFleetLogic'
import type { SignalScoutConfig } from './scoutFleetLogic'
@@ -83,12 +85,15 @@ export interface inboxSetupLogicValues {
draft: InboxOnboardingDraftApi
editedDraft: InboxOnboardingDraftApi | null
error: string | null
- experimentVariant: 'control' | 'test' | null
+ experimentVariant: 'control' | 'test-github' | 'test-ui' | null
failedOperation: 'activation' | 'other' | 'scouts' | 'sources' | null
hasGithubIntegration: boolean
inProgress: boolean
isFinalStep: boolean
+ isQuickSetup: boolean
isTreatment: boolean
+ quickSetupDraft: InboxOnboardingDraftApi | null
+ quickSetupReady: boolean
ready: boolean
refreshingSources: boolean
resumingSetup: boolean
@@ -97,6 +102,7 @@ export interface inboxSetupLogicValues {
saving: boolean
scoutChoices: ScoutSuggestionItemApi[]
scoutsLoading: boolean
+ shouldResumeQuickSetup: boolean
sourceCount: number
sourceSetupSource: WarehouseBackedSource | null
sources: InboxSetupSource[]
@@ -120,8 +126,11 @@ export interface inboxSetupLogicActions {
loadSources: () => {
value: true
} // sourcesDataLogic
- activate: () => {
- value: true
+ activate: (activationSource?: 'button' | 'github_return' | 'retry') => {
+ activationSource: 'button' | 'github_return' | 'retry'
+ }
+ activateQuickSetup: (activationSource?: 'button' | 'github_return' | 'retry') => {
+ activationSource: 'button' | 'github_return' | 'retry'
}
connectGithub: (url: string) => {
url: string
@@ -129,8 +138,8 @@ export interface inboxSetupLogicActions {
continueFromWelcome: () => {
value: true
}
- expose: (variant: 'control' | 'test') => {
- variant: 'control' | 'test'
+ expose: (variant: 'control' | 'test-github' | 'test-ui') => {
+ variant: 'control' | 'test-github' | 'test-ui'
}
finishSourceSetup: () => {
value: true
@@ -168,6 +177,12 @@ export interface inboxSetupLogicActions {
reportInteraction: () => {
value: true
}
+ reportStepViewed: () => {
+ value: true
+ }
+ resumeQuickSetup: () => {
+ value: true
+ }
retry: () => {
value: true
}
@@ -176,10 +191,12 @@ export interface inboxSetupLogicActions {
}
setError: (
error: string | null,
- failedOperation?: 'activation' | 'other' | 'scouts' | 'sources'
+ failedOperation?: 'activation' | 'other' | 'scouts' | 'sources',
+ failureReason?: 'draft_save_failed' | 'github_redirect_failed' | 'source_connection_failed' | null
) => {
error: string | null
failedOperation: 'activation' | 'other' | 'scouts' | 'sources'
+ failureReason: 'draft_save_failed' | 'github_redirect_failed' | 'source_connection_failed' | null
}
setSavedState: (state: InboxOnboardingStateApi) => {
state: InboxOnboardingStateApi
@@ -208,11 +225,32 @@ export interface inboxSetupLogicActions {
// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface inboxSetupLogicMeta {
__keaTypeGenInternalSelectorTypes: {
+ isQuickSetup: (experimentVariant: 'control' | 'test-github' | 'test-ui' | null) => boolean
+ shouldResumeQuickSetup: (
+ isQuickSetup: boolean,
+ quickSetupReady: boolean,
+ hasGithubIntegration: boolean,
+ searchParams: Record<string, any>,
+ saving: boolean,
+ error: string | null,
+ completed: boolean
+ ) => boolean
+ quickSetupDraft: (
+ sources: InboxSetupSource[],
+ visionScanners: ReplayScannerApi[] | null,
+ scoutConfigs: SignalScoutConfigApi[] | null,
+ featureFlags: FeatureFlagsSet
+ ) => InboxOnboardingDraftApi | null
+ quickSetupReady: (
+ ready: boolean,
+ quickSetupDraft: InboxOnboardingDraftApi | null,
+ scoutConfigsLoading: boolean
+ ) => boolean
experimentVariant: (
featureFlags: FeatureFlagsSet,
savedState: InboxOnboardingStateApi | null
- ) => 'control' | 'test' | null
- isTreatment: (experimentVariant: 'control' | 'test' | null) => boolean
+ ) => 'control' | 'test-github' | 'test-ui' | null
+ isTreatment: (experimentVariant: 'control' | 'test-github' | 'test-ui' | null) => boolean
resumingSetup: (searchParams: Record<string, any>) => boolean
usesFocusedSetup: (
isTreatment: boolean,
@@ -232,7 +270,8 @@ export interface inboxSetupLogicMeta {
editedDraft: InboxOnboardingDraftApi | null,
sources: InboxSetupSource[],
visionScanners: ReplayScannerApi[] | null,
- scannerInventoryKnown: boolean
+ scannerInventoryKnown: boolean,
+ featureFlags: FeatureFlagsSet
) => InboxOnboardingDraftApi
scoutsLoading: (
scoutConfigsLoading: boolean,
@@ -338,19 +377,29 @@ export const inboxSetupLogic = kea<inboxSetupLogicType>([
setSourceSetupSource: (source: WarehouseBackedSource | null) => ({ source }),
finishSourceSetup: true,
reportInteraction: true,
- expose: (variant: 'control' | 'test') => ({ variant }),
+ reportStepViewed: true,
+ expose: (variant: 'control' | 'test-ui' | 'test-github') => ({ variant }),
patchDraft: (patch: Partial<InboxOnboardingDraftApi>) => ({ patch }),
setEditedDraft: (draft: InboxOnboardingDraftApi) => ({ draft }),
connectGithub: (url: string) => ({ url }),
toggleSource: (source: InboxSetupSource, enabled: boolean) => ({ source, enabled }),
toggleSuggestion: (suggestion: ScoutSuggestionItemApi) => ({ suggestion }),
goToStep: (step: InboxOnboardingDraftApi['step']) => ({ step }),
- activate: true,
+ activate: (activationSource: 'button' | 'github_return' | 'retry' = 'button') => ({ activationSource }),
retry: true,
+ activateQuickSetup: (activationSource: 'button' | 'github_return' | 'retry' = 'button') => ({
+ activationSource,
+ }),
+ resumeQuickSetup: true,
setSaving: (saving: boolean) => ({ saving }),
- setError: (error: string | null, failedOperation: 'activation' | 'sources' | 'scouts' | 'other' = 'other') => ({
+ setError: (
+ error: string | null,
+ failedOperation: 'activation' | 'sources' | 'scouts' | 'other' = 'other',
+ failureReason: 'draft_save_failed' | 'source_connection_failed' | 'github_redirect_failed' | null = null
+ ) => ({
error,
failedOperation,
+ failureReason,
}),
setSavedState: (state: InboxOnboardingStateApi) => ({ state }),
}),
@@ -384,21 +433,72 @@ export const inboxSetupLogic = kea<inboxSetupLogicType>([
started: [false, { startSetup: () => true, openSetup: () => true }],
}),
selectors({
+ isQuickSetup: [
+ (s) => [s.experimentVariant],
+ (variant: 'control' | 'test-github' | 'test-ui' | null): boolean => variant === 'test-github',
+ ],
+ shouldResumeQuickSetup: [
+ (s) => [
+ s.isQuickSetup,
+ s.quickSetupReady,
+ s.hasGithubIntegration,
+ s.searchParams,
+ s.saving,
+ s.error,
+ s.completed,
+ ],
+ (
+ quick: boolean,
+ ready: boolean,
+ connected: boolean,
+ params: Record<string, any>,
+ saving: boolean,
+ error: string | null,
+ completed: boolean
+ ): boolean =>
+ quick && ready && connected && params.onboarding_step === 'quick' && !saving && !error && !completed,
+ ],
+ quickSetupDraft: [
+ (s) => [s.sources, s.visionScanners, s.scoutConfigs, s.featureFlags],
+ (
+ sources: InboxSetupSource[],
+ scanners: ReplayScannerApi[] | null,
+ configs: SignalScoutConfigApi[] | null,
+ flags: FeatureFlagsSet
+ ): InboxOnboardingDraftApi | null => {
+ const quickDraft = quickInboxSetupDraft(sources, scanners ?? [], configs ?? [])
+ return quickDraft
+ ? {
+ ...quickDraft,
+ automatic_implementation: !flags[FEATURE_FLAGS.SELF_DRIVING_UBP],
+ }
+ : null
+ },
+ ],
+ quickSetupReady: [
+ (s) => [s.ready, s.quickSetupDraft, s.scoutConfigsLoading],
+ (ready: boolean, draft: InboxOnboardingDraftApi | null, loading: boolean): boolean =>
+ ready && draft !== null && !loading,
+ ],
experimentVariant: [
(s) => [s.featureFlags, s.savedState],
- (flags: FeatureFlagsSet, state: InboxOnboardingStateApi | null): 'control' | 'test' | null => {
+ (
+ flags: FeatureFlagsSet,
+ state: InboxOnboardingStateApi | null
+ ): 'control' | 'test-ui' | 'test-github' | null => {
const variant = state?.variant ?? flags[FEATURE_FLAGS.INBOX_UI_ONBOARDING]
- return variant === 'control' || variant === 'test' ? variant : null
+ return variant === 'control' || variant === 'test-ui' || variant === 'test-github' ? variant : null
},
],
isTreatment: [
(s) => [s.experimentVariant],
- (variant: 'control' | 'test' | null): boolean => variant === 'test',
+ (variant: 'control' | 'test-ui' | 'test-github' | null): boolean =>
+ variant === 'test-ui' || variant === 'test-github',
],
resumingSetup: [
(s) => [s.searchParams],
(params: Record<string, any>): boolean =>
- ['signals', 'scouts', 'github'].includes(String(params.onboarding_step)),
+ ['signals', 'scouts', 'github', 'quick'].includes(String(params.onboarding_step)),
],
usesFocusedSetup: [
(s) => [s.isTreatment, s.started, s.savedState, s.resumingSetup],
@@ -432,14 +532,15 @@ export const inboxSetupLogic = kea<inboxSetupLogicType>([
),
],
draft: [
- (s) => [s.editedDraft, s.sources, s.visionScanners, s.scannerInventoryKnown],
+ (s) => [s.editedDraft, s.sources, s.visionScanners, s.scannerInventoryKnown, s.featureFlags],
(
draft: InboxOnboardingDraftApi | null,
sources: InboxSetupSource[],
scanners: ReplayScannerApi[] | null,
- scannerInventoryKnown: boolean
- ): InboxOnboardingDraftApi =>
- draft
+ scannerInventoryKnown: boolean,
+ flags: FeatureFlagsSet
+ ): InboxOnboardingDraftApi => {
+ const reconciled = draft
? reconcileInboxSetupDraft(
draft,
sources,
@@ -448,7 +549,11 @@ export const inboxSetupLogic = kea<inboxSetupLogicType>([
: newInboxSetupDraft(
sources,
(scanners ?? []).map((scanner) => scanner.id)
- ),
+ )
+ return flags[FEATURE_FLAGS.SELF_DRIVING_UBP]
+ ? reconciled
+ : { ...reconciled, automatic_implementation: true }
+ },
],
scoutsLoading: [
(s) => [s.scoutConfigsLoading, s.suggestionSetLoading, s.isRefreshing, s.scoutChoices],
@@ -548,6 +653,22 @@ export const inboxSetupLogic = kea<inboxSetupLogicType>([
let persistedDraft: InboxOnboardingDraftApi | null = null
let requestedStep: InboxOnboardingDraftApi['step'] | undefined
+ const capture = (event: string, properties: Record<string, unknown> = {}): void => {
+ posthog.capture(event, {
+ variant: values.experimentVariant,
+ project_id: values.currentTeamId,
+ flow_version: 'ui-first-v1',
+ inbox_client: 'cloud',
+ setup_mode: values.isQuickSetup ? 'quick' : 'guided',
+ self_driving_ubp: values.featureFlags[FEATURE_FLAGS.SELF_DRIVING_UBP] ?? null,
+ automatic_implementation: values.isQuickSetup
+ ? (values.quickSetupDraft?.automatic_implementation ?? null)
+ : values.draft.automatic_implementation,
+ implementation_priority: values.draft.implementation_priority,
+ ...properties,
+ })
+ }
+
const saveDraft = async (step?: InboxOnboardingDraftApi['step']): Promise<void> => {
requestedStep = step ?? requestedStep
if (pendingSave) {
@@ -558,12 +679,16 @@ export const inboxSetupLogic = kea<inboxSetupLogicType>([
while (!values.completed) {
const step = requestedStep
const draft = step ? { ...values.draft, step } : values.draft
+ if (!values.savedState?.draft && draft.step === 'signals') {
+ return
+ }
if (objectsEqual(draft, persistedDraft ?? values.savedState?.draft)) {
return
}
const state = await signalsOnboardingCreate(String(values.currentTeamId), draft)
persistedDraft = draft
actions.setSavedState(state)
+ actions.reportInteraction()
if (step) {
actions.setEditedDraft({ ...values.draft, step })
requestedStep = undefined
@@ -584,11 +709,7 @@ export const inboxSetupLogic = kea<inboxSetupLogicType>([
if (values.inProgress) {
return
}
- posthog.capture('self-driving onboarding welcome continued', {
- variant: values.experimentVariant,
- project_id: values.currentTeamId,
- flow_version: 'ui-first-v1',
- })
+ capture('self-driving onboarding welcome continued')
actions.openSetup()
},
expose: async ({ variant }) => {
@@ -606,7 +727,10 @@ export const inboxSetupLogic = kea<inboxSetupLogicType>([
},
openSetup: () => {
actions.reportInteraction()
- router.actions.push(urls.inbox(), { onboarding_step: values.draft.step })
+ router.actions.push(
+ urls.inbox(),
+ values.savedState?.draft ? { onboarding_step: values.draft.step } : {}
+ )
},
startSetup: () => {
actions.setError(null)
@@ -648,7 +772,11 @@ export const inboxSetupLogic = kea<inboxSetupLogicType>([
await saveDraft()
actions.setSourceSetupSource(source)
} catch {
- actions.setError('Could not save your choices. Try again before connecting a source.')
+ actions.setError(
+ 'Could not save your choices. Try again before connecting a source.',
+ 'other',
+ 'draft_save_failed'
+ )
} finally {
actions.setSaving(false)
}
@@ -678,7 +806,11 @@ export const inboxSetupLogic = kea<inboxSetupLogicType>([
await saveDraft()
actions.setSourceSetupSource(null)
} catch {
- actions.setError('Could not confirm your source connection. Try again.')
+ actions.setError(
+ 'Could not confirm your source connection. Try again.',
+ 'other',
+ 'source_connection_failed'
+ )
} finally {
actions.setSaving(false)
}
@@ -697,15 +829,36 @@ export const inboxSetupLogic = kea<inboxSetupLogicType>([
}
},
reportInteraction: () => {
- if (!cache.startReported) {
- posthog.capture('self-driving onboarding started', {
- variant: values.experimentVariant,
- project_id: values.currentTeamId,
- flow_version: 'ui-first-v1',
+ if (values.savedState?.draft && cache.startReported !== values.currentTeamId) {
+ capture('self-driving onboarding started')
+ cache.startReported = values.currentTeamId
+ }
+ },
+ reportStepViewed: () => {
+ if (!values.ready || values.isQuickSetup || values.completed) {
+ return
+ }
+ const key = `${values.currentTeamId}:${values.draft.step}`
+ if (cache.viewedStep !== key) {
+ capture('self-driving onboarding step viewed', {
+ step: values.draft.step,
+ implementation_toggle_shown:
+ values.draft.step === 'github' && !!values.featureFlags[FEATURE_FLAGS.SELF_DRIVING_UBP],
+ github_connected: values.hasGithubIntegration,
+ })
+ cache.viewedStep = key
+ }
+ },
+ setError: ({ error, failedOperation, failureReason }) => {
+ if (error) {
+ capture('self-driving onboarding failed', {
+ step: values.draft.step,
+ failed_operation: failedOperation,
+ failure_reason: failureReason ?? failedOperation,
})
- cache.startReported = true
}
},
+ loadSetupFailure: () => capture('self-driving onboarding failed', { failed_operation: 'load_setup' }),
[signalSourcesLogic.actionTypes.loadSourceConfigsFailure]: () => {
actions.setError('Could not load signal sources. Try again.', 'sources')
},
@@ -714,32 +867,51 @@ export const inboxSetupLogic = kea<inboxSetupLogicType>([
},
patchDraft: async ({ patch }, breakpoint) => {
actions.reportInteraction()
+ const previousImplementation = values.draft.automatic_implementation
actions.setEditedDraft({ ...values.draft, ...patch })
+ if (
+ patch.automatic_implementation !== undefined &&
+ patch.automatic_implementation !== previousImplementation
+ ) {
+ capture('self-driving onboarding implementation changed', {
+ previous_value: previousImplementation,
+ new_value: patch.automatic_implementation,
+ })
+ }
actions.setError(null)
await breakpoint(750)
try {
await saveDraft()
} catch {
- actions.setError('Could not save your choices. Try again before leaving setup.')
+ actions.setError(
+ 'Could not save your choices. Try again before leaving setup.',
+ 'other',
+ 'draft_save_failed'
+ )
}
},
connectGithub: async ({ url }) => {
if (values.saving) {
return
}
+ actions.reportInteraction()
actions.setSaving(true)
actions.setError(null)
try {
await saveDraft()
window.location.assign(url)
} catch {
- actions.setError('Could not save your choices. Try again before connecting GitHub.')
+ actions.setError(
+ 'Could not save your choices. Try again before connecting GitHub.',
+ 'other',
+ 'github_redirect_failed'
+ )
} finally {
actions.setSaving(false)
}
},
[scoutSuggestionsLogic.actionTypes.loadSuggestionsSuccess]: ({ suggestionSet }) => {
- if (!values.started || cache.suggestionsChecked || !suggestionSet) {
+ if (values.isQuickSetup || !values.started || cache.suggestionsChecked || !suggestionSet) {
return
}
cache.suggestionsChecked = true
@@ -792,23 +964,22 @@ export const inboxSetupLogic = kea<inboxSetupLogicType>([
actions.setError(null)
try {
await saveDraft(step)
- if (step !== previousStep) {
- posthog.capture('self-driving onboarding step completed', {
+ const steps: InboxOnboardingDraftApi['step'][] = ['signals', 'scouts', 'github']
+ if (steps.indexOf(step) > steps.indexOf(previousStep)) {
+ capture('self-driving onboarding step completed', {
step: previousStep,
- variant: values.experimentVariant,
- project_id: values.currentTeamId,
skipped: previousStep === 'scouts' && !values.draft.suggestions.length,
})
}
- router.actions.replace(urls.inbox(), { ...router.values.searchParams, onboarding_step: step })
- posthog.capture('self-driving onboarding step viewed', {
- step,
- variant: values.experimentVariant,
- project_id: values.currentTeamId,
+ router.actions.replace(urls.inbox(), {
+ ...router.values.searchParams,
+ onboarding_step: values.savedState?.draft ? step : undefined,
})
} catch (error) {
actions.setError(
- error instanceof ApiError ? error.detail : 'Could not save your choices. Try again.'
+ error instanceof ApiError ? error.detail : 'Could not save your choices. Try again.',
+ 'other',
+ 'draft_save_failed'
)
} finally {
actions.setSaving(false)
@@ -816,7 +987,7 @@ export const inboxSetupLogic = kea<inboxSetupLogicType>([
},
retry: () => {
if (values.failedOperation === 'activation') {
- actions.activate()
+ actions.activate('retry')
} else if (values.failedOperation === 'sources') {
actions.setError(null)
actions.refreshSources()
@@ -831,17 +1002,41 @@ export const inboxSetupLogic = kea<inboxSetupLogicType>([
actions.startSetup()
}
},
- activate: async () => {
+ resumeQuickSetup: () => {
+ if (values.shouldResumeQuickSetup && !cache.quickSetupResumed) {
+ cache.quickSetupResumed = true
+ actions.activateQuickSetup('github_return')
+ }
+ },
+ activateQuickSetup: async ({ activationSource }) => {
+ if (values.saving || !values.quickSetupReady || values.completed || !values.isQuickSetup) {
+ return
+ }
+ actions.setEditedDraft(values.quickSetupDraft!)
+ actions.activate(activationSource)
+ },
+ activate: async ({ activationSource }) => {
if (values.saving || cache.activating || values.activationDisabledReason) {
return
}
actions.reportInteraction()
+ capture('self-driving onboarding activation requested', {
+ activation_source: activationSource,
+ github_connected: values.hasGithubIntegration,
+ })
cache.activating = true
actions.setSaving(true)
actions.setError(null)
let draft = values.draft
const projectId = String(values.currentTeamId)
try {
+ if (values.isQuickSetup) {
+ const state = await signalsOnboardingExposeCreate(projectId, { variant: 'test-github' })
+ actions.setSavedState(state)
+ if (state.variant !== 'test-github') {
+ throw new Error('Onboarding assignment changed. Reload the page to continue.')
+ }
+ }
await saveDraft()
actions.setSavedState(await signalsOnboardingList(projectId))
if (values.completed) {
@@ -932,6 +1127,15 @@ export const inboxSetupLogic = kea<inboxSetupLogicType>([
} else if (source.enabled) {
await signalsSourceConfigsCreate(projectId, source)
}
+ if (source.enabled && !existing?.enabled) {
+ captureSignalSourceConnected({
+ sourceProduct: source.source_product,
+ sourceType: source.source_type,
+ isFirstConnection: !existing,
+ viaSetupWizard: false,
+ setupMode: values.isQuickSetup ? 'quick' : 'guided',
+ })
+ }
}
for (const scanner of scanners) {
const enabled = draft.scanner_ids.includes(scanner.id)
@@ -939,6 +1143,35 @@ export const inboxSetupLogic = kea<inboxSetupLogicType>([
await visionScannersPartialUpdate(projectId, scanner.id, { emits_signals: enabled })
}
}
+ if (values.isQuickSetup) {
+ const scoutProjectId = String(teamLogic.values.currentProjectId ?? values.currentTeamId)
+ if (scoutProjectId !== projectId) {
+ await signalsConfigCreate(scoutProjectId, { autostart_enabled: false })
+ }
+ const configs = await signalsSourceConfigsList(scoutProjectId, { limit: 1000 })
+ const source = configs.results.find(
+ (item) =>
+ item.source_product === 'signals_scout' && item.source_type === 'cross_source_issue'
+ )
+ if (source) {
+ await signalsSourceConfigsPartialUpdate(scoutProjectId, source.id, { enabled: true })
+ } else {
+ await signalsSourceConfigsCreate(scoutProjectId, {
+ source_product: 'signals_scout',
+ source_type: 'cross_source_issue',
+ enabled: true,
+ })
+ }
+ if (!source?.enabled) {
+ captureSignalSourceConnected({
+ sourceProduct: 'signals_scout',
+ sourceType: 'cross_source_issue',
+ isFirstConnection: !source,
+ viaSetupWizard: false,
+ setupMode: 'quick',
+ })
+ }
+ }
for (const suggestion of draft.suggestions) {
if (
!currentScouts.some(
@@ -968,6 +1201,9 @@ export const inboxSetupLogic = kea<inboxSetupLogicType>([
}
}
actions.setSavedState(await signalsOnboardingCompleteCreate(projectId, draft))
+ if (!values.isQuickSetup) {
+ capture('self-driving onboarding step completed', { step: 'github', skipped: false })
+ }
actions.loadSourceConfigs()
actions.loadVisionScanners()
actions.loadScoutConfigs()
@@ -979,11 +1215,6 @@ export const inboxSetupLogic = kea<inboxSetupLogicType>([
: 'Could not finish setup. Your choices are saved. Retry activation.',
'activation'
)
- posthog.capture('self-driving onboarding failed', {
- variant: values.experimentVariant,
- project_id: values.currentTeamId,
- step: draft.step,
- })
} finally {
actions.setSaving(false)
cache.activating = false
@@ -996,7 +1227,9 @@ export const inboxSetupLogic = kea<inboxSetupLogicType>([
},
[featureFlagLogic.actionTypes.setFeatureFlags]: () => {
if (
- ['control', 'test'].includes(String(values.featureFlags[FEATURE_FLAGS.INBOX_UI_ONBOARDING])) &&
+ ['control', 'test-ui', 'test-github'].includes(
+ String(values.featureFlags[FEATURE_FLAGS.INBOX_UI_ONBOARDING])
+ ) &&
!values.savedState &&
!values.savedStateLoading &&
values.currentTeamId
diff --git a/products/signals/frontend/inbox/logics/scoutSuggestionsLogic.ts b/products/signals/frontend/inbox/logics/scoutSuggestionsLogic.ts
index 7c0a7937c3ee..882fcab5fd68 100644
--- a/products/signals/frontend/inbox/logics/scoutSuggestionsLogic.ts
+++ b/products/signals/frontend/inbox/logics/scoutSuggestionsLogic.ts
@@ -40,7 +40,7 @@ const REFRESH_POLL_INTERVAL_MS = 15_000
* scan itself may run for up to 30 minutes and wait as long again for a worker, so this sits past
* both rather than giving up while the workflow is still allowed to finish.
*/
-const REFRESH_POLL_TIMEOUT_MS = 60 * 60_000
+export const REFRESH_POLL_TIMEOUT_MS = 60 * 60_000
/** How often the elapsed line is redrawn. Minutes are the unit, so seconds-precision buys nothing. */
const REFRESH_ELAPSED_TICK_MS = 10_000
diff --git a/products/signals/frontend/inbox/utils/quickInboxSetup.ts b/products/signals/frontend/inbox/utils/quickInboxSetup.ts
new file mode 100644
index 000000000000..a3d62f1b3f54
--- /dev/null
+++ b/products/signals/frontend/inbox/utils/quickInboxSetup.ts
@@ -0,0 +1,45 @@
+import type { ReplayScannerApi } from '../../../../replay_vision/frontend/generated/api.schemas'
+import type { InboxOnboardingDraftApi, SignalScoutConfigApi } from '../../generated/api.schemas'
+import { InboxSetupSource, newInboxSetupDraft } from './inboxSetup'
+
+export function quickInboxSetupDraft(
+ sources: InboxSetupSource[],
+ scanners: ReplayScannerApi[],
+ configs: SignalScoutConfigApi[]
+): InboxOnboardingDraftApi | null {
+ const general = configs.find(
+ (config) =>
+ config.skill_name === 'signals-scout-general' &&
+ config.scout_origin === 'canonical' &&
+ !config.deprecation &&
+ !config.lifecycle_locked
+ )
+ if (!general) {
+ return null
+ }
+ return {
+ ...newInboxSetupDraft(
+ sources,
+ scanners.filter((scanner) => scanner.enabled).map((scanner) => scanner.id)
+ ),
+ step: 'github',
+ suggestions: [
+ {
+ id: `builtin:${general.id}`,
+ kind: 'canonical',
+ skill_name: general.skill_name,
+ title: 'General scout',
+ why_here: 'Explore available data and investigate what needs your attention.',
+ description: '',
+ draft_body: '',
+ proposed_config: {
+ run_interval_minutes: general.run_interval_minutes ?? 1440,
+ run_cron_schedule: general.run_cron_schedule,
+ emit: true,
+ },
+ gap: true,
+ confidence: 'medium',
+ },
+ ],
+ }
+}
diff --git a/services/mcp/src/api/generated.ts b/services/mcp/src/api/generated.ts
index 6a00d2a8c5ef..0fff80546250 100644
--- a/services/mcp/src/api/generated.ts
+++ b/services/mcp/src/api/generated.ts
@@ -60921,25 +60921,63 @@ export namespace Schemas {
/**
* * `control` - Control
- * * `test` - Focused steps
+ * * `test-ui` - Focused steps
+ * * `test-github` - Activate and explore
*/
export type InboxOnboardingVariantEnum = typeof InboxOnboardingVariantEnum[keyof typeof InboxOnboardingVariantEnum];
export const InboxOnboardingVariantEnum = {
Control: 'control',
- Test: 'test',
+ TestUi: 'test-ui',
+ TestGithub: 'test-github',
} as const;
export interface InboxOnboardingExposure {
/** Assigned experiment variant at the eligible Inbox impression.
*
* * `control` - Control
- * * `test` - Focused steps */
+ * * `test-ui` - Focused steps
+ * * `test-github` - Activate and explore */
variant: InboxOnboardingVariantEnum;
}
+ /**
+ * * `pending` - Pending
+ * * `started` - Started
+ * * `skipped` - Unavailable
+ * * `failed` - Failed
+ */
+ export type InboxOnboardingJobStatusEnum = typeof InboxOnboardingJobStatusEnum[keyof typeof InboxOnboardingJobStatusEnum];
+
+
+ export const InboxOnboardingJobStatusEnum = {
+ Pending: 'pending',
+ Started: 'started',
+ Skipped: 'skipped',
+ Failed: 'failed',
+ } as const;
+
+ export interface InboxOnboardingJobs {
+ /** Dispatch status of the first general scout run.
+ *
+ * * `pending` - Pending
+ * * `started` - Started
+ * * `skipped` - Unavailable
+ * * `failed` - Failed */
+ scout: InboxOnboardingJobStatusEnum;
+ /** Dispatch status of personalized scout recommendations.
+ *
+ * * `pending` - Pending
+ * * `started` - Started
+ * * `skipped` - Unavailable
+ * * `failed` - Failed */
+ recommendations: InboxOnboardingJobStatusEnum;
+ }
+
export interface InboxOnboardingState {
+ /** Background work started by quick activation. */
+ jobs?: InboxOnboardingJobs;
/** Saved setup choices, without activating them. */
draft: InboxOnboardingDraft | null;
/**
@@ -60950,7 +60988,8 @@ export namespace Schemas {
/** Variant recorded at the first eligible impression.
*
* * `control` - Control
- * * `test` - Focused steps */
+ * * `test-ui` - Focused steps
+ * * `test-github` - Activate and explore */
variant: InboxOnboardingVariantEnum | null;
}