: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(tasks): create small products' tasks from task profiles (#127905)
Charles Viene4ab303ee673
diff --git a/products/account_audits/backend/apps.py b/products/account_audits/backend/apps.pyindex 6528662209b2..6d4f33bfeeb3 100644--- a/products/account_audits/backend/apps.py+++ b/products/account_audits/backend/apps.py@@ -1,7 +1,12 @@from django.apps import AppConfig+from . import task_profiles+class AccountAuditsConfig(AppConfig):default_auto_field = "django.db.models.BigAutoField"name = "products.account_audits.backend"label = "account_audits"++ def ready(self) -> None:+ task_profiles.register()diff --git a/products/account_audits/backend/logic/execution.py b/products/account_audits/backend/logic/execution.pyindex 2def9c4ab7d4..603084ae6385 100644--- a/products/account_audits/backend/logic/execution.py+++ b/products/account_audits/backend/logic/execution.py@@ -13,11 +13,13 @@ from posthog.ph_client import ph_scoped_capturefrom posthog.utils import absolute_uri, get_instance_regionfrom products.account_audits.backend.models import AccountAuditAdmission+from products.account_audits.backend.task_profiles import ACCOUNT_AUDIT, ACCOUNT_AUDIT_MCP_SCOPESfrom products.notebooks.backend.facade import api as notebooks_facadefrom products.notebooks.backend.facade.content import convert_notebook_content_to_markdownfrom products.skills.backend.facade.api import SkillPromptfrom products.tasks.backend.facade import api as tasks_facadefrom products.tasks.backend.facade.billing import get_task_run_cost+from products.tasks.backend.facade.profiles import TaskRunOptionslogger = logging.getLogger(__name__)COMPLETION_GRACE = timedelta(minutes=3)@@ -29,12 +31,13 @@ class AccountAuditOutput(BaseModel):def create_audit_task(*, team_id: int, user_id: int, skill: SkillPrompt, notebook_short_id: str) -> UUID:# The sandbox policy admits platform services; audit skills need no other network access.+ network = ACCOUNT_AUDIT.networkenvironment_id = tasks_facade.upsert_internal_sandbox_env(team_id,"ACCOUNT_AUDIT",- tasks_facade.SandboxNetworkAccessLevel.CUSTOM,- allowed_domains=[],- include_default_domains=False,+ tasks_facade.SandboxNetworkAccessLevel(network.levels[0]),+ allowed_domains=list(network.allowed_domains),+ include_default_domains=network.include_default_domains,)created = tasks_facade.create_and_run_task(team=Team.objects.get(id=team_id),@@ -45,15 +48,15 @@ def create_audit_task(*, team_id: int, user_id: int, skill: SkillPrompt, noteboo"with PostHog MCP, even if the skill asks you to create a notebook. ""Read the saved notebook before you return its short ID as notebook_short_id."),- origin_product=tasks_facade.TaskOriginProduct.ACCOUNT_AUDIT,+ profile=ACCOUNT_AUDIT,user_id=user_id,- repository=None,+ options=TaskRunOptions(+ mcp_scopes=ACCOUNT_AUDIT_MCP_SCOPES,+ model="claude-sonnet-5",+ output_schema=AccountAuditOutput.model_json_schema(),+ ),create_pr=False,- internal=True,sandbox_environment_id=str(environment_id),- posthog_mcp_scopes=["user:read", "query:read", "insight:read", "notebook:read", "notebook:write"],- model="claude-sonnet-5",- output_schema=AccountAuditOutput,sandbox_timeout_seconds=3 * 60 * 60,extra_run_state={"audit_skill_version": skill.version},)diff --git a/products/account_audits/backend/task_profiles.py b/products/account_audits/backend/task_profiles.pynew file mode 100644index 000000000000..d78bf12af0dc--- /dev/null+++ b/products/account_audits/backend/task_profiles.py@@ -0,0 +1,60 @@+from products.tasks.backend.facade.profiles import (+ DrivePolicy,+ GithubAccess,+ GithubResolution,+ NetworkAccess,+ NetworkPolicy,+ OAuthApp,+ PrAuthorship,+ Read,+ TaskProfile,+ register_task_profiles,+)++ACCOUNT_AUDIT_MCP_SCOPES = ["user:read", "query:read", "insight:read", "notebook:read", "notebook:write"]++ACCOUNT_AUDIT = TaskProfile(+ key="account_audit",+ origin_product="account_audit",+ public=False,+ public_options=frozenset(),+ source_kind=None,+ listed=False,+ read_without_channel=Read.CREATOR,+ api_visible=False,+ drive=DrivePolicy.OWNER,+ max_live_per_user=None,+ warm=None,+ runtimes=("acp",),+ sandbox_templates=("default_base",),+ network=NetworkPolicy(levels=(NetworkAccess.CUSTOM,)),+ inherit_user_defaults=False,+ personal_mcp=False,+ mcp_agent=None,+ mcp_scopes=ACCOUNT_AUDIT_MCP_SCOPES,+ mcp_store_servers=True,+ mcp_exclude_tools=(),+ oauth_app=OAuthApp.ARRAY,+ github_resolution=GithubResolution.NEVER,+ github_access=GithubAccess.NONE,+ user_authorable_prs=False,+ default_pr_authorship=PrAuthorship.BOT,+ create_pr=False,+ finish_tool=False,+ done_on_turn_close=False,+ idle_minutes=30,+ inactivity_minutes=10,+ tool_call_minutes=None,+ max_wake_minutes=180,+ billing_product="account_audit",+ bills_compute=False,+ max_cost_usd=None,+ task_budget_usd=None,+ finish_in_flight=True,+)++PROFILES = (ACCOUNT_AUDIT,)+++def register() -> None:+ register_task_profiles(PROFILES)diff --git a/products/account_audits/backend/tests/test_account_audits.py b/products/account_audits/backend/tests/test_account_audits.pyindex 59670ee6d4f0..dc5f13f83362 100644--- a/products/account_audits/backend/tests/test_account_audits.py+++ b/products/account_audits/backend/tests/test_account_audits.py@@ -130,6 +130,7 @@ class TestAccountAuditStartAPI(APIBaseTest):self.assertEqual(run.task.created_by_id, self.user.id)self.assertTrue(run.task.internal)self.assertEqual(run.task.origin_product, "account_audit")+ self.assertEqual(run.task.profile, "account_audit")self.assertIsNone(run.task.repository)self.assertIn(self.skill.body, run.task.description)self.assertIn(admission.notebook_short_id, run.task.description)diff --git a/products/autoresearch/backend/apps.py b/products/autoresearch/backend/apps.pyindex 4361a5a1b58f..ad464790da5f 100644--- a/products/autoresearch/backend/apps.py+++ b/products/autoresearch/backend/apps.py@@ -14,3 +14,7 @@ class AutoresearchConfig(AppConfig):# Lazy "app_label.Model" sender keeps the tasks model off autoresearch's import path.post_save.connect(on_task_run_saved, sender="tasks.TaskRun", dispatch_uid="autoresearch.on_task_run_saved")++ from products.autoresearch.backend import task_profiles # noqa: PLC0415++ task_profiles.register()diff --git a/products/autoresearch/backend/task_profiles.py b/products/autoresearch/backend/task_profiles.pynew file mode 100644index 000000000000..1b0442db451f--- /dev/null+++ b/products/autoresearch/backend/task_profiles.py@@ -0,0 +1,69 @@+from products.tasks.backend.facade.profiles import (+ DrivePolicy,+ GithubAccess,+ GithubResolution,+ NetworkAccess,+ NetworkPolicy,+ OAuthApp,+ PrAuthorship,+ Read,+ TaskProfile,+ register_task_profiles,+)++# The agent explores with execute-sql (query:read, insight:read) and writes only through+# the autoresearch tools. The PostHog MCP server reads /api/users/@me/ to start a session,+# so without user:read it refuses the connection and the agent gets none of those tools.+# The brief carries user-authored text, so the token grants nothing beyond that.+TRAINING_MCP_SCOPES = ["query:read", "insight:read", "user:read", "autoresearch:read", "autoresearch:write"]++# Added only when the report notebook flag is on for the user who starts the run.+# notebook:write also exposes notebooks-partial-update and notebooks-destroy, so the brief+# limits the agent to the notebook it creates in this run.+REPORT_NOTEBOOK_MCP_SCOPES = ["notebook:read", "notebook:write"]++TRAINING = TaskProfile(+ key="autoresearch.training",+ origin_product="autoresearch",+ public=False,+ public_options=frozenset(),+ source_kind=None,+ listed=False,+ read_without_channel=Read.CREATOR,+ api_visible=True,+ drive=DrivePolicy.OWNER,+ max_live_per_user=None,+ warm=None,+ runtimes=("acp",),+ sandbox_templates=("default_base", "autoresearch_base"),+ network=NetworkPolicy(levels=(NetworkAccess.FULL,)),+ inherit_user_defaults=False,+ personal_mcp=False,+ mcp_agent=None,+ mcp_scopes=[*TRAINING_MCP_SCOPES, *REPORT_NOTEBOOK_MCP_SCOPES],+ mcp_store_servers=False,+ mcp_exclude_tools=(),+ oauth_app=OAuthApp.ARRAY,+ github_resolution=GithubResolution.WITH_REPOSITORY,+ github_access=GithubAccess.WRITE,+ user_authorable_prs=False,+ default_pr_authorship=PrAuthorship.BOT,+ create_pr=True,+ finish_tool=False,+ done_on_turn_close=False,+ idle_minutes=30,+ inactivity_minutes=10,+ tool_call_minutes=None,+ max_wake_minutes=180,+ billing_product="background_agents",+ bills_compute=False,+ max_cost_usd=None,+ task_budget_usd=None,+ finish_in_flight=True,+)++PROFILES = (TRAINING,)+++def register() -> None:+ register_task_profiles(PROFILES)diff --git a/products/autoresearch/backend/training/runner.py b/products/autoresearch/backend/training/runner.pyindex 91fb420af0c0..325dd0126434 100644--- a/products/autoresearch/backend/training/runner.py+++ b/products/autoresearch/backend/training/runner.py@@ -49,6 +49,7 @@ from products.autoresearch.backend.models import (AutoresearchTrainingRun,)from products.autoresearch.backend.query import INTERACTIVE_QUERY_TIME_LIMIT_S+from products.autoresearch.backend.task_profiles import REPORT_NOTEBOOK_MCP_SCOPES, TRAINING, TRAINING_MCP_SCOPESfrom products.autoresearch.backend.training.agent_model import agent_run_config_forfrom products.autoresearch.backend.training.artifacts import MAX_ARTIFACT_BYTESfrom products.autoresearch.backend.training.explanation import MAX_TOP_FEATURES@@ -62,6 +63,7 @@ from products.tasks.backend.facade import (api as tasks_facade,cancellation as tasks_cancellation,)+from products.tasks.backend.facade.profiles import TaskRunOptionsfrom products.tasks.backend.facade.sandbox import SandboxTemplatelogger = structlog.get_logger(__name__)@@ -87,17 +89,6 @@ MAX_SUGGESTION_PROMPT_CHARS = 1500# agent's context before research begins. The oldest TRY_NEXT suggestions go first.MAX_PENDING_SUGGESTIONS = 10-# The agent explores with execute-sql (query:read, insight:read) and writes only through-# the autoresearch tools. The PostHog MCP server reads /api/users/@me/ to start a session,-# so without user:read it refuses the connection and the agent gets none of those tools.-# The brief carries user-authored text, so the token grants nothing beyond that.-TRAINING_MCP_SCOPES = ["query:read", "insight:read", "user:read", "autoresearch:read", "autoresearch:write"]--# Added only when the report notebook flag is on for the user who starts the run.-# notebook:write also exposes notebooks-partial-update and notebooks-destroy, so the brief-# limits the agent to the notebook it creates in this run.-REPORT_NOTEBOOK_MCP_SCOPES = ["notebook:read", "notebook:write"]-# Task.title is a 255-character column, and a pipeline name and target event can each# take all of it._TASK_TITLE_MAX_CHARS = 255@@ -1037,18 +1028,18 @@ def run_training(team=pipeline.team,title=title[:_TASK_TITLE_MAX_CHARS],description=description,- origin_product=tasks_facade.TaskOriginProduct.AUTORESEARCH,+ profile=TRAINING,user_id=user_id,- repository=None,- create_pr=False,- mode="background",- internal=True,# Internal tasks skip team and user run preferences, so without these the run would# take whatever the Tasks default is.- runtime_adapter=agent_config.runtime_adapter,- model=agent_config.model,- reasoning_effort=agent_config.reasoning_effort,- posthog_mcp_scopes=mcp_scopes,+ options=TaskRunOptions(+ adapter=agent_config.runtime_adapter,+ model=agent_config.model,+ reasoning_effort=agent_config.reasoning_effort,+ mcp_scopes=mcp_scopes,+ ),+ create_pr=False,+ mode="background",# The autoresearch image is the agent-capable base plus pandas/numpy/# scikit-learn/pyarrow at system site. The base image lacks the ML libs; the# notebook image has the libs but cannot host the agent server — only thisdiff --git a/products/autoresearch/backend/training/test_training.py b/products/autoresearch/backend/training/test_training.pyindex 373e1f87aec3..4e97fba7cb42 100644--- a/products/autoresearch/backend/training/test_training.py+++ b/products/autoresearch/backend/training/test_training.py@@ -23,19 +23,14 @@ from products.autoresearch.backend.models import (AutoresearchSuggestion,AutoresearchTrainingRun,)+from products.autoresearch.backend.task_profiles import REPORT_NOTEBOOK_MCP_SCOPES, TRAINING, TRAINING_MCP_SCOPESfrom products.autoresearch.backend.testing import TeamScopedTestMixinfrom products.autoresearch.backend.training.realized_context import (REALIZED_DATES_PER_MODEL,RELATED_PIPELINES_LIMIT,build_realized_context,)-from products.autoresearch.backend.training.runner import (- REPORT_NOTEBOOK_MCP_SCOPES,- TRAINING_MCP_SCOPES,- UNTRUSTED_DATA_TAG,- build_agent_description,- run_training,-)+from products.autoresearch.backend.training.runner import UNTRUSTED_DATA_TAG, build_agent_description, run_training_UNSCORABLE = UnscorableChampion(failure_kind="limit_exceeded", onset=date(2026, 9, 2))@@ -372,10 +367,11 @@ class TestRunTraining(TeamScopedTestMixin, BaseTest):assert flag.call_args.args[0] == self.userkwargs = facade.create_and_run_task.call_args.kwargs- assert kwargs["posthog_mcp_scopes"] == expected_scopes+ assert kwargs["profile"] == TRAINING+ assert kwargs["options"].mcp_scopes == expected_scopesassert ("notebooks-create-markdown" in kwargs["description"]) is flag_onassert "No realized results yet" in kwargs["description"]- assert "user:read" in kwargs["posthog_mcp_scopes"]+ assert "user:read" in kwargs["options"].mcp_scopesassert kwargs["extra_run_state"] == {"autoresearch_training_run_id": str(training_run.id),"config_snapshot": {"connectors": {"mcp_installation_ids": []}},@@ -445,8 +441,8 @@ class TestRunTraining(TeamScopedTestMixin, BaseTest):training_run = run_training(self.pipeline, iteration_budget=5, user_id=self.user.id)- kwargs = facade.create_and_run_task.call_args.kwargs- assert (kwargs["runtime_adapter"], kwargs["model"], kwargs["reasoning_effort"]) == expected+ options = facade.create_and_run_task.call_args.kwargs["options"]+ assert (options.adapter, options.model, options.reasoning_effort) == expectedtraining_run.refresh_from_db()assert (training_run.agent_runtime_adapter,diff --git a/products/business_knowledge/backend/sandbox.py b/products/business_knowledge/backend/sandbox.pyindex ae0fa6d54287..ac601995a324 100644--- a/products/business_knowledge/backend/sandbox.py+++ b/products/business_knowledge/backend/sandbox.py@@ -241,10 +241,7 @@ def start_sandbox_run(mcp_scopes=BK_MCP_SCOPES,output_schema=SandboxAnswer.model_json_schema(),),- extra_run_state={- "mcp_exclude_tools": list(task_profiles.BUSINESS_KNOWLEDGE.mcp_exclude_tools),- "config_snapshot": {"connectors": {"mcp_installation_ids": []}},- },+ extra_run_state={"config_snapshot": {"connectors": {"mcp_installation_ids": []}}},)if created.latest_run is None:raise RuntimeError("Sandbox task was created without a run")diff --git a/products/business_knowledge/backend/task_profiles.py b/products/business_knowledge/backend/task_profiles.pyindex a2413dd9ef06..5f46466f12d9 100644--- a/products/business_knowledge/backend/task_profiles.py+++ b/products/business_knowledge/backend/task_profiles.py@@ -1,5 +1,4 @@from products.tasks.backend.facade.profiles import (- AccessGate,DrivePolicy,GithubAccess,GithubResolution,@@ -24,7 +23,6 @@ BUSINESS_KNOWLEDGE = TaskProfile(read_without_channel=Read.CREATOR,api_visible=False,drive=DrivePolicy.OWNER,- access_gate=AccessGate.NONE,max_live_per_user=MAX_OPEN_RUNS_PER_OWNER,warm=None,runtimes=("acp",),diff --git a/products/business_knowledge/backend/tests/test_playground.py b/products/business_knowledge/backend/tests/test_playground.pyindex f92131fc52d2..e89e289857a8 100644--- a/products/business_knowledge/backend/tests/test_playground.py+++ b/products/business_knowledge/backend/tests/test_playground.py@@ -14,6 +14,7 @@ from posthog.models.user import Userfrom products.business_knowledge.backend.api.playground import BusinessKnowledgePlaygroundChatViewSetfrom products.business_knowledge.backend.constants import MAX_OPEN_RUNS_PER_OWNERfrom products.business_knowledge.backend.models import PlaygroundChat, PlaygroundTurn+from products.tasks.backend.facade.temporal import mcp_exclude_tools_for_taskfrom products.tasks.backend.models import Task, TaskRunWORKFLOW = "products.tasks.backend.temporal.client.execute_task_processing_workflow"@@ -167,6 +168,24 @@ class TestPlaygroundChatAPI(APIBaseTest):assert not Task.objects.filter(origin_product=Task.OriginProduct.BUSINESS_KNOWLEDGE).exists()assert PlaygroundTurn.objects.unscoped().count() == 0+ def test_follow_up_keeps_hidden_tools_for_a_task_without_a_profile(self, _ff, _workflow) -> None:+ chat = self._create_chat()+ asked = self.client.post(f"{self.url}{chat['id']}/ask/", {"question": "Can I get a refund?"}, format="json")+ assert asked.status_code == status.HTTP_201_CREATED, asked.content+ first_turn = asked.json()["turns"][0]+ Task.objects.filter(id=first_turn["task_id"]).update(profile=None)+ first_run = TaskRun.objects.get(id=first_turn["run"]["run_id"])+ first_run.status = TaskRun.Status.COMPLETED+ first_run.output = {"reply": "Yes, within 30 days.", "sources": []}+ first_run.state = {**first_run.state, "mcp_exclude_tools": ["project-get", "user-get"]}+ first_run.save(update_fields=["status", "output", "state"])++ follow_up = self.client.post(f"{self.url}{chat['id']}/ask/", {"question": "And after 30 days?"}, format="json")++ assert follow_up.status_code == status.HTTP_201_CREATED, follow_up.content+ successor = TaskRun.objects.get(id=follow_up.json()["turns"][1]["run"]["run_id"])+ assert successor.state["mcp_exclude_tools"] == ["project-get", "user-get"]+def test_follow_up_resumes_the_same_sandbox(self, _ff, _workflow) -> None:chat = self._create_chat()asked = self.client.post(f"{self.url}{chat['id']}/ask/", {"question": "Can I get a refund?"}, format="json")@@ -194,7 +213,10 @@ class TestPlaygroundChatAPI(APIBaseTest):assert successor.task_id == first_run.task_idassert successor.state["resume_from_run_id"] == str(first_run.id)assert successor.state["pending_user_message"] == "And after 30 days?"- assert successor.state["mcp_exclude_tools"] == first_run.state["mcp_exclude_tools"]+ assert "mcp_exclude_tools" not in successor.state+ assert mcp_exclude_tools_for_task(successor.task, successor.state) == mcp_exclude_tools_for_task(+ first_run.task, first_run.state+ )assert successor.state["config_snapshot"] == first_run.state["config_snapshot"]assert successor.state["model"] == first_run.state["model"]assert successor.state["runtime_adapter"] == first_run.state["runtime_adapter"]diff --git a/products/business_knowledge/backend/tests/test_sandbox.py b/products/business_knowledge/backend/tests/test_sandbox.pyindex e671d4a6b677..13c0aaa37823 100644--- a/products/business_knowledge/backend/tests/test_sandbox.py+++ b/products/business_knowledge/backend/tests/test_sandbox.py@@ -31,6 +31,7 @@ from products.business_knowledge.backend.sandbox import (format_always_on_context,parse_sandbox_log,)+from products.tasks.backend.facade.temporal import mcp_exclude_tools_for_taskfrom products.tasks.backend.models import SandboxEnvironment, Task, TaskRunWORKFLOW = "products.tasks.backend.temporal.client.execute_task_processing_workflow"@@ -242,6 +243,7 @@ class TestSandboxAPI(APIBaseTest):"user:read","project:read",]+ assert "mcp_exclude_tools" not in run.stateassert {DOCS_SEARCH_TOOL,"user-get",@@ -250,7 +252,7 @@ class TestSandboxAPI(APIBaseTest):"mcp-connection-tools-list","tasks-runs-session-logs-retrieve","tasks-artifacts-list",- } <= set(run.state["mcp_exclude_tools"])+ } <= set(mcp_exclude_tools_for_task(task, run.state))assert run.state["config_snapshot"]["connectors"]["mcp_installation_ids"] == []assert run.state["model"] == "claude-sonnet-5"assert run.state["runtime_adapter"] == "claude"diff --git a/products/canvas/backend/tests/test_canvas_api.py b/products/canvas/backend/tests/test_canvas_api.pyindex 06ef0b537a40..e5f86df23af8 100644--- a/products/canvas/backend/tests/test_canvas_api.py+++ b/products/canvas/backend/tests/test_canvas_api.py@@ -2553,6 +2553,7 @@ class TestCanvasActions(CanvasAPIBaseTest):task = Task.objects.get(id=response.json()["result"]["task_id"])assert task.created_by_id == self.user.idassert task.channel_id == self.channel.id+ assert task.profile == "user"assert task.title == "Follow up"assert not task.runs.exists()@@ -2640,6 +2641,7 @@ class TestCanvasActions(CanvasAPIBaseTest):run = task.runs.get(id=response.json()["result"]["run_id"])assert task.created_by_id == viewer.idassert task.channel_id == self.channel.id+ assert task.profile == "user"assert task.repositories == repositoriesassert task.github_integration_id == integration.idassert run.environment == TaskRun.Environment.CLOUDdiff --git a/products/context_layer/backend/apps.py b/products/context_layer/backend/apps.pyindex 17839de74478..9c867847e572 100644--- a/products/context_layer/backend/apps.py+++ b/products/context_layer/backend/apps.py@@ -1,8 +1,13 @@from django.apps import AppConfig+from . import task_profiles+class ContextLayerAppConfig(AppConfig):default_auto_field = "django.db.models.BigAutoField"name = "products.context_layer.backend"label = "context_layer"verbose_name = "Context layer"++ def ready(self) -> None:+ task_profiles.register()diff --git a/products/context_layer/backend/task_profiles.py b/products/context_layer/backend/task_profiles.pynew file mode 100644index 000000000000..a95654e6719d--- /dev/null+++ b/products/context_layer/backend/task_profiles.py@@ -0,0 +1,58 @@+from products.tasks.backend.facade.profiles import (+ DrivePolicy,+ GithubAccess,+ GithubResolution,+ NetworkAccess,+ NetworkPolicy,+ OAuthApp,+ PrAuthorship,+ Read,+ TaskProfile,+ register_task_profiles,+)++DREAM = TaskProfile(+ key="context_layer.dream",+ origin_product="context_layer",+ public=False,+ public_options=frozenset(),+ source_kind=None,+ listed=False,+ read_without_channel=Read.CREATOR,+ api_visible=True,+ drive=DrivePolicy.OWNER,+ max_live_per_user=None,+ warm=None,+ runtimes=("acp",),+ sandbox_templates=("default_base",),+ network=NetworkPolicy(levels=(NetworkAccess.FULL,)),+ inherit_user_defaults=False,+ personal_mcp=False,+ mcp_agent=None,+ mcp_scopes="full",+ mcp_store_servers=True,+ mcp_exclude_tools=(),+ oauth_app=OAuthApp.ARRAY,+ github_resolution=GithubResolution.WITH_REPOSITORY,+ github_access=GithubAccess.WRITE,+ user_authorable_prs=False,+ default_pr_authorship=PrAuthorship.BOT,+ create_pr=True,+ finish_tool=False,+ done_on_turn_close=False,+ idle_minutes=30,+ inactivity_minutes=10,+ tool_call_minutes=None,+ max_wake_minutes=180,+ billing_product="background_agents",+ bills_compute=False,+ max_cost_usd=None,+ task_budget_usd=None,+ finish_in_flight=True,+)++PROFILES = (DREAM,)+++def register() -> None:+ register_task_profiles(PROFILES)diff --git a/products/context_layer/backend/temporal/dreaming.py b/products/context_layer/backend/temporal/dreaming.pyindex fff1aa0bb440..35b78ba69f2d 100644--- a/products/context_layer/backend/temporal/dreaming.py+++ b/products/context_layer/backend/temporal/dreaming.py@@ -37,7 +37,7 @@ from posthog.temporal.oauth import CONTEXT_LAYER_INTERNAL_SCOPE, MCP_READ_SCOPESfrom products.context_layer.backend.dreams import DREAM_AI_STAGEfrom products.context_layer.backend.facade import api as context_layer_facadefrom products.context_layer.backend.models import ContextLayerConfig-from products.tasks.backend.facade.api import TaskOriginProduct+from products.context_layer.backend.task_profiles import DREAMlogger = structlog.get_logger(__name__)@@ -205,9 +205,8 @@ async def dispatch_dream_run(input: DispatchDreamRunInput) -> DispatchDreamRunOuinitial_permission_mode="full-access",),step_name="context-layer-dream",- origin_product=TaskOriginProduct.CONTEXT_LAYER,+ profile=DREAM,ai_stage=DREAM_AI_STAGE,- internal=True,workflow_id_prefix="context-layer-dream",)except Exception:diff --git a/products/context_layer/backend/test/test_dreaming.py b/products/context_layer/backend/test/test_dreaming.pyindex 76e562590fa3..b89c9fbe22dc 100644--- a/products/context_layer/backend/test/test_dreaming.py+++ b/products/context_layer/backend/test/test_dreaming.py@@ -12,6 +12,7 @@ from parameterized import parameterizedfrom products.context_layer.backend.admin import ContextLayerConfigAdminfrom products.context_layer.backend.models import ContextLayerConfig+from products.context_layer.backend.task_profiles import DREAMfrom products.context_layer.backend.temporal import dreaming@@ -171,8 +172,7 @@ class TestDreamingLane(BaseTest):assert context.initial_permission_mode == "full-access"assert context.posthog_mcp_scopes == [*dreaming.MCP_READ_SCOPES, dreaming.CONTEXT_LAYER_INTERNAL_SCOPE]assert trigger_mock.call_args.kwargs["ai_stage"] == dreaming.DREAM_AI_STAGE- assert trigger_mock.call_args.kwargs["origin_product"] == "context_layer"- assert trigger_mock.call_args.kwargs["internal"] is True+ assert trigger_mock.call_args.kwargs["profile"] == DREAMprompt = trigger_mock.call_args.args[0]assert prompt.startswith("This is the first dream: review the last 7 days of organizational activity. Treat this as a seed run:"diff --git a/products/conversations/backend/apps.py b/products/conversations/backend/apps.pyindex 50d2f6139d7c..e30754e67c87 100644--- a/products/conversations/backend/apps.py+++ b/products/conversations/backend/apps.py@@ -12,7 +12,9 @@ class ConversationsConfig(AppConfig):from . import (activity_logging, # noqa: F401, PLC0415signals, # noqa: F401+ task_profiles,)from .learning_provider import register_conversations_learning_providerregister_conversations_learning_provider()+ task_profiles.register()diff --git a/products/conversations/backend/task_profiles.py b/products/conversations/backend/task_profiles.pynew file mode 100644index 000000000000..2c2bf78d7433--- /dev/null+++ b/products/conversations/backend/task_profiles.py@@ -0,0 +1,58 @@+from products.tasks.backend.facade.profiles import (+ DrivePolicy,+ GithubAccess,+ GithubResolution,+ NetworkAccess,+ NetworkPolicy,+ OAuthApp,+ PrAuthorship,+ Read,+ TaskProfile,+ register_task_profiles,+)++SUPPORT_REPLY = TaskProfile(+ key="conversations.support_reply",+ origin_product="support_reply",+ public=False,+ public_options=frozenset(),+ source_kind=None,+ listed=False,+ read_without_channel=Read.CREATOR,+ api_visible=True,+ drive=DrivePolicy.OWNER,+ max_live_per_user=None,+ warm=None,+ runtimes=("acp",),+ sandbox_templates=("default_base",),+ network=NetworkPolicy(levels=(NetworkAccess.CUSTOM,)),+ inherit_user_defaults=False,+ personal_mcp=False,+ mcp_agent="support",+ mcp_scopes="read_only",+ mcp_store_servers=True,+ mcp_exclude_tools=(),+ oauth_app=OAuthApp.ARRAY,+ github_resolution=GithubResolution.WITH_REPOSITORY,+ github_access=GithubAccess.WRITE,+ user_authorable_prs=False,+ default_pr_authorship=PrAuthorship.BOT,+ create_pr=True,+ finish_tool=False,+ done_on_turn_close=False,+ idle_minutes=30,+ inactivity_minutes=10,+ tool_call_minutes=None,+ max_wake_minutes=180,+ billing_product="conversations",+ bills_compute=False,+ max_cost_usd=None,+ task_budget_usd=None,+ finish_in_flight=True,+)++PROFILES = (SUPPORT_REPLY,)+++def register() -> None:+ register_task_profiles(PROFILES)diff --git a/products/conversations/backend/temporal/ai_reply/activities/draft.py b/products/conversations/backend/temporal/ai_reply/activities/draft.pyindex d313f58200e5..bb7dd8203f5c 100644--- a/products/conversations/backend/temporal/ai_reply/activities/draft.py+++ b/products/conversations/backend/temporal/ai_reply/activities/draft.py@@ -18,6 +18,7 @@ from posthog.temporal.oauth import PosthogMcpScopesfrom products.business_knowledge.backend.constants import MAX_ALWAYS_ON_CONTEXT_CHARSfrom products.business_knowledge.backend.logic import get_chunks_by_idsfrom products.conversations.backend.playbook import compose_support_playbook, is_posthog_docs_source+from products.conversations.backend.task_profiles import SUPPORT_REPLYfrom products.conversations.backend.temporal.ai_reply.constants import (BASE_DRAFT_SCOPES,DIAGNOSTIC_SCOPES_PRESET,@@ -45,7 +46,6 @@ from products.conversations.backend.temporal.helpers import (get_or_create_support_sandbox_env,resolve_user_id_for_support,)-from products.tasks.backend.facade import api as tasks_facadefrom products.tasks.backend.facade.agents import EmptyAgentTurnError, MultiTurnSessionlogger = structlog.get_logger(__name__)@@ -414,9 +414,7 @@ Return your response as a JSON object with keys: reply, citations, confidence (aprompt,context,step_name="support_reply",- origin_product=tasks_facade.TaskOriginProduct.SUPPORT_REPLY,- mcp_builtin_agent_key="support",- internal=True,+ profile=SUPPORT_REPLY,max_poll_seconds=DRAFT_POLL_SECONDS,)except EmptyAgentTurnError:diff --git a/products/conversations/backend/temporal/helpers.py b/products/conversations/backend/temporal/helpers.pyindex c54a197bb766..fc220cceabe9 100644--- a/products/conversations/backend/temporal/helpers.py+++ b/products/conversations/backend/temporal/helpers.py@@ -5,6 +5,7 @@ import structlogfrom posthog.models.organization import OrganizationMembershipfrom posthog.models.team.team import Team+from products.conversations.backend.task_profiles import SUPPORT_REPLYfrom products.tasks.backend.facade import api as tasks_facadelogger = structlog.get_logger(__name__)@@ -25,15 +26,16 @@ def get_or_create_support_sandbox_env(team_id: int) -> str:exfiltration channel that TRUSTED's broad allowlist would otherwise leave open. This agentonly drafts text + calls read-only MCP tools; it has no reason to fetch from the internet."""+ network = SUPPORT_REPLY.networkreturn str(tasks_facade.upsert_internal_sandbox_env(team_id,CONVERSATIONS_SUPPORT_REPLY_ENV_NAME,- tasks_facade.SandboxNetworkAccessLevel.CUSTOM,+ tasks_facade.SandboxNetworkAccessLevel(network.levels[0]),private=False,internal=True,- allowed_domains=[],- include_default_domains=False,+ allowed_domains=list(network.allowed_domains),+ include_default_domains=network.include_default_domains,))diff --git a/products/experiments/backend/apps.py b/products/experiments/backend/apps.pyindex 2810eec9fcd3..74579ec04150 100644--- a/products/experiments/backend/apps.py+++ b/products/experiments/backend/apps.py@@ -69,3 +69,7 @@ class ExperimentsConfig(AppConfig):register_post_delete_hook("experiment", _post_delete)register_post_restore_hook("experiment", _post_restore)++ from products.experiments.backend import task_profiles # noqa: PLC0415++ task_profiles.register()diff --git a/products/experiments/backend/experiment_service.py b/products/experiments/backend/experiment_service.pyindex a3d7167ec01e..19e7d10126c7 100644--- a/products/experiments/backend/experiment_service.py+++ b/products/experiments/backend/experiment_service.py@@ -121,6 +121,7 @@ from products.experiments.backend.models.experiment import ()from products.experiments.backend.models.team_experiments_config import TeamExperimentsConfigfrom products.experiments.backend.result_serialization import strip_step_sessions+from products.experiments.backend.task_profiles import CLEANUPfrom products.experiments.backend.warehouse_access_control import validate_warehouse_metricsfrom products.experiments.backend.warehouse_native_sources import (validate_experiment_warehouse_native_sources,@@ -2789,7 +2790,7 @@ class ExperimentService:team=team,title=title,description=description,- origin_product=tasks_facade.TaskOriginProduct.EXPERIMENTS,+ profile=CLEANUP,user_id=user_id,repository=repository,create_pr=True,diff --git a/products/experiments/backend/task_profiles.py b/products/experiments/backend/task_profiles.pynew file mode 100644index 000000000000..5d3f80a6a54e--- /dev/null+++ b/products/experiments/backend/task_profiles.py@@ -0,0 +1,58 @@+from products.tasks.backend.facade.profiles import (+ DrivePolicy,+ GithubAccess,+ GithubResolution,+ NetworkAccess,+ NetworkPolicy,+ OAuthApp,+ PrAuthorship,+ Read,+ TaskProfile,+ register_task_profiles,+)++CLEANUP = TaskProfile(+ key="experiments.cleanup",+ origin_product="experiments",+ public=False,+ public_options=frozenset(),+ source_kind=None,+ listed=True,+ read_without_channel=Read.TEAM,+ api_visible=True,+ drive=DrivePolicy.OWNER,+ max_live_per_user=None,+ warm=None,+ runtimes=("acp",),+ sandbox_templates=("default_base",),+ network=NetworkPolicy(levels=(NetworkAccess.FULL,)),+ inherit_user_defaults=True,+ personal_mcp=True,+ mcp_agent=None,+ mcp_scopes="full",+ mcp_store_servers=True,+ mcp_exclude_tools=(),+ oauth_app=OAuthApp.ARRAY,+ github_resolution=GithubResolution.WITH_REPOSITORY,+ github_access=GithubAccess.WRITE,+ user_authorable_prs=False,+ default_pr_authorship=PrAuthorship.BOT,+ create_pr=True,+ finish_tool=False,+ done_on_turn_close=False,+ idle_minutes=30,+ inactivity_minutes=10,+ tool_call_minutes=None,+ max_wake_minutes=180,+ billing_product="posthog_code",+ bills_compute=False,+ max_cost_usd=None,+ task_budget_usd=None,+ finish_in_flight=True,+)++PROFILES = (CLEANUP,)+++def register() -> None:+ register_task_profiles(PROFILES)diff --git a/products/experiments/backend/test/test_experiment_cleanup_pr.py b/products/experiments/backend/test/test_experiment_cleanup_pr.pyindex 3e546ebcc66e..bddf20406f2d 100644--- a/products/experiments/backend/test/test_experiment_cleanup_pr.py+++ b/products/experiments/backend/test/test_experiment_cleanup_pr.py@@ -16,8 +16,8 @@ from posthog.models.user_integration import UserIntegrationfrom products.experiments.backend.experiment_service import ExperimentServicefrom products.experiments.backend.models.experiment import Experimentfrom products.experiments.backend.models.team_experiments_config import TeamExperimentsConfig+from products.experiments.backend.task_profiles import CLEANUPfrom products.feature_flags.backend.models.feature_flag import FeatureFlag-from products.tasks.backend.facade import api as tasks_facadeclass TestExperimentCleanupPr(APIBaseTest):@@ -90,7 +90,7 @@ class TestExperimentCleanupPr(APIBaseTest):if expect_task_created:mock_create_task.assert_called_once()kwargs = mock_create_task.call_args.kwargs- self.assertEqual(kwargs["origin_product"], tasks_facade.TaskOriginProduct.EXPERIMENTS)+ self.assertEqual(kwargs["profile"], CLEANUP)self.assertEqual(kwargs["repository"], "posthog/posthog")self.assertTrue(kwargs["create_pr"])self.assertEqual(experiment.flag_cleanup_task_id, task_id)diff --git a/products/knowledge_writer/backend/apps.py b/products/knowledge_writer/backend/apps.pyindex 3ea77291c56a..1a3db18192d2 100644--- a/products/knowledge_writer/backend/apps.py+++ b/products/knowledge_writer/backend/apps.py@@ -7,6 +7,7 @@ class KnowledgeWriterConfig(AppConfig):label = "knowledge_writer"def ready(self) -> None:- from products.knowledge_writer.backend import receivers # noqa: PLC0415 — needs the app registry+ from products.knowledge_writer.backend import receivers, task_profiles # noqa: PLC0415 — needs the app registryreceivers.connect()+ task_profiles.register()diff --git a/products/knowledge_writer/backend/logic/launch.py b/products/knowledge_writer/backend/logic/launch.pyindex 71968c0c2b5b..e6f17c94aadd 100644--- a/products/knowledge_writer/backend/logic/launch.py+++ b/products/knowledge_writer/backend/logic/launch.py@@ -11,6 +11,7 @@ from products.tasks.backend.facade import api as tasks_facadefrom ..adapters.registry import REGISTRYfrom ..facade.contracts import DocsRequestfrom ..settings import WriterSettings+from ..task_profiles import WRITERfrom .caps import WriterRerunTaken, claim_sectionfrom .records import (JOIN_STATE_KEY,@@ -123,11 +124,10 @@ def create_writer_task(team=team,title=f"Docs: {request.source_url}"[:255],description=description,- origin_product=tasks_facade.TaskOriginProduct.KNOWLEDGE_WRITER,+ profile=WRITER,user_id=writer.user_id,repository=writer.docs_repository,create_pr=False,- internal=True,posthog_mcp_scopes=[],extra_run_state=no_store_connectors_run_state(),origin_key=request.dedupe_id,diff --git a/products/knowledge_writer/backend/task_profiles.py b/products/knowledge_writer/backend/task_profiles.pynew file mode 100644index 000000000000..dff33a45b9c8--- /dev/null+++ b/products/knowledge_writer/backend/task_profiles.py@@ -0,0 +1,58 @@+from products.tasks.backend.facade.profiles import (+ DrivePolicy,+ GithubAccess,+ GithubResolution,+ NetworkAccess,+ NetworkPolicy,+ OAuthApp,+ PrAuthorship,+ Read,+ TaskProfile,+ register_task_profiles,+)++WRITER = TaskProfile(+ key="knowledge_writer.docs",+ origin_product="knowledge_writer",+ public=False,+ public_options=frozenset(),+ source_kind=None,+ listed=False,+ read_without_channel=Read.CREATOR,+ api_visible=True,+ drive=DrivePolicy.OWNER,+ max_live_per_user=None,+ warm=None,+ runtimes=("acp",),+ sandbox_templates=("default_base",),+ network=NetworkPolicy(levels=(NetworkAccess.FULL,)),+ inherit_user_defaults=False,+ personal_mcp=False,+ mcp_agent=None,+ mcp_scopes=[],+ mcp_store_servers=True,+ mcp_exclude_tools=(),+ oauth_app=OAuthApp.ARRAY,+ github_resolution=GithubResolution.WITH_REPOSITORY,+ github_access=GithubAccess.WRITE,+ user_authorable_prs=False,+ default_pr_authorship=PrAuthorship.BOT,+ create_pr=True,+ finish_tool=False,+ done_on_turn_close=False,+ idle_minutes=30,+ inactivity_minutes=10,+ tool_call_minutes=None,+ max_wake_minutes=180,+ billing_product="background_agents",+ bills_compute=False,+ max_cost_usd=None,+ task_budget_usd=None,+ finish_in_flight=True,+)++PROFILES = (WRITER,)+++def register() -> None:+ register_task_profiles(PROFILES)diff --git a/products/knowledge_writer/backend/tests/test_intake.py b/products/knowledge_writer/backend/tests/test_intake.pyindex a913f292977f..4ea3c3a7d6c7 100644--- a/products/knowledge_writer/backend/tests/test_intake.py+++ b/products/knowledge_writer/backend/tests/test_intake.py@@ -35,6 +35,7 @@ from products.knowledge_writer.backend.logic.records import ()from products.knowledge_writer.backend.logic.routing import docs_sectionfrom products.knowledge_writer.backend.settings import writer_settings+from products.knowledge_writer.backend.task_profiles import WRITERfrom products.tasks.backend.facade import api as tasks_facadefrom products.tasks.backend.models import Task, TaskRun@@ -212,6 +213,7 @@ def test_a_request_starts_one_internal_writer_task_and_a_repeat_is_a_duplicate(ttask = tasks_facade.get_task_by_origin_key(team.id, verdict.request.dedupe_id)assert task is not Noneassert task.origin_product == tasks_facade.TaskOriginProduct.KNOWLEDGE_WRITER+ assert Task.objects.get(id=task.id).profile == WRITER.keyassert task.repository == "posthog/posthog.com"stored_request = tasks_facade.read_task_state_entry(task.id, team.id, REQUEST_STATE_KEY)assert isinstance(stored_request, dict)diff --git a/products/metrics/backend/apps.py b/products/metrics/backend/apps.pyindex 276f8aa58256..955696f9573b 100644--- a/products/metrics/backend/apps.py+++ b/products/metrics/backend/apps.py@@ -18,3 +18,7 @@ class MetricsConfig(AppConfig):from products.metrics.backend.alerts.registration import register # noqa: PLC0415register()++ from products.metrics.backend import task_profiles # noqa: PLC0415++ task_profiles.register()diff --git a/products/metrics/backend/dashboard_import/importer.py b/products/metrics/backend/dashboard_import/importer.pyindex b65c0e1b7256..34941ed9e320 100644--- a/products/metrics/backend/dashboard_import/importer.py+++ b/products/metrics/backend/dashboard_import/importer.py@@ -109,8 +109,15 @@ from products.metrics.backend.facade.enums import (PanelImportOutcome,PanelProgressState,)+from products.metrics.backend.task_profiles import (+ AGENT_HIDDEN_TOOLS,+ AGENT_MCP_SCOPES,+ DASHBOARD_IMPORT,+ MAX_RUNNING_IMPORTS,+)from products.tasks.backend.facade import api as tasks_facadefrom products.tasks.backend.facade.contracts import TaskRunDTO, TaskRunInputFile+from products.tasks.backend.facade.profiles import TaskRunOptionslogger = structlog.get_logger(__name__)@@ -118,37 +125,6 @@ IMPORT_STATE_KEY = "metrics_dashboard_import"SANDBOX_ENVIRONMENT_NAME = "METRICS_DASHBOARD_IMPORT"AGENT_MODEL = "claude-sonnet-5"AGENT_RUNTIME_ADAPTER = "claude"-# The PostHog MCP server reads the user and the project to start a session, so it needs user:read and-# project:read. The rest lets the agent read metrics, logs and traces. Nothing lets it write.-AGENT_MCP_SCOPES = ["metrics:read", "logs:read", "tracing:read", "user:read", "project:read"]-# Read tools that the internal scopes unlock but the conversion never needs. The input can carry planted-# instructions, so hide every tool that reads other data of the user.-AGENT_HIDDEN_TOOLS = [- "docs-search",- "user-get",- "user-home-settings-get",- "llma-personal-spend",- "reminder-get",- "reminders-list",- "mcp-connections-list",- "mcp-connection-tools-list",- "tasks-list",- "tasks-retrieve",- "tasks-runs-list",- "tasks-runs-retrieve",- "tasks-runs-session-logs-retrieve",- "tasks-artifacts-list",- "tasks-config-list",- "tasks-me-config-list",- "tasks-models-retrieve",- "channel-list",- "channel-retrieve",- "channel-instructions-retrieve",- "inbox-reports-list",- "inbox-reports-retrieve",- "task-context-wiki-channel-resolve",- "task-context-wiki-page-retrieve",-]START_CHECK_SECONDS = 20.0FINAL_CHECK_SECONDS = 60.0# A finalizer that holds the claim longer than this died before it saved a result, so another may take over.@@ -163,7 +139,6 @@ STORAGE_TTL_DAYS = "30"DEFAULT_SCREENSHOT_LAYOUT = GridLayout(x=0, y=0, w=6, h=4)_QUERY_KINDS = frozenset({"timeseries", "stat", "gauge", "bargauge", "table", "heatmap"})_AGENT_FAILED_MESSAGE = "The import agent stopped before it finished. Try again."-MAX_RUNNING_IMPORTS = 3RECENT_IMPORTS_WINDOW = dt.timedelta(days=7)MAX_RECENT_IMPORTS = 20MAX_LAYOUT_ROUNDS = 3@@ -566,29 +541,30 @@ class DashboardImporter:with transaction.atomic():self._admit()+ network = DASHBOARD_IMPORT.networkenvironment_id = tasks_facade.upsert_internal_sandbox_env(self._team.id,SANDBOX_ENVIRONMENT_NAME,- tasks_facade.SandboxNetworkAccessLevel.CUSTOM,+ tasks_facade.SandboxNetworkAccessLevel(network.levels[0]),private=False,internal=True,- allowed_domains=[],- include_default_domains=False,+ allowed_domains=list(network.allowed_domains),+ include_default_domains=network.include_default_domains,)created = tasks_facade.create_and_run_task(team=self._team,title=f"Import dashboard: {state.dashboard_name}"[:255],description=prompt,- origin_product=tasks_facade.TaskOriginProduct.METRICS_IMPORT,+ profile=DASHBOARD_IMPORT,user_id=self._user.id,- repository=None,+ options=TaskRunOptions(+ adapter=AGENT_RUNTIME_ADAPTER,+ model=AGENT_MODEL,+ mcp_scopes=AGENT_MCP_SCOPES,+ output_schema=AgentImportOutput.model_json_schema(),+ ),create_pr=False,- internal=True,sandbox_environment_id=str(environment_id),- posthog_mcp_scopes=AGENT_MCP_SCOPES,- model=AGENT_MODEL,- runtime_adapter=AGENT_RUNTIME_ADAPTER,- output_schema=AgentImportOutput,extra_run_state={"mcp_exclude_tools": AGENT_HIDDEN_TOOLS,"config_snapshot": {"connectors": {"mcp_installation_ids": []}},diff --git a/products/metrics/backend/task_profiles.py b/products/metrics/backend/task_profiles.pynew file mode 100644index 000000000000..84aab0d78574--- /dev/null+++ b/products/metrics/backend/task_profiles.py@@ -0,0 +1,91 @@+from products.tasks.backend.facade.profiles import (+ DrivePolicy,+ GithubAccess,+ GithubResolution,+ NetworkAccess,+ NetworkPolicy,+ OAuthApp,+ PrAuthorship,+ Read,+ TaskProfile,+ register_task_profiles,+)++# The PostHog MCP server reads the user and the project to start a session, so it needs user:read and+# project:read. The rest lets the agent read metrics, logs and traces. Nothing lets it write.+AGENT_MCP_SCOPES = ["metrics:read", "logs:read", "tracing:read", "user:read", "project:read"]+# Read tools that the internal scopes unlock but the conversion never needs. The input can carry planted+# instructions, so hide every tool that reads other data of the user.+AGENT_HIDDEN_TOOLS = [+ "docs-search",+ "user-get",+ "user-home-settings-get",+ "llma-personal-spend",+ "reminder-get",+ "reminders-list",+ "mcp-connections-list",+ "mcp-connection-tools-list",+ "tasks-list",+ "tasks-retrieve",+ "tasks-runs-list",+ "tasks-runs-retrieve",+ "tasks-runs-session-logs-retrieve",+ "tasks-artifacts-list",+ "tasks-config-list",+ "tasks-me-config-list",+ "tasks-models-retrieve",+ "channel-list",+ "channel-retrieve",+ "channel-instructions-retrieve",+ "inbox-reports-list",+ "inbox-reports-retrieve",+ "task-context-wiki-channel-resolve",+ "task-context-wiki-page-retrieve",+]+MAX_RUNNING_IMPORTS = 3++DASHBOARD_IMPORT = TaskProfile(+ key="metrics.dashboard_import",+ origin_product="metrics_import",+ public=False,+ public_options=frozenset(),+ source_kind=None,+ listed=False,+ read_without_channel=Read.CREATOR,+ api_visible=False,+ drive=DrivePolicy.OWNER,+ max_live_per_user=MAX_RUNNING_IMPORTS,+ warm=None,+ runtimes=("acp",),+ sandbox_templates=("default_base",),+ network=NetworkPolicy(levels=(NetworkAccess.CUSTOM,)),+ inherit_user_defaults=False,+ personal_mcp=False,+ mcp_agent=None,+ mcp_scopes=AGENT_MCP_SCOPES,+ mcp_store_servers=False,+ mcp_exclude_tools=tuple(AGENT_HIDDEN_TOOLS),+ oauth_app=OAuthApp.POSTHOG_AI,+ github_resolution=GithubResolution.WITH_REPOSITORY,+ github_access=GithubAccess.WRITE,+ user_authorable_prs=False,+ default_pr_authorship=PrAuthorship.BOT,+ create_pr=False,+ finish_tool=False,+ done_on_turn_close=False,+ idle_minutes=30,+ inactivity_minutes=10,+ tool_call_minutes=None,+ max_wake_minutes=180,+ billing_product="posthog_ai",+ bills_compute=False,+ max_cost_usd=None,+ task_budget_usd=None,+ finish_in_flight=True,+)++PROFILES = (DASHBOARD_IMPORT,)+++def register() -> None:+ register_task_profiles(PROFILES)diff --git a/products/metrics/backend/tests/test_dashboard_import_api.py b/products/metrics/backend/tests/test_dashboard_import_api.pyindex f26bb21abcdb..b16dcf4c1b03 100644--- a/products/metrics/backend/tests/test_dashboard_import_api.py+++ b/products/metrics/backend/tests/test_dashboard_import_api.py@@ -172,6 +172,7 @@ class TestDashboardImportAPI(APIBaseTest):task = Task.objects.get(id=body["id"])run = TaskRun.objects.get(task=task)assert (task.origin_product, task.internal, task.repository) == (Task.OriginProduct.METRICS_IMPORT, True, None)+ assert task.profile == "metrics.dashboard_import"assert run.state["pending_dispatch"]["posthog_mcp_scopes"] == AGENT_MCP_SCOPESassert "docs-search" in run.state["mcp_exclude_tools"]assert {artifact["name"] for artifact in run.artifacts} == {"brief.json", "grafana-dashboard.json"}diff --git a/products/tasks/backend/apps.py b/products/tasks/backend/apps.pyindex 244b0e9aa986..25a0a3b07fec 100644--- a/products/tasks/backend/apps.py+++ b/products/tasks/backend/apps.py@@ -10,4 +10,6 @@ class TasksConfig(AppConfig):# Signal receivers live in their own import-light modules so every# process type (celery, temporal, migrate) wires them without pulling# the viewset import graph into django.setup().- from products.tasks.backend import search_index, team_deletion # noqa: F401, PLC0415+ from products.tasks.backend import search_index, task_profiles, team_deletion # noqa: F401, PLC0415++ task_profiles.register()diff --git a/products/tasks/backend/facade/api.py b/products/tasks/backend/facade/api.pyindex 5e087c1626ef..9542b384bcb5 100644--- a/products/tasks/backend/facade/api.py+++ b/products/tasks/backend/facade/api.py@@ -214,6 +214,7 @@ from products.tasks.backend.repository_config_analytics import (capture_space_context_changed,repositories_differ,)+from products.tasks.backend.task_profiles import SPACE_SETUP, USER, WIZARDfrom products.tasks.backend.task_sources import apply_task_source, idempotency_key_q, source_qfrom products.tasks.backend.visibility import (PRODUCT_PRIVATE_ORIGIN_PRODUCTS,@@ -2287,17 +2288,17 @@ def create_wizard_cloud_run(team=team,title="Set up PostHog",description=prompt,- origin_product=Task.OriginProduct.ONBOARDING,+ profile=WIZARD,user_id=user_id,repository=repository,+ options=TaskRunOptions(+ adapter=WIZARD_CLOUD_RUN_RUNTIME_ADAPTER, model=WIZARD_CLOUD_RUN_MODEL, mcp_scopes="read_only"+ ),create_pr=True,mode="background",branch=branch,wizard_config={},wizard_head_branch=head_branch,- posthog_mcp_scopes="read_only",- runtime_adapter=WIZARD_CLOUD_RUN_RUNTIME_ADAPTER,- model=WIZARD_CLOUD_RUN_MODEL,ai_stage=WIZARD_CLOUD_RUN_AI_STAGE,# The agent server boots idle; this is the message that actually kicks it off once ready# (delivered by forward_pending_user_message). Without it the run stalls after "Started agent".@@ -2388,7 +2389,7 @@ def create_channel_task(team_id: int, user_id: int, channel_id: str | UUID, *, treturn create_task_without_run(team=Team.objects.get(id=team_id),user_id=user_id,- origin_product=Task.OriginProduct.USER_CREATED,+ profile=USER,title=title,description=description,channel=channel,@@ -11594,16 +11595,18 @@ def start_space_setup(description=build_space_setup_prompt(team_id=team.id, channel_id=str(channel.id), channel_name=channel.name, request=request),- origin_product=Task.OriginProduct.SPACE_SETUP,+ profile=SPACE_SETUP,user_id=user_id,channel=channel,repository=repository,+ options=TaskRunOptions(+ adapter=SPACE_SETUP_RUNTIME_ADAPTER,+ model=SPACE_SETUP_MODEL,+ reasoning_effort=SPACE_SETUP_REASONING_EFFORT,+ mcp_scopes=[*contracts.SPACE_SETUP_SCOPES, CONTEXT_LAYER_INTERNAL_SCOPE],+ permission_mode="auto",+ ),create_pr=False,- posthog_mcp_scopes=[*contracts.SPACE_SETUP_SCOPES, CONTEXT_LAYER_INTERNAL_SCOPE],- runtime_adapter=SPACE_SETUP_RUNTIME_ADAPTER,- model=SPACE_SETUP_MODEL,- reasoning_effort=SPACE_SETUP_REASONING_EFFORT,- initial_permission_mode="auto",client_provenance=client_provenance,)except ValueError as e:diff --git a/products/tasks/backend/facade/canvas_tasks.py b/products/tasks/backend/facade/canvas_tasks.pyindex 8fc8dc5d6f0d..20927e3c63e3 100644--- a/products/tasks/backend/facade/canvas_tasks.py+++ b/products/tasks/backend/facade/canvas_tasks.py@@ -6,6 +6,7 @@ from django.db import transactionfrom products.tasks.backend.facade import apifrom products.tasks.backend.facade.contracts import TaskRunDTOfrom products.tasks.backend.models import Channel, Task+from products.tasks.backend.task_profiles import USERfrom products.tasks.backend.task_sources import idempotency_key_q@@ -52,6 +53,7 @@ def create_and_run_channel_task("description": description,"channel": channel,"origin_key": origin_key,+ "profile": USER.key,},)result = api.run_task(task.id, team_id, user_id, validated_data=run_options)diff --git a/products/tasks/backend/facade/profiles.py b/products/tasks/backend/facade/profiles.pyindex 0ac3972a77d9..db42f8112a01 100644--- a/products/tasks/backend/facade/profiles.py+++ b/products/tasks/backend/facade/profiles.py@@ -22,12 +22,6 @@ class DrivePolicy(StrEnum):NONE = "none"-class AccessGate(StrEnum):- DESKTOP_CODE = "desktop_code"- INBOX = "inbox"- NONE = "none"--class GithubResolution(StrEnum):ALWAYS = "always"WITH_REPOSITORY = "with_repository"@@ -48,6 +42,7 @@ class PrAuthorship(StrEnum):class WarmQuota(StrEnum):NONE = "none"AI_CREDITS = "ai_credits"+ POSTHOG_AI = "posthog_ai"class GithubAccess(StrEnum):@@ -148,9 +143,6 @@ class TaskProfile:# AUDIENCE means anyone who can read the task, such as the people in a Slack thread.# NONE means nobody, for tasks that finish on their own.drive: DrivePolicy- # A check on the person that runs at create and again on every wake. DESKTOP_CODE requires- # PostHog Code access in the organization. INBOX requires inbox access. NONE runs no check.- access_gate: AccessGate# The most queued or running tasks one person may have on this profile at once. Create and# wake refuse at the cap. None means no cap.max_live_per_user: int | None@@ -311,7 +303,6 @@ _ORIGIN_SCOPED_FIELDS = ("read_without_channel","drive","api_visible",- "access_gate","idle_minutes","max_wake_minutes","warm",diff --git a/products/tasks/backend/facade/temporal.py b/products/tasks/backend/facade/temporal.pyindex 2fcb05122421..ff8a2b56dcab 100644--- a/products/tasks/backend/facade/temporal.py+++ b/products/tasks/backend/facade/temporal.py@@ -38,6 +38,7 @@ from products.tasks.backend.temporal.process_task.activities.post_slack_update iPostSlackUpdateInput,post_slack_update,)+from products.tasks.backend.temporal.process_task.utils import mcp_exclude_tools_for_taskfrom products.tasks.backend.temporal.process_task.workflow import ProcessTaskWorkflow__all__ = [@@ -65,6 +66,7 @@ __all__ = ["execute_posthog_code_agent_relay_workflow","execute_task_processing_workflow","execute_task_processing_workflow_async",+ "mcp_exclude_tools_for_task","post_slack_update","resume_task_in_cloud_workflow","signal_task_followup_message",diff --git a/products/tasks/backend/facade/warm.py b/products/tasks/backend/facade/warm.pyindex 8a24a4f65b49..414edb5a5ed6 100644--- a/products/tasks/backend/facade/warm.py+++ b/products/tasks/backend/facade/warm.py@@ -14,6 +14,7 @@ from posthog.models.team import Teamfrom posthog.models.user import Userfrom products.tasks.backend.facade import contracts+from products.tasks.backend.facade.profiles import TaskProfilefrom products.tasks.backend.logic.services.warm import SandboxWarmer, WarmResultfrom products.tasks.backend.models import Task@@ -37,16 +38,18 @@ def _warm_result_to_dto(result: WarmResult) -> contracts.WarmRunDTO:)-def enforce_warm_quota(origin_product: str, team_id: int, user_id: int) -> None:+def enforce_warm_quota(origin_product: str, team_id: int, user_id: int, *, profile: TaskProfile | None = None) -> None:"""Raise if the team may not warm a sandbox run for the origin product."""team, user = _team_and_user(team_id, user_id)- SandboxWarmer.enforce_quota(origin_product, team, user)+ SandboxWarmer.enforce_quota(origin_product, team, user, profile=profile)-def warm_pool_at_capacity(origin_product: str, team_id: int, user_id: int) -> bool:+def warm_pool_at_capacity(+ origin_product: str, team_id: int, user_id: int, *, profile: TaskProfile | None = None+) -> bool:"""Whether the user or organization already holds the max concurrent warm runs."""team, user = _team_and_user(team_id, user_id)- return SandboxWarmer.at_capacity(origin_product, team, user)+ return SandboxWarmer.at_capacity(origin_product, team, user, profile=profile)def warm_task_run(diff --git a/products/tasks/backend/logic/repo_selection/agent.py b/products/tasks/backend/logic/repo_selection/agent.pyindex dbd286175d9c..961885d4d24e 100644--- a/products/tasks/backend/logic/repo_selection/agent.py+++ b/products/tasks/backend/logic/repo_selection/agent.py@@ -19,6 +19,7 @@ from posthog.models.team.team import Teamfrom posthog.models.user_integration import UserGitHubIntegration, UserIntegrationfrom posthog.sync import database_sync_to_async+from products.tasks.backend.facade.profiles import TaskProfile, TaskSourcefrom products.tasks.backend.logic.repo_selection.types import RepoSelectionResultfrom products.tasks.backend.logic.services.custom_prompt_internals import CustomPromptSandboxContextfrom products.tasks.backend.logic.services.custom_prompt_multi_turn_runner import MultiTurnSession@@ -689,8 +690,10 @@ async def select_repository(user_id: int,context: str,*,- origin_product: Task.OriginProduct,+ profile: TaskProfile | None = None,priority: Priority,+ origin_product: Task.OriginProduct | None = None,+ source: TaskSource | None = None,github: GitHubIntegrationBase | None = None,candidate_repos: list[str] | None = None,step_name: str = "repo_selection",@@ -843,11 +846,13 @@ async def select_repository(step_name=step_name,verbose=verbose,output_fn=output_fn,+ profile=profile,+ source=source,origin_product=origin_product,signal_report_id=signal_report_id,+ internal=True,spend_signal_id=spend_signal_id,ai_stage="repo_selection",- internal=True,on_task_run_created=_session_created,fallback_from_text=_salvage,json_retry_prompt=REPO_SELECTION_JSON_RETRY_PROMPT,diff --git a/products/tasks/backend/logic/services/custom_prompt_internals.py b/products/tasks/backend/logic/services/custom_prompt_internals.pyindex 88eae2fb8c2e..4aba043bd4a8 100644--- a/products/tasks/backend/logic/services/custom_prompt_internals.py+++ b/products/tasks/backend/logic/services/custom_prompt_internals.py@@ -24,6 +24,7 @@ from posthog.temporal.oauth import PosthogMcpScopesfrom products.tasks.backend.facade.api import upload_task_run_artifactsfrom products.tasks.backend.facade.contracts import AgentStartupFailure, AgentTaskRunDTO, SessionFile+from products.tasks.backend.facade.profiles import TaskProfile, TaskRunOptions, TaskSourcefrom products.tasks.backend.logic.services.startup_failure import (AgentStartupFailed,SandboxRunFailed as SandboxRunFailed,@@ -330,15 +331,18 @@ def _with_session_files(async def _create_task_and_trigger(description: str,context: CustomPromptSandboxContext,+ *,+ profile: TaskProfile | None = None,branch: str | None = None,step_name: str = "",+ source: TaskSource | None = None,origin_product: Task.OriginProduct | None = None,signal_report_id: str | None = None,+ internal: bool = False,+ mcp_builtin_agent_key: MCPBuiltInAgentKey | None = None,ai_stage: str | None = None,ai_agent_name: str | None = None,- internal: bool = False,workflow_id_prefix: str | None = None,- mcp_builtin_agent_key: MCPBuiltInAgentKey | None = None,mcp_credential_owner_id: int | None = None,mcp_gateway_server_ids: list[str] | None = None,mcp_tool_allowlist: list[str] | None = None,@@ -351,11 +355,33 @@ async def _create_task_and_trigger() -> tuple[Task, TaskRun]:title = f"[sandbox_prompt:{step_name}] {description[:80]}" if step_name else description[:100]team = await sync_to_async(Team.objects.get)(id=context.team_id)- # Mirror Task.create_and_run's "full" default when the caller didn't set scopes — passing- # None would clobber it. sandbox_environment_id already accepts None.- posthog_mcp_scopes: PosthogMcpScopes = (- context.posthog_mcp_scopes if context.posthog_mcp_scopes is not None else "full"- )+ task_kwargs: dict[str, Any]+ if profile is not None:+ task_kwargs = {+ "profile": profile,+ "source": source,+ "options": TaskRunOptions(+ adapter=context.runtime_adapter,+ model=context.model,+ reasoning_effort=context.reasoning_effort,+ output_schema=output_schema,+ mcp_scopes=context.posthog_mcp_scopes,+ permission_mode=context.initial_permission_mode,+ ),+ }+ else:+ task_kwargs = {+ "origin_product": origin_product or Task.OriginProduct.USER_CREATED,+ "signal_report_id": signal_report_id,+ "internal": internal,+ "mcp_builtin_agent_key": mcp_builtin_agent_key,+ "posthog_mcp_scopes": context.posthog_mcp_scopes if context.posthog_mcp_scopes is not None else "full",+ "model": context.model,+ "runtime_adapter": context.runtime_adapter,+ "reasoning_effort": context.reasoning_effort,+ "initial_permission_mode": context.initial_permission_mode,+ "output_schema": output_schema,+ }extra_run_state: dict[str, Any] = {}if context.system_prompt is not None:extra_run_state["systemPrompt"] = context.system_prompt@@ -381,32 +407,23 @@ async def _create_task_and_trigger(team=team,title=title,description=description,- origin_product=origin_product or Task.OriginProduct.USER_CREATED,user_id=context.user_id,repository=context.repository,repositories=list(context.repositories) or None,create_pr=False,mode="background",branch=branch,- signal_report_id=signal_report_id,spend_signal_id=spend_signal_id,ai_stage=ai_stage,ai_agent_name=ai_agent_name,- posthog_mcp_scopes=posthog_mcp_scopes,sandbox_environment_id=context.sandbox_environment_id,- model=context.model,- runtime_adapter=context.runtime_adapter,runtime=context.runtime,pending_user_message=description if context.runtime == "pi" else None,- reasoning_effort=context.reasoning_effort,service_tier=context.service_tier,- initial_permission_mode=context.initial_permission_mode,- internal=internal,sandbox_resources=context.sandbox_resources,sandbox_timeout_seconds=context.sandbox_timeout_seconds,workflow_id_prefix=workflow_id_prefix,github_read_access=context.github_read_access,- mcp_builtin_agent_key=mcp_builtin_agent_key,mcp_credential_owner_id=mcp_credential_owner_id,mcp_gateway_server_ids=mcp_gateway_server_ids,mcp_tool_allowlist=mcp_tool_allowlist,@@ -414,7 +431,7 @@ async def _create_task_and_trigger(extra_run_state=extra_run_state,origin_key=origin_key,before_task_dispatch=before_task_dispatch,- output_schema=output_schema,+ **task_kwargs,)# lambda wrap: task.latest_run is a lazy ORM property; sync_to_async needs a callabletask_run = await sync_to_async(lambda: task.latest_run)()@@ -426,15 +443,18 @@ async def _create_task_and_trigger(async def create_task_and_trigger(description: str,context: CustomPromptSandboxContext,+ *,+ profile: TaskProfile | None = None,branch: str | None = None,step_name: str = "",+ source: TaskSource | None = None,origin_product: Task.OriginProduct | None = None,signal_report_id: str | None = None,+ internal: bool = False,+ mcp_builtin_agent_key: MCPBuiltInAgentKey | None = None,ai_stage: str | None = None,ai_agent_name: str | None = None,- internal: bool = False,workflow_id_prefix: str | None = None,- mcp_builtin_agent_key: MCPBuiltInAgentKey | None = None,mcp_credential_owner_id: int | None = None,mcp_gateway_server_ids: list[str] | None = None,output_schema: dict[str, Any] | None = None,@@ -444,16 +464,18 @@ async def create_task_and_trigger(task, task_run = await _create_task_and_trigger(description,context,+ profile=profile,branch=branch,step_name=step_name,+ source=source,origin_product=origin_product,signal_report_id=signal_report_id,+ internal=internal,+ mcp_builtin_agent_key=mcp_builtin_agent_key,spend_signal_id=spend_signal_id,ai_stage=ai_stage,ai_agent_name=ai_agent_name,- internal=internal,workflow_id_prefix=workflow_id_prefix,- mcp_builtin_agent_key=mcp_builtin_agent_key,mcp_credential_owner_id=mcp_credential_owner_id,mcp_gateway_server_ids=mcp_gateway_server_ids,output_schema=output_schema,diff --git a/products/tasks/backend/logic/services/custom_prompt_multi_turn_runner.py b/products/tasks/backend/logic/services/custom_prompt_multi_turn_runner.pyindex 0288718c5fd3..4aea60a2c51c 100644--- a/products/tasks/backend/logic/services/custom_prompt_multi_turn_runner.py+++ b/products/tasks/backend/logic/services/custom_prompt_multi_turn_runner.py@@ -13,6 +13,7 @@ from pydantic import BaseModel, JsonValue, ValidationErrorfrom products.tasks.backend.facade.api import record_run_failure_causefrom products.tasks.backend.facade.contracts import SessionFile+from products.tasks.backend.facade.profiles import TaskProfile, TaskSourcefrom products.tasks.backend.models import MCPBuiltInAgentKey, Task, TaskRunif TYPE_CHECKING:@@ -85,16 +86,19 @@ class MultiTurnSession:context: CustomPromptSandboxContext,model: type[_ModelT],*,+ profile: TaskProfile | None = None,branch: str | None = None,step_name: str = "",verbose: bool = False,output_fn: OutputFn = None,+ source: TaskSource | None = None,origin_product: Task.OriginProduct | None = None,signal_report_id: str | None = None,+ internal: bool = False,+ mcp_builtin_agent_key: MCPBuiltInAgentKey | None = None,spend_signal_id: str | None = None,ai_stage: str | None = None,ai_agent_name: str | None = None,- internal: bool = False,on_task_run_created: Callable[[TaskRun], Awaitable[None]] | None = None,before_task_dispatch: Callable[[UUID], dict[str, JsonValue] | None] | None = None,origin_key: str | None = None,@@ -102,7 +106,6 @@ class MultiTurnSession:fallback_from_text: Callable[[str], _ModelT] | None = None,json_retry_prompt: str | None = None,workflow_id_prefix: str | None = None,- mcp_builtin_agent_key: MCPBuiltInAgentKey | None = None,mcp_credential_owner_id: int | None = None,mcp_gateway_server_ids: list[str] | None = None,mcp_tool_allowlist: list[str] | None = None,@@ -134,22 +137,24 @@ class MultiTurnSession:session, last_message = await cls.start_raw(prompt=prompt,context=context,+ profile=profile,branch=branch,step_name=step_name,verbose=verbose,output_fn=output_fn,+ source=source,origin_product=origin_product,signal_report_id=signal_report_id,+ internal=internal,+ mcp_builtin_agent_key=mcp_builtin_agent_key,spend_signal_id=spend_signal_id,ai_stage=ai_stage,ai_agent_name=ai_agent_name,- internal=internal,on_task_run_created=on_task_run_created,before_task_dispatch=before_task_dispatch,origin_key=origin_key,max_poll_seconds=max_poll_seconds,workflow_id_prefix=workflow_id_prefix,- mcp_builtin_agent_key=mcp_builtin_agent_key,mcp_credential_owner_id=mcp_credential_owner_id,mcp_gateway_server_ids=mcp_gateway_server_ids,mcp_tool_allowlist=mcp_tool_allowlist,@@ -216,23 +221,25 @@ class MultiTurnSession:prompt: str,context: CustomPromptSandboxContext,*,+ profile: TaskProfile | None = None,branch: str | None = None,step_name: str = "",verbose: bool = False,output_fn: OutputFn = None,+ source: TaskSource | None = None,origin_product: Task.OriginProduct | None = None,signal_report_id: str | None = None,+ internal: bool = False,+ mcp_builtin_agent_key: MCPBuiltInAgentKey | None = None,spend_signal_id: str | None = None,ai_stage: str | None = None,ai_agent_name: str | None = None,- internal: bool = False,on_task_run_created: Callable[[TaskRun], Awaitable[None]] | None = None,before_task_dispatch: Callable[[UUID], dict[str, JsonValue] | None] | None = None,origin_key: str | None = None,max_poll_seconds: int | None = None,poll_deadline: float | None = None,workflow_id_prefix: str | None = None,- mcp_builtin_agent_key: MCPBuiltInAgentKey | None = None,mcp_credential_owner_id: int | None = None,mcp_gateway_server_ids: list[str] | None = None,mcp_tool_allowlist: list[str] | None = None,@@ -267,16 +274,18 @@ class MultiTurnSession:task, task_run = await create_task_and_trigger(prompt,context,+ profile=profile,branch=branch,step_name=step_name,+ source=source,origin_product=origin_product,signal_report_id=signal_report_id,+ internal=internal,+ mcp_builtin_agent_key=mcp_builtin_agent_key,spend_signal_id=spend_signal_id,ai_stage=ai_stage,ai_agent_name=ai_agent_name,- internal=internal,workflow_id_prefix=workflow_id_prefix,- mcp_builtin_agent_key=mcp_builtin_agent_key,mcp_credential_owner_id=mcp_credential_owner_id,mcp_gateway_server_ids=mcp_gateway_server_ids,mcp_tool_allowlist=mcp_tool_allowlist,diff --git a/products/tasks/backend/logic/services/image_builder.py b/products/tasks/backend/logic/services/image_builder.pyindex 4993bfb22bae..be0e1ae01e0a 100644--- a/products/tasks/backend/logic/services/image_builder.py+++ b/products/tasks/backend/logic/services/image_builder.py@@ -8,6 +8,7 @@ from products.tasks.backend.constants import (vm_sandbox_default_base_origin_products,vm_sandbox_origin_rollout_percentages,)+from products.tasks.backend.facade.profiles import TaskRunOptionsfrom products.tasks.backend.logic.services.image_spec import (SANDBOX_IMAGE_SPEC_PATH,SandboxImageSpec,@@ -15,6 +16,7 @@ from products.tasks.backend.logic.services.image_spec import (parse_image_spec_yaml,)from products.tasks.backend.models import SandboxCustomImage, Task, TaskRun+from products.tasks.backend.task_profiles import IMAGE_BUILDERlogger = logging.getLogger(__name__)@@ -127,15 +129,15 @@ def ensure_image_builder_task(image: SandboxCustomImage, user_id: int) -> Task:team=image.team,title=f"Custom image: {image.name}",description=f"Image-builder session for custom sandbox image '{image.name}'",- origin_product=Task.OriginProduct.IMAGE_BUILDER,+ profile=IMAGE_BUILDER,user_id=user_id,repository=image.repository or None,+ options=TaskRunOptions(+ adapter="claude", model=IMAGE_BUILDER_MODEL, reasoning_effort=IMAGE_BUILDER_REASONING_EFFORT+ ),create_pr=False,mode="interactive",interaction_origin="desktop",- runtime_adapter="claude",- model=IMAGE_BUILDER_MODEL,- reasoning_effort=IMAGE_BUILDER_REASONING_EFFORT,pending_user_message=build_image_builder_prompt(image),custom_image_builder_id=str(image.id),)diff --git a/products/tasks/backend/logic/services/task_analysis.py b/products/tasks/backend/logic/services/task_analysis.pyindex d692e3e18049..931a2cb8856d 100644--- a/products/tasks/backend/logic/services/task_analysis.py+++ b/products/tasks/backend/logic/services/task_analysis.py@@ -24,6 +24,7 @@ from products.tasks.backend.constants import (TASK_ANALYSIS_ACTIVITIES_STATE_KEY,)from products.tasks.backend.facade.contracts import TaskAnalysisError+from products.tasks.backend.facade.profiles import TaskRunOptionsfrom products.tasks.backend.logic.services.staged_artifacts import (RUN_ARTIFACT_TTL_DAYS,build_task_artifact_entry,@@ -31,6 +32,7 @@ from products.tasks.backend.logic.services.staged_artifacts import (tag_task_artifact,)from products.tasks.backend.models import SandboxCustomImage, Task, TaskRun+from products.tasks.backend.task_profiles import TASK_ANALYSISfrom products.tasks.backend.task_sources import idempotency_key_startswith_qlogger = structlog.get_logger(__name__)@@ -263,20 +265,18 @@ def create_task_analysis(*, team: Team, user_id: int, target_task: Task, target_team=team,title=f"Task analysis: {target_task.title[:120]}",description=prompt,- origin_product=Task.OriginProduct.TASK_ANALYSIS,+ profile=TASK_ANALYSIS,user_id=user_id,- repository=None,+ options=TaskRunOptions(+ adapter=TASK_ANALYSIS_RUNTIME_ADAPTER, model=TASK_ANALYSIS_MODEL, mcp_scopes="read_only"+ ),create_pr=False,mode="background",start_workflow=False,origin_key=origin_key,- posthog_mcp_scopes="read_only",- runtime_adapter=TASK_ANALYSIS_RUNTIME_ADAPTER,- model=TASK_ANALYSIS_MODEL,pending_user_message=prompt,extra_run_state=extra_run_state,inactivity_timeout_seconds=TASK_ANALYSIS_INACTIVITY_TIMEOUT_SECONDS,- internal=True,)except IntegrityError:claimed = find_existing_analysis_task(team_id=team.id, target_run_id=str(target_run.id))diff --git a/products/tasks/backend/logic/services/tests/test_warm.py b/products/tasks/backend/logic/services/tests/test_warm.pyindex 44f8486f3939..58cc7d81dee5 100644--- a/products/tasks/backend/logic/services/tests/test_warm.py+++ b/products/tasks/backend/logic/services/tests/test_warm.py@@ -1,7 +1,8 @@+from dataclasses import replacefrom datetime import datetime, timedeltafrom posthog.test.base import APIBaseTest-from unittest.mock import patch+from unittest.mock import MagicMock, patchfrom django.utils import timezone@@ -14,6 +15,7 @@ from posthog.models.team import Teamfrom products.signals.backend.models import SignalReportfrom products.tasks.backend.access import PostHogAIAccessDecisionfrom products.tasks.backend.constants import DEFAULT_SANDBOX_WORKING_DIR+from products.tasks.backend.facade.profiles import WarmPolicy, WarmQuota, get_task_profilefrom products.tasks.backend.logic.services.warm import ActiveSessionCaps, SandboxWarmer, WarmSourceChangedfrom products.tasks.backend.models import SandboxSession, Task, TaskRun@@ -530,3 +532,107 @@ class TestSandboxWarmerAtCapacity(APIBaseTest):)assert scope == expected+++class TestSandboxWarmerProfilePolicy(APIBaseTest):+ @staticmethod+ def _profile(origin: str, warm: WarmPolicy | None):+ return replace(get_task_profile("user"), key="test.warm", origin_product=origin, warm=warm)++ def _warm_runs(self, count: int) -> None:+ for _ in range(count):+ task = Task.objects.create(+ team=self.team,+ title="",+ description="",+ origin_product=Task.OriginProduct.POSTHOG_AI,+ created_by=self.user,+ )+ task.create_run(mode="interactive", extra_state={"await_user_message": True})++ @parameterized.expand(+ [+ (+ "profile_without_warm_denies_a_warmable_origin",+ Task.OriginProduct.POSTHOG_AI,+ None,+ False,+ True,+ PermissionDenied,+ ),+ (+ "profile_warm_allows_an_origin_the_registry_denies",+ Task.OriginProduct.ERROR_TRACKING,+ WarmPolicy(quota=WarmQuota.AI_CREDITS, per_user_cap=2, per_org_cap=10, feature_flag=None),+ False,+ True,+ None,+ ),+ (+ "profile_ai_credits_quota_blocks_a_limited_team",+ Task.OriginProduct.ERROR_TRACKING,+ WarmPolicy(quota=WarmQuota.AI_CREDITS, per_user_cap=2, per_org_cap=10, feature_flag=None),+ True,+ True,+ QuotaLimitExceeded,+ ),+ (+ "profile_without_a_quota_ignores_the_credit_limit",+ Task.OriginProduct.POSTHOG_AI,+ WarmPolicy(quota=WarmQuota.NONE, per_user_cap=2, per_org_cap=10, feature_flag=None),+ True,+ True,+ None,+ ),+ (+ "profile_posthog_ai_quota_refuses_a_user_without_access",+ Task.OriginProduct.POSTHOG_AI,+ WarmPolicy(quota=WarmQuota.POSTHOG_AI, per_user_cap=2, per_org_cap=10, feature_flag=None),+ False,+ False,+ PermissionDenied,+ ),+ (+ "profile_posthog_ai_quota_still_checks_credits",+ Task.OriginProduct.POSTHOG_AI,+ WarmPolicy(quota=WarmQuota.POSTHOG_AI, per_user_cap=2, per_org_cap=10, feature_flag=None),+ True,+ True,+ QuotaLimitExceeded,+ ),+ ]+ )+ def test_enforce_quota_follows_the_profile(self, _name, origin, warm, team_limited, access_allowed, expected_error):+ profile = self._profile(origin, warm)+ access = MagicMock(allowed=access_allowed)++ with (+ patch(f"{WARM}.is_team_limited", return_value=team_limited),+ patch(f"{WARM}.get_posthog_ai_access_decision", return_value=access),+ ):+ if expected_error is None:+ SandboxWarmer.enforce_quota(origin, self.team, self.user, profile=profile)+ else:+ with self.assertRaises(expected_error):+ SandboxWarmer.enforce_quota(origin, self.team, self.user, profile=profile)++ @parameterized.expand(+ [+ ("user_cap_below_the_origin_cap", 1, 10, 1, True),+ ("user_cap_above_the_origin_cap", 3, 10, _CAPS.per_user, False),+ ("org_cap_below_the_origin_cap", 10, 1, 1, True),+ ]+ )+ def test_at_capacity_follows_the_profile_caps(self, _name, per_user_cap, per_org_cap, existing_warm_runs, expected):+ warm = WarmPolicy(quota=WarmQuota.NONE, per_user_cap=per_user_cap, per_org_cap=per_org_cap, feature_flag=None)+ profile = self._profile(Task.OriginProduct.POSTHOG_AI, warm)+ self._warm_runs(existing_warm_runs)++ assert (+ SandboxWarmer.at_capacity(Task.OriginProduct.POSTHOG_AI, self.team, self.user, profile=profile) is expected+ )++ def test_at_capacity_without_a_profile_uses_the_origin_caps(self):+ self._warm_runs(_CAPS.per_user)++ assert SandboxWarmer.at_capacity(Task.OriginProduct.POSTHOG_AI, self.team, self.user) is Truediff --git a/products/tasks/backend/logic/services/warm.py b/products/tasks/backend/logic/services/warm.pyindex 25dd8eebfee4..2f72ab3e3bd9 100644--- a/products/tasks/backend/logic/services/warm.py+++ b/products/tasks/backend/logic/services/warm.py@@ -31,6 +31,7 @@ from posthog.models.team import Teamfrom posthog.models.user import Userfrom products.tasks.backend.access import get_posthog_ai_access_decision+from products.tasks.backend.facade.profiles import TaskProfile, WarmQuotafrom products.tasks.backend.logic.services.compute_quota import organization_deactivatedfrom products.tasks.backend.logic.services.workflow_dispatch import WorkflowDispatchOptions, enqueue_or_start_workflowfrom products.tasks.backend.metrics import observe_warm_churn_throttled@@ -104,6 +105,13 @@ def _posthog_ai_checker(team: Team, user: User) -> None:_ai_credits_checker(team, user)+_CHECKERS_BY_WARM_QUOTA: dict[WarmQuota, Callable[[Team, User], None] | None] = {+ WarmQuota.AI_CREDITS: _ai_credits_checker,+ WarmQuota.POSTHOG_AI: _posthog_ai_checker,+ WarmQuota.NONE: None,+}++class SandboxWarmer:"""Idempotently warm a sandbox Run for an existing Task, enforcing the product's quota gate and astate-derived warm-pool cap, then dispatching the processing workflow after commit.@@ -149,22 +157,28 @@ class SandboxWarmer:self.user = user@classmethod- def enforce_quota(cls, origin_product: str, team: Team, user: User) -> None:+ def enforce_quota(cls, origin_product: str, team: Team, user: User, *, profile: TaskProfile | None = None) -> None:"""Raise if ``team`` may not warm a Run for ``origin_product`` (over quota, or origin not registered).Fail-closed: an origin absent from the registry is denied. A registered origin whose gate is- ``None`` is allowed with no billing quota (enablement + caps gate it elsewhere).+ ``None`` is allowed with no billing quota (enablement + caps gate it elsewhere). A profile+ answers from its warm policy instead of the origin registry."""- if origin_product not in cls.ORIGIN_PRODUCT_QUOTA:- raise PermissionDenied(f"Warming is not enabled for origin product '{origin_product}'.")+ if profile is not None:+ if profile.warm is None:+ raise PermissionDenied(f"Warming is not enabled for origin product '{origin_product}'.")+ checker = _CHECKERS_BY_WARM_QUOTA[profile.warm.quota]+ else:+ if origin_product not in cls.ORIGIN_PRODUCT_QUOTA:+ raise PermissionDenied(f"Warming is not enabled for origin product '{origin_product}'.")+ checker = cls.ORIGIN_PRODUCT_QUOTA[origin_product]if organization_deactivated(team.id):raise PermissionDenied("Your organization has been deactivated.")- checker = cls.ORIGIN_PRODUCT_QUOTA[origin_product]if checker is not None:checker(team, user)@classmethod- def at_capacity(cls, origin_product: str, team: Team, user: User) -> bool:+ def at_capacity(cls, origin_product: str, team: Team, user: User, *, profile: TaskProfile | None = None) -> bool:"""True if the user or org already holds the max concurrent *warm* Runs.Counts only Runs still awaiting their first message (``state.await_user_message`` set) — so the@@ -174,7 +188,10 @@ class SandboxWarmer:serialized by the per-Task lock, so it may overshoot slightly under heavy concurrency — acceptablefor a best-effort resource guard."""- caps = cls.ORIGIN_PRODUCT_CAPS.get(origin_product, cls._DEFAULT_CAPS)+ if profile is not None and profile.warm is not None:+ caps = WarmPoolCaps(per_user=profile.warm.per_user_cap, per_org=profile.warm.per_org_cap)+ else:+ caps = cls.ORIGIN_PRODUCT_CAPS.get(origin_product, cls._DEFAULT_CAPS)# `await_user_message` is stored literally (the field is alias-free in PostHogAIRunState); see the# comment there before adding an alias, which would silently break this filter and open the cap.warm_runs = TaskRun.objects.filter(@@ -321,10 +338,11 @@ class SandboxWarmer:"""# Quota is a gateway/cache call — check it before taking the row lock, never while holding it.origin_product = self.task.origin_product+ profile = self.task.stored_profileteam = self.task.team- self.enforce_quota(origin_product, team, self.user)+ self.enforce_quota(origin_product, team, self.user, profile=profile)churned = self._warm_churn_exceeded()- pool_full = self.at_capacity(origin_product, team, self.user)+ pool_full = self.at_capacity(origin_product, team, self.user, profile=profile)new_run: TaskRunwith transaction.atomic():diff --git a/products/tasks/backend/task_profiles.py b/products/tasks/backend/task_profiles.pynew file mode 100644index 000000000000..7325847d66d9--- /dev/null+++ b/products/tasks/backend/task_profiles.py@@ -0,0 +1,169 @@+from dataclasses import replace++from products.tasks.backend.facade.profiles import (+ DrivePolicy,+ GithubAccess,+ GithubResolution,+ NetworkAccess,+ NetworkPolicy,+ OAuthApp,+ PrAuthorship,+ Read,+ SourceKind,+ TaskProfile,+ WarmPolicy,+ WarmQuota,+ register_task_profiles,+)++PUBLIC_RUN_OPTIONS = frozenset(+ {+ "runtime",+ "adapter",+ "model",+ "reasoning_effort",+ "repositories",+ "output_schema",+ "permission_mode",+ "auto_publish",+ }+)+PREWARM_SANDBOX_FLAG = "tasks-prewarm-sandbox"++_BASE = TaskProfile(+ key="tasks.base",+ origin_product="",+ public=False,+ public_options=frozenset(),+ source_kind=None,+ listed=True,+ read_without_channel=Read.CREATOR,+ api_visible=True,+ drive=DrivePolicy.OWNER,+ max_live_per_user=None,+ warm=None,+ runtimes=("acp",),+ sandbox_templates=("default_base",),+ network=NetworkPolicy(levels=(NetworkAccess.FULL,)),+ inherit_user_defaults=True,+ personal_mcp=True,+ mcp_agent=None,+ mcp_scopes="full",+ mcp_store_servers=True,+ mcp_exclude_tools=(),+ oauth_app=OAuthApp.ARRAY,+ github_resolution=GithubResolution.WITH_REPOSITORY,+ github_access=GithubAccess.WRITE,+ user_authorable_prs=False,+ default_pr_authorship=PrAuthorship.BOT,+ create_pr=True,+ finish_tool=False,+ done_on_turn_close=False,+ idle_minutes=30,+ inactivity_minutes=10,+ tool_call_minutes=None,+ max_wake_minutes=180,+ billing_product="posthog_code",+ bills_compute=False,+ max_cost_usd=None,+ task_budget_usd=None,+ finish_in_flight=True,+)++_PUBLIC = replace(_BASE, public=True, public_options=PUBLIC_RUN_OPTIONS)++USER = replace(+ _PUBLIC,+ key="user",+ origin_product="user_created",+ runtimes=("acp", "pi"),+ network=NetworkPolicy(levels=(NetworkAccess.FULL, NetworkAccess.TRUSTED, NetworkAccess.CUSTOM)),+ warm=WarmPolicy(quota=WarmQuota.NONE, per_user_cap=10, per_org_cap=100, feature_flag=PREWARM_SANDBOX_FLAG),+ github_resolution=GithubResolution.ALWAYS,+ user_authorable_prs=True,+ default_pr_authorship=PrAuthorship.USER,+ idle_minutes=60,+ max_wake_minutes=None,+ bills_compute=True,+)++ERROR_TRACKING = replace(_PUBLIC, key="error_tracking", origin_product="error_tracking")+EVAL_CLUSTERS = replace(_PUBLIC, key="eval_clusters", origin_product="eval_clusters")+SUPPORT_QUEUE = replace(_PUBLIC, key="support_queue", origin_product="support_queue")+SESSION_SUMMARIES = replace(_PUBLIC, key="session_summaries", origin_product="session_summaries")+MCP_ANALYTICS = replace(_PUBLIC, key="mcp_analytics", origin_product="mcp_analytics")+LOOP = replace(_PUBLIC, key="loop", origin_product="loop", mcp_scopes="read_only")++HOGDESK = replace(+ _PUBLIC, key="hogdesk", origin_product="hogdesk", read_without_channel=Read.TEAM, drive=DrivePolicy.AUDIENCE+)++WIZARD = replace(+ _BASE,+ key="wizard",+ origin_product="onboarding",+ read_without_channel=Read.TEAM,+ drive=DrivePolicy.AUDIENCE,+ mcp_scopes="read_only",+ billing_product="onboarding",+)++SPACE_SETUP = replace(+ _BASE,+ key="space_setup",+ origin_product="space_setup",+ idle_minutes=60,+ max_wake_minutes=None,+ bills_compute=True,+)++IMAGE_BUILDER = replace(+ _BASE,+ key="image_builder",+ origin_product="image_builder",+ github_resolution=GithubResolution.ALWAYS,+ idle_minutes=60,+ max_wake_minutes=None,+)++TASK_ANALYSIS = replace(+ _BASE,+ key="task_analysis",+ origin_product="task_analysis",+ listed=False,+ inherit_user_defaults=False,+ personal_mcp=False,+ mcp_scopes="read_only",+ billing_product="background_agents",+)++WORKFLOW = replace(+ _BASE,+ key="workflow",+ origin_product="workflow",+ source_kind=SourceKind.HOG_FLOW,+ read_without_channel=Read.TEAM,+ drive=DrivePolicy.AUDIENCE,+ mcp_agent="workflow",+ billing_product="workflows",+)++PROFILES = (+ USER,+ ERROR_TRACKING,+ EVAL_CLUSTERS,+ SUPPORT_QUEUE,+ SESSION_SUMMARIES,+ MCP_ANALYTICS,+ LOOP,+ HOGDESK,+ WIZARD,+ SPACE_SETUP,+ IMAGE_BUILDER,+ TASK_ANALYSIS,+ WORKFLOW,+)+++def register() -> None:+ register_task_profiles(PROFILES)diff --git a/products/tasks/backend/temporal/process_task/activities/tests/test_get_task_processing_context.py b/products/tasks/backend/temporal/process_task/activities/tests/test_get_task_processing_context.pyindex b78b5022367c..5669d2fa212f 100644--- a/products/tasks/backend/temporal/process_task/activities/tests/test_get_task_processing_context.py+++ b/products/tasks/backend/temporal/process_task/activities/tests/test_get_task_processing_context.py@@ -485,6 +485,8 @@ class TestGetTaskProcessingContextActivity:(None, False, False),("business_knowledge", True, False),("business_knowledge", False, False),+ ("space_setup", True, True),+ ("space_setup", False, False),("test.unregistered", True, True),],)diff --git a/products/tasks/backend/tests/test_api.py b/products/tasks/backend/tests/test_api.pyindex 109c759138e3..1e020a70401c 100644--- a/products/tasks/backend/tests/test_api.py+++ b/products/tasks/backend/tests/test_api.py@@ -18500,6 +18500,7 @@ class TestSandboxCustomImageAPI(BaseTaskAPITest):task = Task.objects.get(id=data["builder_task_id"])self.assertEqual(task.repository, "posthog/hedgebox")self.assertEqual(task.origin_product, Task.OriginProduct.IMAGE_BUILDER)+ self.assertEqual(task.profile, "image_builder")run = task.runs.order_by("-created_at").first()assert run is not Noneself.assertIn("/tmp/workspace/repos/posthog/hedgebox", run.state["pending_user_message"])@@ -18971,6 +18972,7 @@ class TestTaskRunAnalyzeAPI(BaseTaskAPITest):self.assertTrue(body["created"])analysis_task = Task.objects.get(id=body["analysis_task_id"])self.assertEqual(analysis_task.origin_product, Task.OriginProduct.TASK_ANALYSIS)+ self.assertEqual(analysis_task.profile, "task_analysis")self.assertTrue(analysis_task.internal)self.assertIn("analyzing-task-runs", analysis_task.description)run = analysis_task.latest_rundiff --git a/products/tasks/backend/tests/test_channel_extras.py b/products/tasks/backend/tests/test_channel_extras.pyindex 3019853c6918..41d09f320a57 100644--- a/products/tasks/backend/tests/test_channel_extras.py+++ b/products/tasks/backend/tests/test_channel_extras.py@@ -183,6 +183,7 @@ class TestChannelSetup(ChannelExtrasBaseTest):task = Task.objects.get(id=response.json()["task_id"])assert task.channel_id == self.channel.idassert task.origin_product == Task.OriginProduct.SPACE_SETUP+ assert task.profile == "space_setup"assert task.created_by_id == self.user.idassert "Increase the weekly activation rate" in task.descriptionassert "posthog/posthog" in task.descriptiondiff --git a/products/tasks/backend/tests/test_multi_turn_session.py b/products/tasks/backend/tests/test_multi_turn_session.pyindex 564036fa4e50..aef7b4a20a9f 100644--- a/products/tasks/backend/tests/test_multi_turn_session.py+++ b/products/tasks/backend/tests/test_multi_turn_session.py@@ -23,6 +23,7 @@ from posthog.storage.object_storage import ObjectStorageErrorfrom products.tasks.backend.facade import agents as agents_facadefrom products.tasks.backend.facade.api import _public_task_run_statefrom products.tasks.backend.facade.contracts import SessionFile+from products.tasks.backend.facade.profiles import get_task_profilefrom products.tasks.backend.logic.services.custom_prompt_internals import (AgentError,AgentTurnFailed,@@ -65,6 +66,9 @@ from products.tasks.backend.tests.agent_log_fixtures import (FIXTURES_DIR = Path(__file__).parent / "fixtures"+USER = get_task_profile("user")++class _Resp(BaseModel):value: str@@ -1891,6 +1895,7 @@ class TestMultiTurnSessionStartBranch:prompt="hello",context=context,model=_Resp,+ profile=USER,**kwargs,)@@ -1951,6 +1956,7 @@ class TestMultiTurnSessionStartCleanup:prompt="test",context=CustomPromptSandboxContext(team_id=1, user_id=2),model=_Resp,+ profile=USER,)# session.end() must have signalled the workflow exactly once on the cleanup path.@@ -1981,7 +1987,7 @@ class TestCreateTaskAndTriggerForwardsContext:"ctx_env, ctx_scopes, expected_env, expected_scopes",[("env-uuid-abc", "read_only", "env-uuid-abc", "read_only"),- (None, None, None, "full"),+ (None, None, None, None),(None, [], None, []),],)@@ -2001,11 +2007,11 @@ class TestCreateTaskAndTriggerForwardsContext:"products.tasks.backend.logic.services.custom_prompt_internals.Task.create_and_run",return_value=mock_task,) as mock_create:- await create_task_and_trigger("prompt", context)+ await create_task_and_trigger("prompt", context, profile=USER)kwargs = mock_create.call_args.kwargsassert kwargs["sandbox_environment_id"] == expected_env- assert kwargs["posthog_mcp_scopes"] == expected_scopes+ assert kwargs["options"].mcp_scopes == expected_scopes@pytest.mark.asyncio@pytest.mark.parametrize(@@ -2027,7 +2033,7 @@ class TestCreateTaskAndTriggerForwardsContext:"products.tasks.backend.logic.services.custom_prompt_internals.Task.create_and_run",return_value=mock_task,) as mock_create:- await create_task_and_trigger("prompt", context, **{stamp: value})+ await create_task_and_trigger("prompt", context, profile=USER, **{stamp: value})assert mock_create.call_args.kwargs[stamp] == value@@ -2049,7 +2055,7 @@ class TestCreateTaskAndTriggerForwardsContext:with patch("products.tasks.backend.temporal.client.execute_task_processing_workflow"):task_run = await agents_facade.create_task_and_trigger(- "prompt", context, workflow_id_prefix=workflow_id_prefix, analytics_query_context=queries+ "prompt", context, profile=USER, workflow_id_prefix=workflow_id_prefix, analytics_query_context=queries)persisted = await sync_to_async(TaskRun.objects.get)(id=task_run.run_id)@@ -2098,11 +2104,11 @@ class TestCreateTaskAndTriggerForwardsContext:if fail_initialization:with pytest.raises(ValueError, match="Initialization failed"):await _create_task_and_trigger(- "prompt", context, origin_key="trial-example", before_task_dispatch=initialize+ "prompt", context, profile=USER, origin_key="trial-example", before_task_dispatch=initialize)else:task, run = await _create_task_and_trigger(- "prompt", context, origin_key="trial-example", before_task_dispatch=initialize+ "prompt", context, profile=USER, origin_key="trial-example", before_task_dispatch=initialize)assert task.origin_key == "trial-example"assert run.state["private_ready"] is True@@ -2128,7 +2134,11 @@ class TestCreateTaskAndTriggerForwardsContext:patch("products.tasks.backend.temporal.client.execute_task_processing_workflow"),):_, run = await _create_task_and_trigger(- "prompt", context, files=files, before_task_dispatch=lambda run_id: {"private_ready": True}+ "prompt",+ context,+ profile=USER,+ files=files,+ before_task_dispatch=lambda run_id: {"private_ready": True},)persisted = await sync_to_async(TaskRun.objects.get)(id=run.id)@@ -2152,7 +2162,7 @@ class TestCreateTaskAndTriggerForwardsContext:)with patch("products.tasks.backend.temporal.client.execute_task_processing_workflow"):- task_run = await agents_facade.create_task_and_trigger("prompt", context)+ task_run = await agents_facade.create_task_and_trigger("prompt", context, profile=USER)persisted = await sync_to_async(TaskRun.objects.get)(id=task_run.run_id)public_state = _public_task_run_state(persisted.state)@@ -2167,7 +2177,9 @@ class TestCreateTaskAndTriggerForwardsContext:context = CustomPromptSandboxContext(team_id=team.id, user_id=user.id)with patch("products.tasks.backend.temporal.client.execute_task_processing_workflow"):- task_run = await agents_facade.create_task_and_trigger("prompt", context, output_schema=output_schema)+ task_run = await agents_facade.create_task_and_trigger(+ "prompt", context, profile=USER, output_schema=output_schema+ )persisted = await sync_to_async(TaskRun.objects.get)(id=task_run.run_id)assert persisted.state.get("caller_ends_run") is expected_flag@@ -2204,14 +2216,14 @@ class TestCreateTaskAndTriggerForwardsContext:"products.tasks.backend.logic.services.custom_prompt_internals.Task.create_and_run",return_value=mock_task,) as mock_create:- await create_task_and_trigger("prompt", context)+ await create_task_and_trigger("prompt", context, profile=USER)- kwargs = mock_create.call_args.kwargs+ options = mock_create.call_args.kwargs["options"]assert (- kwargs["model"],- kwargs["runtime_adapter"],- kwargs["reasoning_effort"],- kwargs["initial_permission_mode"],+ options.model,+ options.adapter,+ options.reasoning_effort,+ options.permission_mode,) == (model, runtime_adapter, reasoning_effort, initial_permission_mode)@@ -2258,6 +2270,7 @@ class TestMultiTurnSessionStartFallback:prompt="x",context=MagicMock(),model=_Resp,+ profile=USER,fallback_from_text=lambda text: _Resp(value=text),json_retry_prompt="Return JSON" if retry_reply is not None else None,)@@ -2273,7 +2286,7 @@ class TestMultiTurnSessionStartFallback:with patch.object(MultiTurnSession, "start_raw", new=AsyncMock(return_value=(session, "prose only"))):with pytest.raises(ValueError):- await MultiTurnSession.start(prompt="x", context=MagicMock(), model=_Resp)+ await MultiTurnSession.start(prompt="x", context=MagicMock(), model=_Resp, profile=USER)session.end.assert_awaited_once() # type: ignore[attr-defined]assert session.end.await_args.kwargs.get("status") == "failed" # type: ignore[attr-defined]@@ -2287,7 +2300,7 @@ class TestMultiTurnSessionStartFallback:MultiTurnSession, "start_raw", new=AsyncMock(return_value=(session, json.dumps({"value": "ok"})))):_, parsed = await MultiTurnSession.start(- prompt="x", context=MagicMock(), model=_Resp, fallback_from_text=fallback+ prompt="x", context=MagicMock(), model=_Resp, profile=USER, fallback_from_text=fallback)assert parsed == _Resp(value="ok")@@ -2305,7 +2318,9 @@ class TestMultiTurnSessionStartFallback:with patch.object(MultiTurnSession, "start_raw", new=AsyncMock(return_value=(session, "prose only"))):with pytest.raises(ValueError):- await MultiTurnSession.start(prompt="x", context=MagicMock(), model=_Resp, fallback_from_text=boom)+ await MultiTurnSession.start(+ prompt="x", context=MagicMock(), model=_Resp, profile=USER, fallback_from_text=boom+ )session.end.assert_awaited_once() # type: ignore[attr-defined]assert session.end.await_args.kwargs.get("status") == "failed" # type: ignore[attr-defined]@@ -2322,7 +2337,9 @@ class TestMultiTurnSessionStartFallback:patch.object(MultiTurnSession, "_parse_and_validate", side_effect=asyncio.CancelledError()),):with pytest.raises(asyncio.CancelledError):- await MultiTurnSession.start(prompt="x", context=MagicMock(), model=_Resp, fallback_from_text=fallback)+ await MultiTurnSession.start(+ prompt="x", context=MagicMock(), model=_Resp, profile=USER, fallback_from_text=fallback+ )fallback.assert_not_called()session.end.assert_awaited_once() # type: ignore[attr-defined]@@ -2342,10 +2359,12 @@ class TestMultiTurnSessionStartFallback:with patch.object(MultiTurnSession, "start_raw", new=AsyncMock(return_value=(session, "prose only"))):if expected is None:with pytest.raises(ValueError):- await MultiTurnSession.start(prompt="x", context=MagicMock(), model=_Resp, json_retry_prompt="JSON")+ await MultiTurnSession.start(+ prompt="x", context=MagicMock(), model=_Resp, profile=USER, json_retry_prompt="JSON"+ )else:_, parsed = await MultiTurnSession.start(- prompt="x", context=MagicMock(), model=_Resp, json_retry_prompt="JSON"+ prompt="x", context=MagicMock(), model=_Resp, profile=USER, json_retry_prompt="JSON")assert parsed == expected@@ -2367,7 +2386,12 @@ class TestMultiTurnSessionStartFallback:with patch.object(MultiTurnSession, "start_raw", new=AsyncMock(return_value=(session, "prose only"))):with pytest.raises(RuntimeError):await MultiTurnSession.start(- prompt="x", context=MagicMock(), model=_Resp, json_retry_prompt="JSON", fallback_from_text=fallback+ prompt="x",+ context=MagicMock(),+ model=_Resp,+ profile=USER,+ json_retry_prompt="JSON",+ fallback_from_text=fallback,)fallback.assert_not_called()diff --git a/products/tasks/backend/tests/test_profile_parity.py b/products/tasks/backend/tests/test_profile_parity.pyindex b0ac14ea5cc3..eeae0a42fa98 100644--- a/products/tasks/backend/tests/test_profile_parity.py+++ b/products/tasks/backend/tests/test_profile_parity.py@@ -13,13 +13,12 @@ from products.tasks.backend.facade.profiles import (Read,TaskProfile,WarmPolicy,- WarmQuota,task_profiles,)from products.tasks.backend.facade.run_config import WARMABLE_ORIGIN_PRODUCTSfrom products.tasks.backend.logic.services.compute_quota import is_billable_computefrom products.tasks.backend.logic.services.sandbox import parse_requested_sandbox_template-from products.tasks.backend.logic.services.warm import SandboxWarmer+from products.tasks.backend.logic.services.warm import _CHECKERS_BY_WARM_QUOTA, SandboxWarmerfrom products.tasks.backend.models import MCP_BUILT_IN_AGENT_KEY_BY_ORIGIN, Task, TaskClientProvenancefrom products.tasks.backend.presentation.views.api import (WARM_SANDBOX_FLAGS_BY_ORIGIN_PRODUCT,@@ -73,7 +72,7 @@ def _master_warm_policy(origin_product: str) -> WarmPolicy | None:caps = SandboxWarmer.ORIGIN_PRODUCT_CAPS.get(origin_product, SandboxWarmer._DEFAULT_CAPS)checker = SandboxWarmer.ORIGIN_PRODUCT_QUOTA[origin_product]return WarmPolicy(- quota=WarmQuota.NONE if checker is None else WarmQuota.AI_CREDITS,+ quota=next(quota for quota, check in _CHECKERS_BY_WARM_QUOTA.items() if check is checker),per_user_cap=caps.per_user,per_org_cap=caps.per_org,feature_flag=None@@ -172,6 +171,10 @@ class TestTaskProfilesMatchMaster(SimpleTestCase):def test_default_pr_authorship_matches_master(self, _key: str, profile: TaskProfile) -> None:self.assertEqual(profile.default_pr_authorship, get_pr_authorship_mode(_task(profile), None))+ @parameterized.expand(PROFILES)+ def test_create_pr_matches_master(self, _key: str, profile: TaskProfile) -> None:+ self.assertEqual(profile.create_pr, profile.origin_product not in PRODUCT_PRIVATE_ORIGIN_PRODUCTS)+@parameterized.expand(PROFILES)def test_default_runtime_matches_master(self, _key: str, profile: TaskProfile) -> None:self.assertEqual(profile.runtimes[0], Task.Runtime.ACP)diff --git a/products/tasks/evals/repo_selection/runner.py b/products/tasks/evals/repo_selection/runner.pyindex da3f5c02b53e..5cb2aa2415b9 100644--- a/products/tasks/evals/repo_selection/runner.py+++ b/products/tasks/evals/repo_selection/runner.py@@ -29,6 +29,7 @@ from products.posthog_ai.eval_harness.runner import (from products.tasks.backend.facade import api as tasks_apifrom products.tasks.backend.facade.agents import CustomPromptSandboxContext, TurnPollTimeoutfrom products.tasks.backend.facade.contracts import TaskRunDTO+from products.tasks.backend.facade.profiles import TaskProfilefrom products.tasks.backend.facade.repo_selection import (RepoSelectionRejectedError,RepoSelectionUnavailableError,@@ -119,7 +120,8 @@ async def _select(scenario: RepoSelectionScenario,context: CustomPromptSandboxContext,*,- origin_product: tasks_api.TaskOriginProduct,+ profile: TaskProfile | None = None,+ origin_product: tasks_api.TaskOriginProduct | None = None,priority: Priority,deadline: float | None,artifacts: RepoSelectionArtifacts,@@ -131,6 +133,7 @@ async def _select(team_id=context.team_id,user_id=context.user_id,context=scenario.context_block,+ profile=profile,origin_product=origin_product,priority=priority,sandbox_environment_id=context.sandbox_environment_id,@@ -194,7 +197,8 @@ async def run_selector(scenario: RepoSelectionScenario,context: CustomPromptSandboxContext,*,- origin_product: tasks_api.TaskOriginProduct,+ profile: TaskProfile | None = None,+ origin_product: tasks_api.TaskOriginProduct | None = None,priority: Priority,provider: SandboxProviderStrategy,on_cleanup: Callable[[], Awaitable[None]] | None,@@ -217,6 +221,7 @@ async def run_selector(_select(scenario,context,+ profile=profile,origin_product=origin_product,priority=priority,deadline=deadline,@@ -262,7 +267,11 @@ async def run_selector(def selector_case_runner(- scenarios: dict[str, RepoSelectionScenario], *, origin_product: tasks_api.TaskOriginProduct, priority: Priority+ scenarios: dict[str, RepoSelectionScenario],+ *,+ profile: TaskProfile | None = None,+ origin_product: tasks_api.TaskOriginProduct | None = None,+ priority: Priority,) -> SandboxedCaseRunner:async def run(case: SandboxedEvalCase,@@ -276,6 +285,7 @@ def selector_case_runner(return await run_selector(scenarios[case.name],context,+ profile=profile,origin_product=origin_product,priority=priority,provider=provider,