Self-improving AI Employees for everyone
Python ai-agentsai-employeeai-employeesassistantautonomous-agentsco-employeescompanygrok-botinstinctloop-agentsmuseown-your-datapersonalself-hosted
fix(employees): admit a hired team's plan with its generation (#148)
trohitgff4579d3467f
diff --git a/docs-internal/node-logic-flows/ai_tools/taskManager.md b/docs-internal/node-logic-flows/ai_tools/taskManager.mdindex 3429efca..94973f92 100644--- a/docs-internal/node-logic-flows/ai_tools/taskManager.md+++ b/docs-internal/node-logic-flows/ai_tools/taskManager.md@@ -125,6 +125,12 @@ the admitted graph; model arguments cannot choose a different employee orrecipient. The durable job retains the original request, parameters, workspacegeneration, and delivery identity across delegation, review, and retries.+The saved graph keeps node data to UI fields, so the plan is saved on the+employee row, and Start and Apply copy it onto the lead in the generation's+snapshot (`team_runtime.admit_team_plan`). A run holds only the nodes its+trigger reaches, so the runtime reads the plan, and a job takes its graph,+from that whole snapshot (`team_runtime.admitted_graph`).+The acknowledgement confirms assignment only. Specialists submit work throughTask Manager, and the lead reviews and accepts it. The runtime delivers thereviewed result once to the original conversation or app, preserving approvaldiff --git a/server/core/database.py b/server/core/database.pyindex d4279120..2429c896 100644--- a/server/core/database.py+++ b/server/core/database.py@@ -3050,6 +3050,18 @@ class Database:)return result.scalar_one_or_none()+ async def get_workflow_control_generation(+ self, workflow_id: str, generation: int+ ) -> Optional[WorkflowControlExecution]:+ async with self.get_session() as session:+ result = await session.execute(+ select(WorkflowControlExecution).where(+ WorkflowControlExecution.workflow_id == workflow_id,+ WorkflowControlExecution.generation == generation,+ )+ )+ return result.scalar_one_or_none()+async def list_latest_workflow_controls(self, workflow_ids: List[str]) -> Dict[str, WorkflowControlExecution]:diff --git a/server/services/deployment/handlers.py b/server/services/deployment/handlers.pyindex 97b3db3c..faeb8604 100644--- a/server/services/deployment/handlers.py+++ b/server/services/deployment/handlers.py@@ -2053,6 +2053,7 @@ async def handle_start_workflow(data: Dict[str, Any], websocket: WebSocket) -> Dload_node_parameters,persist_parameter_aliases,)+ from services.employees.team_runtime import admit_team_planfrom services.workflow_migrations import normalize_workflow_graphfrom services.workflow_sanitizer import sanitize_workflow_graph@@ -2071,7 +2072,8 @@ async def handle_start_workflow(data: Dict[str, Any], websocket: WebSocket) -> Dparameters_by_id,)safe_graph = sanitize_workflow_graph(normalization.graph_data())- admitted_nodes = list(safe_graph["nodes"])+ # A hired team's plan is saved beside the graph, not in it.+ admitted_nodes = await admit_team_plan(service.database, workflow_id, list(safe_graph["nodes"]))admitted_edges = list(safe_graph["edges"])from services.workflow_validator import validate_workflowdiff --git a/server/services/employees/jobs.py b/server/services/employees/jobs.pyindex 40acc59f..ed8157ff 100644--- a/server/services/employees/jobs.py+++ b/server/services/employees/jobs.py@@ -128,8 +128,9 @@ def _identity(ctx: Any, mission: str) -> str:async def create_job(database: Any, ctx: Any, *, mission: str, lead_node_id: str, delivery_node_ids: list[str], dispatch: bool) -> EmployeeJob:from services.employees.store import get_by_workflowemployee = await get_by_workflow(database, str(ctx.workflow_id))- from services.employees.team_runtime import employee_runtime_plan- captured_plan = await employee_runtime_plan(database, {**ctx.raw, "nodes": ctx.nodes, "node_id": lead_node_id})+ from services.employees.team_runtime import admitted_graph, team_plan_in+ admitted = await admitted_graph(database, ctx.raw)+ captured_plan = team_plan_in(admitted, lead_node_id) if admitted else Noneplan = captured_plan or (employee.team_plan if employee else None)if not employee or not plan or plan.get("lead_node_id") != lead_node_id:raise ValueError("This employee does not have an approved team")@@ -146,10 +147,15 @@ async def create_job(database: Any, ctx: Any, *, mission: str, lead_node_id: strraise EmployeeEmailInputLimit()identifier = _identity(ctx, original_mission)# Persist the original graph/parameters rather than consulting mutable- # recipients or templates when the review completes later.- nodes = ctx.nodes or (graph.data or {}).get("nodes", [])- edges = ctx.edges or (graph.data or {}).get("edges", [])- snapshot = ctx.raw.get("parameter_snapshot") or {}+ # recipients or templates when the review completes later. A team job+ # keeps its generation's whole admitted graph: the run that admits it+ # reaches neither the delivery nodes nor, from Talk, the lead.+ if captured_plan:+ nodes, edges, snapshot = admitted["nodes"], admitted["edges"], admitted.get("parameters") or {}+ else:+ nodes = ctx.nodes or (graph.data or {}).get("nodes", [])+ edges = ctx.edges or (graph.data or {}).get("edges", [])+ snapshot = ctx.raw.get("parameter_snapshot") or {}parameters = {str(node["id"]): snapshot[str(node["id"])] if str(node["id"]) in snapshot else await database.get_node_parameters(str(node["id"])) or {} for node in nodes}from services.workflow_sanitizer import sanitize_runtime_payloadparameters = sanitize_runtime_payload(parameters)diff --git a/server/services/employees/safe_apply.py b/server/services/employees/safe_apply.pyindex e467581a..ef8fd04a 100644--- a/server/services/employees/safe_apply.py+++ b/server/services/employees/safe_apply.py@@ -37,6 +37,7 @@ async def apply_saved_changes(database: Any, workflow_id: str, *, owner_id: str,from services.workflow_validator import validate_workflowfrom services.deployment.control import _graph_hashfrom services.employees.events import employee_changed_now+ from services.employees.team_runtime import admit_team_planif not getattr(container.settings(), "employee_safe_apply_enabled", True):return {"success": False, "error": "safe_apply_disabled", "activation_state": "saved"}workflow = await database.get_workflow(workflow_id)@@ -49,6 +50,8 @@ async def apply_saved_changes(database: Any, workflow_id: str, *, owner_id: str,return {"success": False, "error": "conflict"}identifier = f"apply:{workflow_id}:{key}"snapshot = deepcopy(workflow.data)+ # A hired team's plan is saved beside the graph, not in it.+ snapshot["nodes"] = await admit_team_plan(database, workflow_id, snapshot.get("nodes", []))parameters = {node["id"]: await database.get_node_parameters(node["id"]) or {} for node in snapshot.get("nodes", [])}from services.workflow_sanitizer import sanitize_runtime_payloadsnapshot["parameters"] = sanitize_runtime_payload(parameters)diff --git a/server/services/employees/team_runtime.py b/server/services/employees/team_runtime.pyindex fb5f30a1..6e180090 100644--- a/server/services/employees/team_runtime.py+++ b/server/services/employees/team_runtime.py@@ -220,15 +220,49 @@ def validate_managed_assignment(args, scope):raise ValueError("Employee job assignment depends_on must be a list of resolved task IDs")-async def employee_runtime_plan(database, context):- """Resolve the off-canvas boundary from server-owned employee metadata."""- nodes = context.get("nodes", [])+async def admit_team_plan(database, workflow_id: str, nodes: list) -> list:+ """Put the employee's team plan on its lead in a graph being admitted.++ The saved graph cannot hold it (``workflow_sanitizer`` keeps node data to+ UI fields), so it is saved on the employee row beside the graph+ (``store.commit_hire``, ``workflow_storage.mutate``). Start and Apply copy+ it into the generation, which then runs the plan it was admitted with.+ """+ from services.employees.team_recipe import TEAM_LEAD_TYPE+ if not any(node.get("type") == TEAM_LEAD_TYPE for node in nodes):+ return nodes+ from copy import deepcopy+ from services.employees.store import get_by_workflow+ employee = await get_by_workflow(database, str(workflow_id))+ plan = (employee.team_plan if employee else None) or {}+ if plan.get("version") != 2:+ return nodes+ return [{**node, "data": {**(node.get("data") or {}), "employee_recipe_version": 2, "employee_team_plan": deepcopy(plan)}}+ if node.get("id") == plan.get("lead_node_id") else node for node in nodes]+++async def admitted_graph(database, context):+ """The whole graph the run's generation admitted: its control snapshot.++ A run holds only the nodes its trigger reaches, never a job's delivery+ nodes and, for a Talk run, not the lead.+ """+ generation = int(context.get("generation") or 0)+ if generation <= 0 or not context.get("workflow_id"):+ return None+ control = await database.get_workflow_control_generation(str(context["workflow_id"]), generation)+ return control.graph_snapshot if control else None+++def team_plan_in(graph, node_id):+ """The v2 plan an admitted graph carries, for its lead or Talk contact."""+ nodes = graph.get("nodes") or []lead = next((node for node in nodes if (node.get("data") or {}).get("employee_recipe_version") == 2), None)if not lead:return Nonefrom copy import deepcopyplan = deepcopy((lead.get("data") or {}).get("employee_team_plan") or {})- if plan.get("version") != 2 or context.get("node_id") not in {plan.get("lead_node_id"), plan.get("talk_node_id")}:+ if plan.get("version") != 2 or node_id not in {plan.get("lead_node_id"), plan.get("talk_node_id")}:return Noneids = {node.get("id") for node in nodes}referenced = {plan.get("lead_node_id"), plan.get("talk_node_id"), *plan.get("delivery_node_ids", []), *plan.get("talk_delivery_node_ids", []), *(member.get("node_id") for member in plan.get("members", []))}@@ -237,6 +271,12 @@ async def employee_runtime_plan(database, context):return plan+async def employee_runtime_plan(database, context):+ """Resolve the off-canvas boundary from the generation's admitted graph."""+ graph = await admitted_graph(database, context)+ return team_plan_in(graph, context.get("node_id")) if graph else None++async def admit_employee_runtime_job(database, context, plan, mission, review=None):if not plan or context.get("node_id") != plan.get("lead_node_id"):returndiff --git a/server/services/plugin/edge_walker.py b/server/services/plugin/edge_walker.pyindex 2eadc645..038770ae 100644--- a/server/services/plugin/edge_walker.py+++ b/server/services/plugin/edge_walker.py@@ -310,11 +310,12 @@ async def collect_agent_connections((node for node in (context.get("nodes") or []) if node.get("id") == node_id),None,)- if any((node.get("data") or {}).get("employee_recipe_version") == 2 for node in context.get("nodes", [])):- from services.employees.team_runtime import employee_runtime_plan- plan = await employee_runtime_plan(database, {**context, "node_id": node_id})- if plan and node_id == plan.get("talk_node_id") and not any(entry.get("node_type") == "taskManager" for entry in tool_data):- tool_data.append({"node_id": f"builtin_task_manager_{node_id}", "node_type": "taskManager", "parameters": {}, "label": "Task Manager", "builtin": True})+ # An employee's Talk contact submits jobs to its team. Prepare resolved the+ # plan from the generation's admitted graph: a Talk run never holds the lead+ # that carries it.+ plan = context.get("employee_team_plan") or {}+ if node_id == plan.get("talk_node_id") and not any(entry.get("node_type") == "taskManager" for entry in tool_data):+ tool_data.append({"node_id": f"builtin_task_manager_{node_id}", "node_type": "taskManager", "parameters": {}, "label": "Task Manager", "builtin": True})if (current_node or {}).get("type") in TEAM_LEAD_TYPES and not any(entry.get("node_type") == "taskManager" for entry in tool_data):diff --git a/server/tests/services/employees/test_jobs.py b/server/tests/services/employees/test_jobs.pyindex 4fc3bf55..19785f6b 100644--- a/server/tests/services/employees/test_jobs.py+++ b/server/tests/services/employees/test_jobs.py@@ -46,6 +46,7 @@ async def saved(database):async def test_v2_job_keeps_admitted_plan_after_saved_metadata_rollback(database, monkeypatch):+ from models.database import WorkflowControlExecutionfrom models.employees import Employeefrom services.employees.jobs import create_jobfrom tests.services.employees.test_runtime_v2 import admitted@@ -56,15 +57,22 @@ async def test_v2_job_keeps_admitted_plan_after_saved_metadata_rollback(databaseadmitted_context["parameter_snapshot"]["send"] = {"recipient": "original"}async with database.reserved_session() as session:session.add(Employee(id="employee", workflow_id="7", owner_id="owner", hire_state="ready", team_plan={}, node_roles={}))+ # The generation was admitted with the plan; the saved metadata rolled back since.+ session.add(WorkflowControlExecution(id="workflow-control:7:4", workflow_id="7", generation=4, execution_id="origin",+ root_execution_id="origin", data_scope_id="original-scope", status="running", idempotency_key="start",+ graph_hash="admitted", graph_snapshot={"nodes": admitted_context["nodes"], "edges": [],+ "parameters": admitted_context["parameter_snapshot"]}))await session.commit()monkeypatch.setattr(database, "get_workflow", AsyncMock(return_value=SimpleNamespace(data={"nodes": [{"id": "unactivated"}], "edges": []})))- job = await create_job(database, NodeContext.from_legacy("talk", "chatAgent", admitted_context), mission="Original work",+ # A Talk run holds only its own line; the job takes the generation's whole graph.+ talk_run = {**admitted_context, "nodes": [node for node in admitted_context["nodes"] if node["id"] == "talk"]}+ job = await create_job(database, NodeContext.from_legacy("talk", "chatAgent", talk_run), mission="Original work",lead_node_id="lead", delivery_node_ids=["chat"], dispatch=True)assert job.source["team_plan"] == planassert job.source["generation"] == 4assert job.source["data_scope_id"] == "original-scope"assert job.source["parameters"]["send"]["recipient"] == "original"- assert "unactivated" not in {node["id"] for node in job.source["nodes"]}+ assert {node["id"] for node in job.source["nodes"]} == {node["id"] for node in admitted_context["nodes"]}@pytest.mark.parametrize("status", ["queued", "running", "submitted", "skipped"])async def test_unreviewed_or_skipped_tasks_never_publish(database, runtime, status):diff --git a/server/tests/services/employees/test_runtime_v2.py b/server/tests/services/employees/test_runtime_v2.pyindex f3227834..27aebe89 100644--- a/server/tests/services/employees/test_runtime_v2.py+++ b/server/tests/services/employees/test_runtime_v2.py@@ -20,13 +20,23 @@ def admitted():"inputs": {"trigger": {"recipient": "original"}}}, plan+def generation(context):+ """A database holding the generation's admitted graph and nothing saved."""+ control = SimpleNamespace(graph_snapshot={"nodes": context["nodes"], "edges": context["edges"]})+ return SimpleNamespace(get_workflow_control_generation=AsyncMock(return_value=control),+ get_session=AsyncMock(side_effect=AssertionError("must not read saved metadata")))++async def test_plan_is_from_admitted_graph_even_after_saved_rollback():context, original = admitted()- database = SimpleNamespace(get_session=AsyncMock(side_effect=AssertionError("must not read saved metadata")))- assert await employee_runtime_plan(database, context) == original+ database = generation(context)+ # A run holds only what its trigger reaches; the plan names nodes beyond it.+ run = {**context, "nodes": [node for node in context["nodes"] if node["id"] == "lead"]}+ assert await employee_runtime_plan(database, run) == original+ database.get_workflow_control_generation.assert_awaited_with("wf", 4)context["nodes"][0]["data"]["employee_team_plan"]["delivery_node_ids"].append("unactivated")with pytest.raises(ValueError, match="outside its admitted graph"):- await employee_runtime_plan(database, context)+ await employee_runtime_plan(database, run)async def test_admission_preserves_original_outputs_and_review_reuses_job(monkeypatch):@@ -53,7 +63,7 @@ async def test_intrinsic_talk_submission_ignores_model_destinations(monkeypatch)scope = {**context, "parent_node_id": "talk", "node_id": "builtin_task_manager_talk"}create = AsyncMock(return_value=SimpleNamespace(id="job", state="queued"))dispatch = AsyncMock()- monkeypatch.setattr("services.plugin.deps.get_database", lambda: object())+ monkeypatch.setattr("services.plugin.deps.get_database", lambda: generation(context))monkeypatch.setattr("services.agent_team.get_agent_team_service", lambda: object())monkeypatch.setattr("services.employees.jobs.create_job", create)monkeypatch.setattr("services.employees.jobs.dispatch_job", dispatch)diff --git a/server/tests/services/employees/test_safe_apply.py b/server/tests/services/employees/test_safe_apply.pyindex b78edf6e..f43601c1 100644--- a/server/tests/services/employees/test_safe_apply.py+++ b/server/tests/services/employees/test_safe_apply.py@@ -428,3 +428,21 @@ async def test_rollback_cannot_clear_a_claim_replaced_during_external_resume(harassert request.state == "applying" and request.claim_token == "new-process"assert (await harness.database.get_latest_workflow_control("7")).graph_snapshot == newerassert harness.manager._deployments["7"].nodes == newer["nodes"]+++async def test_apply_admits_the_employee_team_plan_on_its_lead(harness):+ """The saved graph keeps node data to UI fields; Apply copies the plan in (#148)."""+ from models.employees import Employee+ plan = {"version": 2, "lead_node_id": "7:ai_employee:1", "talk_node_id": "7:aiAgent:1"}+ lead = {"id": "7:ai_employee:1", "type": "ai_employee", "data": {"label": "Lead"}}+ saved = {**deepcopy(harness.after), "nodes": [*harness.after["nodes"], lead]}+ await harness.database.save_workflow("7", "Maya", "Maya_7", saved)+ async with harness.database.get_session() as session:+ session.add(Employee(id="employee", workflow_id="7", owner_id="owner", hire_state="ready", team_plan=plan))+ await session.commit()+ result = await safe_apply.apply_saved_changes(harness.database, "7", owner_id="owner", key="team")+ assert result == {"success": True, "activation_state": "running"}+ snapshot = (await harness.database.get_latest_workflow_control("7")).graph_snapshot+ admitted = next(node for node in snapshot["nodes"] if node["id"] == lead["id"])+ assert admitted["data"] == {"label": "Lead", "employee_recipe_version": 2, "employee_team_plan": plan}+ assert (await harness.database.get_workflow("7")).data == saveddiff --git a/server/tests/services/employees/test_team_plan_admission.py b/server/tests/services/employees/test_team_plan_admission.pynew file mode 100644index 00000000..7dade009--- /dev/null+++ b/server/tests/services/employees/test_team_plan_admission.py@@ -0,0 +1,122 @@+"""A hired team's plan reaches its runs through the admitted generation (#148).++The saved graph keeps node data to UI fields, so the plan is saved on the+employee row; Start and Apply copy it onto the lead in the generation's+snapshot. A run holds only what its trigger reaches, so the runtime reads the+plan, and a job its graph, from that whole snapshot.+"""+from __future__ import annotations++from datetime import datetime, timezone+from types import SimpleNamespace+from unittest.mock import AsyncMock++import pytest+import nodes # noqa: F401++from models.employees import Employee+from services.deployment.control import WorkflowControlService+from services.employees.apps import get_app+from services.employees.builder import BuildInputs, build_employee_graph+from services.employees.hire_request import HireEmployeeRequest+from services.employees.jobs import create_job+from services.employees.llm import LLMChoice+from services.employees.prompt import OwnerProfile+from services.employees.team_runtime import admit_team_plan, employee_runtime_plan+from services.plugin import NodeContext+from services.temporal.trigger_listener_workflow import _build_run_graph+from services.workflow_migrations import normalize_workflow_graph+from services.workflow_sanitizer import sanitize_workflow_graph+++def inbox_assistant():+ request = HireEmployeeRequest.model_validate({+ "idempotency_key": "inbox", "job": "Read new email, answer what you can and flag the rest",+ "name": "Leo", "role": "Inbox assistant", "apps": ["Gmail"],+ "steps": [{"title": "Read new email", "role": "trigger", "app": "Gmail"}], "rules": {"ask_first": True}})+ return build_employee_graph(BuildInputs(+ workflow_id="7", request=request, apps=[get_app("gmail")], connected_app_ids={"gmail"},+ owner=OwnerProfile(name="Alex", role="Owner", preferences=""), owner_values={"google_email": "[email protected]"},+ timezone="UTC", llm=LLMChoice(provider="openai", model="gpt-x", local=False), memory=True,+ now=datetime(2026, 9, 25, 12, 0, tzinfo=timezone.utc), team=True))+++async def started(real_database, monkeypatch):+ """A hire saved the way commit_hire saves it, then admitted the way Start admits it."""+ built = inbox_assistant()+ normalized = normalize_workflow_graph("7", built.nodes, built.edges, built.parameters)+ saved = sanitize_workflow_graph({**normalized.graph_data(), "owner_id": "owner"})+ async with real_database.reserved_session() as session:+ session.add(Employee(id="employee", workflow_id="7", owner_id="owner", hire_state="ready",+ team_plan=built.team_plan, node_roles=built.node_roles))+ await session.commit()+ monkeypatch.setattr(real_database, "get_workflow", AsyncMock(return_value=SimpleNamespace(data=saved, slug="Leo_1")))+ control, _ = await WorkflowControlService(real_database).begin_generation(+ workflow_id="7", nodes=await admit_team_plan(real_database, "7", saved["nodes"]), edges=saved["edges"],+ session_id="7", idempotency_key="start", graph_version=normalized.graph_version, owner_id="owner",+ parameters=normalized.node_parameters)+ return SimpleNamespace(database=real_database, saved=saved, control=control, roles=built.node_roles, plan=built.team_plan)+++def run(started, trigger, node_id):+ """The context one agent gets in a run its trigger started."""+ snapshot = started.control.graph_snapshot+ nodes, edges = _build_run_graph(trigger_node_id=trigger, trigger_output={"subject": "Hello"},+ nodes=snapshot["nodes"], edges=snapshot["edges"])+ return {"workflow_id": "7", "generation": started.control.generation, "data_scope_id": started.control.data_scope_id,+ "execution_id": f"run-{node_id}", "session_id": "7", "user_id": "owner", "node_id": node_id,+ "nodes": nodes, "edges": edges, "outputs": {trigger: {"subject": "Hello"}},+ "parameter_snapshot": snapshot["parameters"]}+++async def test_start_admits_the_plan_the_saved_graph_cannot_hold(started):+ lead = started.roles["agent"]+ assert set(next(node for node in started.saved["nodes"] if node["id"] == lead)["data"]) == {"label"}+ admitted = next(node for node in started.control.graph_snapshot["nodes"] if node["id"] == lead)["data"]+ assert admitted["employee_recipe_version"] == 2 and admitted["employee_team_plan"] == started.plan+++async def test_a_trigger_run_resolves_the_plan_and_its_job_holds_the_delivery_nodes(started):+ roles, plan = started.roles, started.plan+ context = run(started, roles["trigger"], roles["agent"])+ delivery = set(plan["delivery_node_ids"])+ assert {roles["gate"], roles["reply"]} <= delivery+ # The run itself never reaches the delivery nodes.+ assert not delivery & {node["id"] for node in context["nodes"]}+ # AgentWorkflow and the Gmail projection read the marker on the run's own lead node.+ assert next(node for node in context["nodes"] if node["id"] == roles["agent"])["data"]["employee_recipe_version"] == 2+ assert await employee_runtime_plan(started.database, context) == plan+ job = await create_job(started.database, NodeContext.from_legacy(roles["agent"], "ai_employee", context),+ mission="Answer the email", lead_node_id=roles["agent"],+ delivery_node_ids=plan["delivery_node_ids"], dispatch=False)+ assert delivery <= {node["id"] for node in job.source["nodes"]} and delivery <= set(job.source["parameters"])+ assert any(edge["source"] == roles["gate"] and edge["target"] == roles["reply"] for edge in job.source["edges"])+++async def test_a_talk_run_resolves_the_plan_and_submits_a_job_that_holds_the_lead(started):+ roles, plan = started.roles, started.plan+ context = run(started, roles["talk_trigger"], roles["talk_agent"])+ assert roles["agent"] not in {node["id"] for node in context["nodes"]}+ assert await employee_runtime_plan(started.database, context) == plan+ job = await create_job(started.database, NodeContext.from_legacy(roles["talk_agent"], "aiAgent", context),+ mission="Draft a reply to Sam", lead_node_id=plan["lead_node_id"],+ delivery_node_ids=plan["talk_delivery_node_ids"], dispatch=True)+ assert roles["agent"] in {node["id"] for node in job.source["nodes"]}+++async def test_a_run_outside_a_started_generation_has_no_plan(started):+ context = {**run(started, started.roles["trigger"], started.roles["agent"]), "generation": 0}+ assert await employee_runtime_plan(started.database, context) is None+++async def test_talk_gets_submit_job_from_the_plan_prepare_resolved():+ from services.plugin.edge_walker import collect_agent_connections+ plan = {"version": 2, "lead_node_id": "lead", "talk_node_id": "talk"}+ context = {"workflow_id": "7", "edges": [{"source": "chat", "target": "talk", "targetHandle": "input-main"}],+ "nodes": [{"id": "chat", "type": "chatTrigger", "data": {"label": "Chat"}},+ {"id": "talk", "type": "aiAgent", "data": {"label": "Talk"}}]}+ _, _, tools, _, _ = await collect_agent_connections("talk", {**context, "employee_team_plan": plan}, object())+ assert [tool["node_type"] for tool in tools] == ["taskManager"]+ _, _, tools, _, _ = await collect_agent_connections("talk", context, object())+ assert tools == []diff --git a/server/tests/services/test_pi_task_manager_dispatch.py b/server/tests/services/test_pi_task_manager_dispatch.pyindex 92deba82..7eea25e5 100644--- a/server/tests/services/test_pi_task_manager_dispatch.py+++ b/server/tests/services/test_pi_task_manager_dispatch.py@@ -49,7 +49,11 @@ async def runtime(monkeypatch):{"id": "coding", "type": "coding_agent", "data": {"employee_recipe_version": 2, "employee_team_plan": plan}},{"id": "talk", "type": "chatAgent"}, {"id": "chat", "type": "chatReply"}]+ edges = [{"source": "coding", "target": "parent", "targetHandle": "input-teammates"}]+ parameters = {node["id"]: {"model": "admitted-model"} for node in nodes}+ admitted = SimpleNamespace(graph_snapshot={"nodes": nodes, "edges": edges, "parameters": parameters})database = SimpleNamespace(+ get_workflow_control_generation=AsyncMock(return_value=admitted),get_session=session, reserved_session=session,get_node_output_by_session=get_output,get_node_parameters=AsyncMock(return_value={"model": "mutated-model", "api_key": "secret"}),@@ -88,9 +92,7 @@ async def runtime(monkeypatch):"tool_call_id": "recorded-call", "operation_id": "recorded-operation", "generation": 4,"data_scope_id": "original-data", "context_execution_id": "context-run","context_session_id": "context-session", "session_id": "session",- "run_scope": "owner_chat", "nodes": nodes,- "edges": [{"source": "coding", "target": "parent", "targetHandle": "input-teammates"}],- "parameter_snapshot": {node["id"]: {"model": "admitted-model"} for node in nodes},+ "run_scope": "owner_chat", "nodes": nodes, "edges": edges, "parameter_snapshot": parameters,"outputs": {"trigger": {"recipient": "original"}},"ai_service": object(), "database": database}monkeypatch.setattr("services.plugin.deps.get_ai_service", lambda: scope["ai_service"])diff --git a/server/tests/services/test_workflow_control_handlers.py b/server/tests/services/test_workflow_control_handlers.pyindex c3ca2fbc..e4392189 100644--- a/server/tests/services/test_workflow_control_handlers.py+++ b/server/tests/services/test_workflow_control_handlers.py@@ -1402,3 +1402,55 @@ async def test_query_still_returns_none_for_a_real_outage(monkeypatch):monkeypatch.setattr(handlers, "_controller_handle", lambda _c: handle)assert await handlers._query_controller_state(_control("running", 1)) is None+++async def test_start_admits_the_employee_team_plan_on_its_lead(monkeypatch):+ """The saved graph keeps node data to UI fields; Start copies the plan in (#148)."""+ plan = {"version": 2, "lead_node_id": "wf:ai_employee:1", "talk_node_id": "wf:aiAgent:1"}+ running = _control("running", 2)++ async def transition(_value, **kwargs):+ return _control("starting", 1) if kwargs["status"] == "starting" else running++ async def broadcast(control, **_kwargs):+ return {"state": control.status, "revision": control.revision}++ service = SimpleNamespace(+ database=SimpleNamespace(+ get_workflow_control_by_idempotency_key=AsyncMock(return_value=None),+ get_latest_workflow_control=AsyncMock(return_value=None),+ update_workflow_run_data_scope=AsyncMock(return_value=True),+ ),+ begin_generation=AsyncMock(return_value=(_control("starting", 0), True)),+ transition=AsyncMock(side_effect=transition),+ )+ monkeypatch.setattr(handlers, "_control_service", lambda: service)+ monkeypatch.setattr(handlers, "_broadcast_control", broadcast)+ monkeypatch.setattr(handlers, "_start_controller", AsyncMock(return_value="controller-run-1"))+ monkeypatch.setattr(handlers, "handle_deploy_workflow", AsyncMock(return_value={"success": True}))+ monkeypatch.setattr(handlers, "_await_deployment_setup", AsyncMock(return_value={"success": True}))+ monkeypatch.setattr(handlers, "_query_controller_state", AsyncMock(return_value={"state": "running", "revision": 0}))+ monkeypatch.setattr("services.workflow_validator.validate_workflow", AsyncMock(return_value={"errors": []}))+ monkeypatch.setattr("services.employees.store.get_by_workflow", AsyncMock(return_value=SimpleNamespace(team_plan=plan)))++ result = await handlers.handle_start_workflow(+ {+ "workflow_id": "wf",+ "nodes": [+ # A client cannot put a plan on a node; Start drops it and admits the employee's.+ {"id": "wf:ai_employee:1", "type": "ai_employee", "data": {"label": "Lead", "employee_team_plan": {"version": 2}}},+ {"id": "wf:aiAgent:1", "type": "aiAgent", "data": {"label": "Talk"}},+ ],+ "edges": [],+ "parameters_by_id": {},+ "expected_revision": 0,+ "idempotency_key": "start-employee",+ },+ None,+ )++ assert result["success"] is True+ admitted = {node["id"]: node["data"] for node in service.begin_generation.await_args.kwargs["nodes"]}+ assert admitted["wf:ai_employee:1"] == {"label": "Lead", "employee_recipe_version": 2, "employee_team_plan": plan}+ assert admitted["wf:aiAgent:1"] == {"label": "Talk"}diff --git a/server/tests/temporal/test_pi_prepared_redaction.py b/server/tests/temporal/test_pi_prepared_redaction.pyindex 0d8bdeba..03a13dd3 100644--- a/server/tests/temporal/test_pi_prepared_redaction.py+++ b/server/tests/temporal/test_pi_prepared_redaction.py@@ -80,6 +80,7 @@ def prepared(monkeypatch):database = SimpleNamespace(get_node_parameters=AsyncMock(side_effect=lambda identifier: deepcopy(snapshot.get(identifier, {}))),get_user_settings=AsyncMock(return_value=None), get_workflow=AsyncMock(return_value=SimpleNamespace(data=graph)),+ get_workflow_control_generation=AsyncMock(return_value=None),)monkeypatch.setattr("core.container.container", SimpleNamespace(database=lambda: database, auth_service=lambda: SimpleNamespace(),diff --git a/server/tests/temporal/test_prepare_payload_chat_choice.py b/server/tests/temporal/test_prepare_payload_chat_choice.pyindex 84ee30bc..b17b9ec2 100644--- a/server/tests/temporal/test_prepare_payload_chat_choice.py+++ b/server/tests/temporal/test_prepare_payload_chat_choice.py@@ -48,6 +48,7 @@ def prepare(monkeypatch):database = SimpleNamespace(get_node_parameters=AsyncMock(return_value=dict(_NODE)),get_user_settings=AsyncMock(return_value=None),+ get_workflow_control_generation=AsyncMock(return_value=None),)monkeypatch.setattr("core.container.container",diff --git a/server/tests/temporal/test_prepare_payload_context.py b/server/tests/temporal/test_prepare_payload_context.pyindex f075a336..badf61a0 100644--- a/server/tests/temporal/test_prepare_payload_context.py+++ b/server/tests/temporal/test_prepare_payload_context.py@@ -28,6 +28,7 @@ def descriptor(monkeypatch):database = SimpleNamespace(get_node_parameters=AsyncMock(return_value={"provider": "openai", "model": "test-model", "api_key": "sk-test", "prompt": "hello"}),get_user_settings=AsyncMock(return_value=None),+ get_workflow_control_generation=AsyncMock(return_value=None),)monkeypatch.setattr("core.container.container",diff --git a/server/tests/temporal/test_prepare_payload_pressure.py b/server/tests/temporal/test_prepare_payload_pressure.pyindex fd345296..ea68bbcd 100644--- a/server/tests/temporal/test_prepare_payload_pressure.py+++ b/server/tests/temporal/test_prepare_payload_pressure.py@@ -63,6 +63,7 @@ def prepare(monkeypatch):}),get_user_settings=AsyncMock(side_effect=lambda *_a, **_k: state.user_settings),+ get_workflow_control_generation=AsyncMock(return_value=None),)monkeypatch.setattr("core.container.container",