: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.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
feat(signals): queue activity summaries for users with only mcp reads (#126916)
posthog[bot]f5cd6e3adafa
diff --git a/products/signals/backend/activity_summary/config.py b/products/signals/backend/activity_summary/config.pyindex 88d27d06df61..ddcd451fa135 100644--- a/products/signals/backend/activity_summary/config.py+++ b/products/signals/backend/activity_summary/config.py@@ -48,6 +48,8 @@ class SourceWeights:repeat_view_days: float = 0.0# A new day of opening a product scene.scene_views: float = 0.0+ # A distinct MCP session after the pair's watermark, without plumbing routes.+ mcp: float = 1.0@frozen@@ -114,6 +116,8 @@ class ActivitySummaryConfig:mcp_buffer_days: int = 10# Renders the buffer in the input. Apart from `mcp_buffer_enabled`, so the buffer can fill before the prompt uses it.mcp_render_enabled: bool = False+ # Drains the buffer's dirty set into the queue, so a pair with only MCP calls can come due. Needs `mcp_render_enabled`.+ mcp_queue_enabled: bool = FalseDISABLED = ActivitySummaryConfig()@@ -260,6 +264,7 @@ def parse_config(payload: Any) -> ActivitySummaryConfig:_positive_int(payload.get("mcp_buffer_days"), defaults.mcp_buffer_days), MAX_MCP_BUFFER_DAYS),mcp_render_enabled=_bool(payload.get("mcp_render_enabled"), defaults.mcp_render_enabled),+ mcp_queue_enabled=_bool(payload.get("mcp_queue_enabled"), defaults.mcp_queue_enabled),)diff --git a/products/signals/backend/activity_summary/inputs.py b/products/signals/backend/activity_summary/inputs.pyindex 36fc0520a53d..ea5c0d07d92d 100644--- a/products/signals/backend/activity_summary/inputs.py+++ b/products/signals/backend/activity_summary/inputs.py@@ -164,7 +164,7 @@ class McpRead:read_error: bool = False-def _mcp_redis_client() -> redis.Redis:+def mcp_redis_client() -> redis.Redis:return get_client(settings.ACTIVITY_SUMMARY_MCP_BUFFER_REDIS_URL or None,socket_timeout=MCP_READ_TIMEOUT_SECONDS,@@ -179,7 +179,7 @@ def user_mcp_records(end: datetime.datetime,*,max_days: int,- redis_client: Callable[[], redis.Redis] = _mcp_redis_client,+ redis_client: Callable[[], redis.Redis] = mcp_redis_client,) -> McpRead:"""The user's buffered MCP calls in [start, end), from the newest `max_days` UTC days, in one pipeline.diff --git a/products/signals/backend/activity_summary/queue.py b/products/signals/backend/activity_summary/queue.pyindex 565e6e65d0f7..d3f2798933f3 100644--- a/products/signals/backend/activity_summary/queue.py+++ b/products/signals/backend/activity_summary/queue.py@@ -41,13 +41,17 @@ from django.db.models import (from django.db.models.expressions import Combinablefrom django.db.models.functions import Cast, Coalesce, Extract, Greatest, Ln, RowNumber+import redis+import structlog+from posthog.dataclasses import frozenfrom posthog.models import ActivityLog, FileSystemViewLog, Teamfrom products.signals.backend import org_rolloutfrom products.signals.backend.activity_summary.config import ActivitySummaryConfig, SourceWeights-from products.signals.backend.activity_summary.inputs import TASK_ORIGIN_PRODUCTS+from products.signals.backend.activity_summary.inputs import TASK_ORIGIN_PRODUCTS, mcp_redis_clientfrom products.signals.backend.activity_summary.logic import EXCEPTION_ERROR_PREFIX+from products.signals.backend.activity_summary.mcp_buffer import DIRTY_KEY, parse_record, records_key, window_daysfrom products.signals.backend.activity_summary.prompt import COMPUTED_MAX_CHARS, PROMPT_VERSION, system_promptfrom products.signals.backend.activity_summary.render import (DEFAULT_LIMITS,@@ -60,7 +64,9 @@ from products.signals.backend.activity_summary.render import (SCENE_VIEW_TYPE,SCOUT_CLIENT_PREFIX,SETUP_SCOPES,+ McpItem,RenderLimits,+ is_plumbing_route,)from products.signals.backend.activity_summary.summaries import DEFAULT_MODEL, MAX_ATTEMPTS, MODEL_PRICES, cost_usdfrom products.signals.backend.models import (@@ -70,6 +76,8 @@ from products.signals.backend.models import ()from products.tasks.backend.facade.user_task_summaries import list_user_task_times+logger = structlog.get_logger(__name__)+DAY = datetime.timedelta(days=1)# Fewer characters per token than the render estimate, so the bound is high, not low._BOUND_CHARS_PER_TOKEN = 2@@ -92,6 +100,9 @@ TIER_PAYING = "paying"TIER_FREE = "free"# A summary younger than this many target intervals counts as fresh on the tick event._FRESH_STALENESS = 2+# One tick drains at most this many members of the MCP dirty set. The other members wait for the next tick.+MAX_MCP_FEED_PAIRS = 2_000+_MCP_FEED_BATCH = 200# Why the queue picked a pair.TRIGGER_ACTIVITY = "activity"@@ -100,7 +111,9 @@ TRIGGER_VIEWS = "views"# A pair with no summary and a pending score below `min_score`, due on its days with views.TRIGGER_COLD_START_VIEWS = "cold_start_views"TRIGGER_STALE = "stale"-TRIGGERS = (TRIGGER_ACTIVITY, TRIGGER_VIEWS, TRIGGER_COLD_START_VIEWS, TRIGGER_STALE)+# MCP sessions make up at least half of the weighted pending score.+TRIGGER_MCP = "mcp"+TRIGGERS = (TRIGGER_ACTIVITY, TRIGGER_VIEWS, TRIGGER_COLD_START_VIEWS, TRIGGER_STALE, TRIGGER_MCP)VIEW_TRIGGERS = frozenset({TRIGGER_VIEWS, TRIGGER_COLD_START_VIEWS})@@ -585,6 +598,122 @@ def feed_queue(config: ActivitySummaryConfig, now: datetime.datetime, team_ids:return fed+@frozen+class McpFeed:+ pairs: int = 0+ sessions: int = 0+ # Dirty members of teams that are not enrolled, or members that do not parse.+ ignored: int = 0+ error: bool = False+++def _mcp_pair(member: bytes | str | int | float, team_ids: set[int]) -> ActivitySummaryPair | None:+ text = member.decode() if isinstance(member, bytes) else str(member)+ team_id, _, user_id = text.partition(":")+ try:+ pair = ActivitySummaryPair(team_id=int(team_id), user_id=int(user_id))+ except ValueError:+ return None+ return pair if pair.team_id in team_ids else None+++def _mcp_sessions(records: Iterable[McpItem]) -> tuple[int, datetime.datetime | None]:+ """The distinct sessions of the records without plumbing routes, and the time of the newest one.++ A record with no session id counts as its own session."""+ sessions: set[str] = set()+ without_session = 0+ last_at: datetime.datetime | None = None+ for record in records:+ if is_plumbing_route(record.route_name):+ continue+ if record.session_id:+ sessions.add(record.session_id)+ else:+ without_session += 1+ last_at = record.at if last_at is None else max(last_at, record.at)+ return len(sessions) + without_session, last_at+++def _read_mcp(+ client: redis.Redis,+ pairs: list[ActivitySummaryPair],+ watermarks: dict[ActivitySummaryPair, datetime.datetime | None],+ config: ActivitySummaryConfig,+ now: datetime.datetime,+) -> dict[ActivitySummaryPair, list[McpItem]]:+ """The buffered records of each pair after its watermark, from the newest `mcp_buffer_days` days, in one pipeline."""+ window_start = now - datetime.timedelta(days=config.limits.window_days)+ starts: dict[ActivitySummaryPair, datetime.datetime] = {}+ keys: list[tuple[ActivitySummaryPair, str]] = []+ for pair in pairs:+ watermark = watermarks.get(pair)+ starts[pair] = window_start if watermark is None else max(window_start, watermark)+ for day in window_days(starts[pair], now, config.mcp_buffer_days):+ keys.append((pair, records_key(pair.team_id, pair.user_id, day)))+ pipeline = client.pipeline(transaction=False)+ for _, key in keys:+ pipeline.lrange(key, 0, -1)+ records: dict[ActivitySummaryPair, list[McpItem]] = {pair: [] for pair in pairs}+ for (pair, _), values in zip(keys, pipeline.execute()):+ for value in values:+ record = parse_record(value)+ if record is not None and record.at > starts[pair]:+ records[pair].append(record)+ return records+++def _set_mcp_score(pair: ActivitySummaryPair, score: float, last_at: datetime.datetime | None) -> None:+ fields: dict[str, Any] = {+ # Postgres reads the old `pending_mcp_score` on the right side of every assignment.+ "pending_score": F("pending_score") - F("pending_mcp_score") + score,+ "pending_mcp_score": score,+ }+ if last_at is not None:+ fields["last_activity_at"] = Greatest("last_activity_at", last_at)+ UserActivitySummaryQueueState.objects.for_team(pair.team_id).filter(user_id=pair.user_id).update(**fields)+++def feed_mcp_queue(+ config: ActivitySummaryConfig,+ now: datetime.datetime,+ team_ids: list[int],+ redis_client: Callable[[], redis.Redis] = mcp_redis_client,+) -> McpFeed:+ """Drain the MCP buffer's dirty set into the queue state of the enrolled pairs.++ Each drained pair gets its MCP score again from the records after its watermark: the `mcp` weight+ times its distinct sessions. The score replaces the earlier MCP part, so a record never counts twice.+ The buffer is optional context, so this never raises. A member that left the set before an error+ comes back with the user's next MCP call.+ """+ enrolled = set(team_ids)+ pairs_fed = sessions_fed = ignored = 0+ try:+ client = redis_client()+ drained = 0+ while drained < MAX_MCP_FEED_PAIRS:+ members = client.spop(DIRTY_KEY, min(_MCP_FEED_BATCH, MAX_MCP_FEED_PAIRS - drained))+ if not members:+ break+ drained += len(members)+ pairs = sorted({pair for member in members if (pair := _mcp_pair(member, enrolled)) is not None})+ ignored += len(members) - len(pairs)+ if not pairs:+ continue+ records = _read_mcp(client, pairs, _watermarks(sorted({pair.team_id for pair in pairs})), config, now)+ counted = {pair: _mcp_sessions(records[pair]) for pair in pairs}+ _create_missing_states([pair for pair, (sessions, _) in counted.items() if sessions])+ for pair, (sessions, last_at) in counted.items():+ _set_mcp_score(pair, sessions * config.source_weights.mcp, last_at)+ pairs_fed += sessions > 0+ sessions_fed += sessions+ except Exception:+ logger.warning("activity_summary.mcp_queue_feed_failed", exc_info=True)+ return McpFeed(pairs=pairs_fed, sessions=sessions_fed, ignored=ignored, error=True)+ return McpFeed(pairs=pairs_fed, sessions=sessions_fed, ignored=ignored)++def seed_queue(config: ActivitySummaryConfig, team_ids: list[int], end: datetime.datetime) -> int:"""Set the queue state of these teams from the rows in the window before `end`.@@ -609,7 +738,7 @@ def seed_queue(config: ActivitySummaryConfig, team_ids: list[int], end: datetimewith transaction.atomic():# nosemgrep: idor-lookup-without-team (operator backfill with no user input; filtered to the given teams)UserActivitySummaryQueueState.all_teams.filter(team_id__in=team_ids).update(- pending_units=0, pending_score=0.0, pending_view_score=0.0, view_active_days=0+ pending_units=0, pending_score=0.0, pending_view_score=0.0, pending_mcp_score=0.0, view_active_days=0)_add_pending(pending)_add_pending(viewed, views)@@ -643,7 +772,12 @@ def sync_pair_state(team_id: int, user_id: int) -> None:watermark = stored["input_watermark"]cleared = {name: F(name) if watermark is None else Case(When(last_activity_at__lte=watermark, then=zero), default=F(name))- for name, zero in (("pending_units", 0), ("pending_score", 0.0), ("pending_view_score", 0.0))+ for name, zero in (+ ("pending_units", 0),+ ("pending_score", 0.0),+ ("pending_view_score", 0.0),+ ("pending_mcp_score", 0.0),+ )}UserActivitySummaryQueueState.objects.for_team(team_id).filter(user_id=user_id).update(**_state_fields(stored), **cleared@@ -714,6 +848,7 @@ def _due(states: QuerySet, config: ActivitySummaryConfig, now: datetime.datetimeWhen(stale=True, then=Value(TRIGGER_STALE)),# A due pair below `min_score` that is not stale is due only on its days with views.When(weighted_score__lt=config.min_score, then=Value(TRIGGER_COLD_START_VIEWS)),+ When(pending_mcp_score__gte=F("weighted_score") / 2, then=Value(TRIGGER_MCP)),When(write_score__lt=F("weighted_score") / 2, then=Value(TRIGGER_VIEWS)),default=Value(TRIGGER_ACTIVITY),)diff --git a/products/signals/backend/activity_summary/render.py b/products/signals/backend/activity_summary/render.pyindex 6f77d236dd14..1a52ae17d8bf 100644--- a/products/signals/backend/activity_summary/render.py+++ b/products/signals/backend/activity_summary/render.py@@ -1090,7 +1090,7 @@ def view_units(return sorted(units, key=lambda unit: (unit.at, unit.text))-def _is_plumbing_route(route_name: str) -> bool:+def is_plumbing_route(route_name: str) -> bool:return route_name in MCP_PLUMBING_ROUTES or route_name.startswith(MCP_PLUMBING_ROUTE_PREFIXES)@@ -1143,7 +1143,7 @@ def _mcp_sessions(records: Iterable[McpItem], shown_intents: frozenset[str], droA record without a session id is its own session, and a long pause splits a session in two."""grouped: dict[tuple[str, int], list[McpItem]] = {}for index, record in enumerate(records):- if _is_plumbing_route(record.route_name):+ if is_plumbing_route(record.route_name):drops[Drop.MCP_PLUMBING_ROUTE] += 1continuegrouped.setdefault((record.session_id, -1) if record.session_id else ("", index), []).append(record)diff --git a/products/signals/backend/activity_summary/tick.py b/products/signals/backend/activity_summary/tick.pyindex 37ad55c9addc..c7f350447d80 100644--- a/products/signals/backend/activity_summary/tick.py+++ b/products/signals/backend/activity_summary/tick.py@@ -51,8 +51,10 @@ from products.signals.backend.activity_summary.queue import (VIEW_TRIGGERS,ActivitySummaryPair,ActivitySummaryTierStats,+ McpFeed,daily_usage,enrollment,+ feed_mcp_queue,feed_queue,is_team_enrolled_for_generation,max_update_cost_usd,@@ -136,6 +138,7 @@ class ActivitySummaryTickPlan:# The days of the MCP intent buffer each update reads. None when `mcp_render_enabled` is off.mcp_buffer_days: int | None = Noneemit_profile_embeddings: bool = False+ mcp_feed: McpFeed = dataclasses.field(default_factory=McpFeed)@frozen@@ -184,6 +187,7 @@ class ActivitySummaryTickResult:refresh_builds: int = 0# Due pairs at the start of the tick, per trigger.due_by_trigger: dict[str, int] = dataclasses.field(default_factory=dict)+ mcp_feed: McpFeed = dataclasses.field(default_factory=McpFeed)def plan_tick(limit: int | None, now: datetime.datetime) -> ActivitySummaryTickPlan:@@ -207,6 +211,9 @@ def plan_tick(limit: int | None, now: datetime.datetime) -> ActivitySummaryTickPif config.enabled:# The cursors move even when a cap stops the tick, so new rows do not pile up behind them.feed_queue(config, now, enrolled.team_ids)+ mcp_feed = McpFeed()+ if config.enabled and config.mcp_queue_enabled and config.mcp_render_enabled:+ mcp_feed = feed_mcp_queue(config, now, enrolled.team_ids)usage = daily_usage(now) if enabled else Noneupdates_left = max(0, config.max_pairs_per_day - usage.updates) if usage else 0cost_left = max(0.0, config.max_cost_usd_per_day - usage.cost_usd) if usage else 0.0@@ -248,6 +255,7 @@ def plan_tick(limit: int | None, now: datetime.datetime) -> ActivitySummaryTickPrebuild_before=config.rebuild_before,max_versions=config.max_versions,mcp_buffer_days=config.mcp_buffer_days if config.mcp_render_enabled else None,+ mcp_feed=mcp_feed,)@@ -420,6 +428,7 @@ def capture_tick(result: ActivitySummaryTickResult) -> None:new_builds=result.new_builds,refresh_builds=result.refresh_builds,due_by_trigger=result.due_by_trigger,+ **{f"mcp_feed_{name}": value for name, value in dataclasses.asdict(result.mcp_feed).items()},**dataclasses.asdict(result.enrollment),)ph_background_capture()(@@ -436,6 +445,7 @@ def capture_tick(result: ActivitySummaryTickResult) -> None:"new_builds": result.new_builds,"refresh_builds": result.refresh_builds,**{f"due_{trigger}": result.due_by_trigger.get(trigger, 0) for trigger in TRIGGERS},+ **{f"mcp_feed_{name}": value for name, value in dataclasses.asdict(result.mcp_feed).items()},**dataclasses.asdict(result.enrollment),**{f"{tier.tier}_{name}": getattr(tier, name)@@ -568,6 +578,7 @@ class ActivitySummaryTickWorkflow:new_builds=builds[True],refresh_builds=builds[False],due_by_trigger=plan.due_by_trigger,+ mcp_feed=plan.mcp_feed,)await workflow.execute_activity(capture_activity_summary_tick_activity,diff --git a/products/signals/backend/migrations/0228_useractivitysummaryqueuestate_pending_mcp_score.py b/products/signals/backend/migrations/0228_useractivitysummaryqueuestate_pending_mcp_score.pynew file mode 100644index 000000000000..01c2317e5a72--- /dev/null+++ b/products/signals/backend/migrations/0228_useractivitysummaryqueuestate_pending_mcp_score.py@@ -0,0 +1,15 @@+from django.db import migrations, models+++class Migration(migrations.Migration):+ dependencies = [+ ("signals", "0227_personalinboxranking_checked_at"),+ ]++ operations = [+ migrations.AddField(+ model_name="useractivitysummaryqueuestate",+ name="pending_mcp_score",+ field=models.FloatField(default=0.0),+ ),+ ]diff --git a/products/signals/backend/migrations/max_migration.txt b/products/signals/backend/migrations/max_migration.txtindex fc3442974dc3..1950e812051f 100644--- a/products/signals/backend/migrations/max_migration.txt+++ b/products/signals/backend/migrations/max_migration.txt@@ -1 +1 @@-0227_personalinboxranking_checked_at+0228_useractivitysummaryqueuestate_pending_mcp_scorediff --git a/products/signals/backend/models.py b/products/signals/backend/models.pyindex 92ebaff3dbe6..3e9c7abefbc6 100644--- a/products/signals/backend/models.py+++ b/products/signals/backend/models.py@@ -4265,6 +4265,8 @@ class UserActivitySummaryQueueState(TeamScopedRootMixin, UUIDModel):pending_view_score = models.FloatField(default=0.0)# Distinct days with an opened object or scene in the window, for the first summary of a view-only pair.view_active_days = models.IntegerField(default=0)+ # The MCP part of `pending_score`. The MCP feed computes it again from the buffer, so a record counts once.+ pending_mcp_score = models.FloatField(default=0.0)last_activity_at = models.DateTimeField(null=True, blank=True)# The pair is due when this is empty or past. A copy of `UserActivitySummary.next_eligible_at`.due_at = models.DateTimeField(null=True, blank=True)diff --git a/products/signals/backend/test/test_activity_summary_tick.py b/products/signals/backend/test/test_activity_summary_tick.pyindex 0e03597f9a9f..24af42a89c51 100644--- a/products/signals/backend/test/test_activity_summary_tick.py+++ b/products/signals/backend/test/test_activity_summary_tick.py@@ -13,6 +13,7 @@ from unittest.mock import AsyncMock, MagicMock, patchfrom django.test import override_settingsimport redis+import fakeredisfrom parameterized import parameterizedfrom temporalio import activityfrom temporalio.client import Client, ScheduleState@@ -31,6 +32,7 @@ from products.signals.backend.activity_summary import ()from products.signals.backend.activity_summary.computed import MAX_OWNED, MAX_WATCHEDfrom products.signals.backend.activity_summary.config import ActivitySummaryConfig, SourceWeights, parse_config+from products.signals.backend.activity_summary.mcp_buffer import DIRTY_KEY, build_record, records_keyfrom products.signals.backend.activity_summary.prompt import (MAX_HEADLINE_CHARS,MAX_LABEL_CHARS,@@ -47,6 +49,7 @@ from products.signals.backend.activity_summary.queue import (daily_usage,enrolled_team_ids,enrollment,+ feed_mcp_queue,feed_queue,is_team_enrolled_for_generation,is_team_enrolled_for_read,@@ -163,7 +166,6 @@ _CONFIG_CASES: list[tuple[str, Any, ActivitySummaryConfig]] = ["max_org_share": 0.3,"self_driving_organization_percentage": 12.5,"deny_organization_ids": ["org-b", 4],- "source_weights": {"new_views": 1, "repeat_view_days": 0.25},"min_score": 4.5,"view_update_interval_hours": 72,"cold_start_min_active_days": 5,@@ -173,6 +175,8 @@ _CONFIG_CASES: list[tuple[str, Any, ActivitySummaryConfig]] = ["mcp_calls_per_day": 20,"mcp_buffer_days": 14,"mcp_render_enabled": True,+ "mcp_queue_enabled": True,+ "source_weights": {"new_views": 1, "repeat_view_days": 0.25, "mcp": 2},},ActivitySummaryConfig(enabled=True,@@ -189,7 +193,7 @@ _CONFIG_CASES: list[tuple[str, Any, ActivitySummaryConfig]] = [max_org_share=0.3,self_driving_organization_percentage=12.5,deny_organization_ids=("org-b",),- source_weights=SourceWeights(new_views=1.0, repeat_view_days=0.25),+ source_weights=SourceWeights(new_views=1.0, repeat_view_days=0.25, mcp=2.0),min_score=4.5,view_update_interval_hours=72.0,cold_start_min_active_days=5,@@ -199,6 +203,7 @@ _CONFIG_CASES: list[tuple[str, Any, ActivitySummaryConfig]] = [mcp_calls_per_day=20,mcp_buffer_days=14,mcp_render_enabled=True,+ mcp_queue_enabled=True,),),(@@ -897,7 +902,7 @@ class TestActivitySummaryQueue(BaseTest):assert [(pair.user_id, pair.trigger) for pair in selection.pairs] == [(self.user.id, trigger)][: bool(trigger)]assert selection.due_by_trigger == {- name: int(name == trigger) for name in ("activity", "views", "cold_start_views", "stale")+ name: int(name == trigger) for name in ("activity", "views", "cold_start_views", "stale", "mcp")}def test_the_feed_counts_one_repeat_day_for_many_reopens_of_a_known_object_in_a_day(self) -> None:@@ -956,6 +961,101 @@ class TestActivitySummaryQueue(BaseTest):feed_queue(config, later)assert self._select(seed=False, now=later) == [(self.team.id, self.user.id)]+ def _mcp_calls(self, redis: fakeredis.FakeRedis, calls: list[tuple[str, str, float]], team: Team | None = None):+ records = [+ build_record(+ team_id=(team or self.team).id,+ user_id=self.user.id,+ session_id=session_id,+ route_name=route_name,+ intent="Find why signups dropped",+ at=NOW - datetime.timedelta(hours=hours_ago),+ )+ for session_id, route_name, hours_ago in calls+ ]+ for record in records:+ redis.rpush(records_key(record.team_id, record.user_id, record.day), record.value)+ redis.sadd(DIRTY_KEY, f"{record.team_id}:{record.user_id}")++ @parameterized.expand(+ [+ ("three sessions", [("s1", "insights-list", 3), ("s2", "insights-list", 2), ("", "insights-list", 1)], 3),+ (+ "many calls in one session",+ [("s1", "insights-list", 3), ("s1", "insights-detail", 2), ("s1", "query-create", 1)],+ 1,+ ),+ (+ "plumbing routes and calls before the watermark",+ [+ ("s1", "users-detail", 3),+ ("s2", "project_llm_skills-list", 2),+ ("s3", "insights-list", 30),+ ("s4", "insights-list", 1),+ ],+ 1,+ ),+ ]+ )+ def test_the_mcp_feed_scores_sessions_and_counts_a_record_once(+ self, _name: str, calls: list[tuple[str, str, float]], sessions: int+ ) -> None:+ watermark = NOW - datetime.timedelta(hours=24)+ self._summary(self.user, generated_at=watermark, input_watermark=watermark)+ redis = fakeredis.FakeRedis()+ self._mcp_calls(redis, calls)+ config = self._config()++ feeds = [feed_mcp_queue(config, NOW, [self.team.id], redis_client=lambda: redis)]+ redis.sadd(DIRTY_KEY, f"{self.team.id}:{self.user.id}")+ feeds.append(feed_mcp_queue(config, NOW, [self.team.id], redis_client=lambda: redis))++ assert [(feed.pairs, feed.sessions, feed.error) for feed in feeds] == [(1, sessions, False)] * 2+ state = UserActivitySummaryQueueState.objects.for_team(self.team.id).get(user_id=self.user.id)+ assert (state.pending_score, state.pending_mcp_score) == (float(sessions), float(sessions))+ selection = select_pairs(config, NOW, 10)+ assert [(pair.user_id, pair.trigger) for pair in selection.pairs] == [(self.user.id, "mcp")][: sessions >= 3]++ def test_the_mcp_feed_ignores_teams_that_are_not_enrolled_and_survives_a_redis_error(self) -> None:+ other_team = Team.objects.create(organization=self.organization)+ redis = fakeredis.FakeRedis()+ self._mcp_calls(redis, [("s1", "insights-list", 1)], team=other_team)++ feed = feed_mcp_queue(self._config(), NOW, [self.team.id], redis_client=lambda: redis)+ broken = feed_mcp_queue(+ self._config(), NOW, [self.team.id], redis_client=MagicMock(side_effect=ConnectionError("unreachable"))+ )++ assert (feed.pairs, feed.ignored, feed.error) == (0, 1, False)+ assert broken.error is True+ assert not UserActivitySummaryQueueState.objects.for_team(other_team.id).exists()++ @parameterized.expand([("queue off", False, True, 1), ("render off", True, False, 1), ("both on", True, True, 0)])+ def test_the_tick_drains_the_mcp_dirty_set_only_when_both_switches_are_on(+ self, _name: str, queue_enabled: bool, render_enabled: bool, members_left: int+ ) -> None:+ redis = fakeredis.FakeRedis()+ self._mcp_calls(redis, [("s1", "insights-list", 1), ("s2", "insights-list", 1), ("s3", "insights-list", 1)])+ config = self._config(mcp_queue_enabled=queue_enabled, mcp_render_enabled=render_enabled)++ with (+ override_settings(AI_GATEWAY_URL="https://ai-gateway.example/v1", AI_GATEWAY_API_KEY="phs_test"),+ patch.object(tick, "read_config", return_value=config),+ patch.object(+ tick,+ "feed_mcp_queue",+ side_effect=lambda config, now, team_ids: feed_mcp_queue(+ config, now, team_ids, redis_client=lambda: redis+ ),+ ),+ patch("products.signals.backend.activity_summary.queue.list_user_task_times", return_value=[]),+ ):+ plan = plan_tick(None, NOW)++ assert redis.scard(DIRTY_KEY) == members_left+ assert plan.mcp_feed.sessions == 3 * (1 - members_left)+ assert [pair.trigger for pair in plan.pairs] == ["mcp"][: 1 - members_left]+@parameterized.expand([("activity", 24), ("views", 168), ("cold_start_views", 168), (None, 24)])def test_an_ok_update_emits_the_embedding_and_an_event_without_the_summary(self, trigger: str | None, wait_hours: int