fuli-context 0.7.10-beta.0 → 0.8.0

package/graph-provider/fuli_graph/store_project_agent_attention.py

@@ -0,0 +1,138 @@
+import hashlib
+import json
+
+from fastapi import HTTPException
+
+from .personal_project_access import authorize_personal_project
+from .project_agent_access import authorize_project_agent
+from .project_agent_attention_models import (
+    AgentAttentionCreate, AgentAttentionDecision, AgentAttentionList,
+    AgentAttentionRecord,
+)
+from .provider_values import native_datetime, now_utc, stable_uuid
+from .system_hr_identity import resolve_hr_alias
+
+
+class StoreProjectAgentAttention:
+    """Explicit human requests; never infer attention from worker/task status."""
+
+    async def create_agent_attention(self, actor, request: AgentAttentionCreate):
+        self._require_personal()
+        space = await self.authorize(actor, request.personal_space_id, 'maintainer')
+        agent_id = await resolve_hr_alias(self, request.personal_space_id, request.agent_id)
+        await authorize_project_agent(
+            self, actor, space, request.personal_project_id, agent_id,
+            require_active=True,
+            allow_unassigned=agent_id in {
+                'employee.bole', 'employee.jefa', 'fuli-project-coordinator',
+            },
+        )
+        if request.task_id:
+            task = await self._find_task_row(
+                request.personal_space_id, request.task_id,
+                request.personal_project_id,
+            )
+            if not task:
+                raise HTTPException(status_code=404, detail='project Agent task not found')
+        payload = request.model_dump(exclude={'idempotency_key'})
+        fingerprint = hashlib.sha256(json.dumps(payload, sort_keys=True).encode()).hexdigest()
+        payload['agent_id'] = agent_id
+        request_id = stable_uuid(
+            self.settings.provider_id, request.personal_space_id,
+            request.personal_project_id, 'agent-attention', request.idempotency_key,
+        )
+        timestamp = now_utc()
+        rows, _, _ = await self.runtime.driver.execute_query(
+            '''
+            MATCH (space:FuliSpace {id: $personal_space_id, kind: 'personal'})
+            MERGE (request:FuliAgentAttention {id: $request_id})
+            ON CREATE SET request += $payload,
+                          request.request_id = $request_id,
+                          request.fingerprint = $fingerprint,
+                          request.status = 'open', request.revision = 0,
+                          request.created_at = $timestamp,
+                          request.updated_at = $timestamp
+            MERGE (space)-[:HAS_AGENT_ATTENTION]->(request)
+            RETURN request
+            ''',
+            personal_space_id=request.personal_space_id, request_id=request_id,
+            payload=payload, fingerprint=fingerprint, timestamp=timestamp,
+        )
+        raw = dict(rows[0]['request'])
+        if raw['fingerprint'] != fingerprint:
+            raise HTTPException(status_code=409, detail='attention idempotency key conflict')
+        return attention_record(raw)
+
+    async def list_agent_attention(
+        self, actor, personal_space_id, personal_project_id=None,
+        agent_id=None, status='open', limit=100, offset=0,
+    ):
+        self._require_personal()
+        space = await self.authorize(actor, personal_space_id, 'reader')
+        agent_id = await resolve_hr_alias(self, personal_space_id, agent_id)
+        if personal_project_id:
+            await authorize_personal_project(self, actor, space, personal_project_id)
+        rows, _, _ = await self.runtime.driver.execute_query(
+            '''
+            MATCH (:FuliSpace {id: $space_id, kind: 'personal'})-
+                  [:HAS_AGENT_ATTENTION]->(request:FuliAgentAttention)
+            WHERE ($project_id IS NULL OR request.personal_project_id = $project_id)
+              AND ($agent_id IS NULL OR request.agent_id = $agent_id)
+              AND ($status IS NULL OR request.status = $status)
+            WITH request ORDER BY request.created_at DESC, request.request_id
+            WITH collect(request) AS requests
+            RETURN requests[$offset..($offset + $limit)] AS items,
+                   size(requests) AS total,
+                   [r IN requests WHERE r.status = 'open' | r.agent_id] AS open_agents
+            ''', space_id=personal_space_id, project_id=personal_project_id,
+            agent_id=agent_id, status=status, limit=limit, offset=offset, routing_='r',
+        )
+        row = rows[0] if rows else {'items': [], 'total': 0, 'open_agents': []}
+        counts = {}
+        for agent in row['open_agents']:
+            counts[agent] = counts.get(agent, 0) + 1
+        return AgentAttentionList(
+            items=[attention_record(dict(item)) for item in row['items']],
+            total=row['total'], counts=counts,
+        )
+
+    async def decide_agent_attention(
+        self, actor, request: AgentAttentionDecision, *, human: bool,
+    ):
+        self._require_personal()
+        space = await self.authorize(actor, request.personal_space_id, 'maintainer')
+        await authorize_personal_project(self, actor, space, request.personal_project_id)
+        timestamp = now_utc()
+        # Increment obtains a write lock before the revision predicate is checked.
+        # A stale caller cannot overwrite the response recorded by another client.
+        rows, _, _ = await self.runtime.driver.execute_query(
+            '''
+            MATCH (:FuliSpace {id: $space_id, kind: 'personal'})-
+                  [:HAS_AGENT_ATTENTION]->(request:FuliAgentAttention {
+                    request_id: $request_id, personal_project_id: $project_id
+                  })
+            SET request.lock_version = coalesce(request.lock_version, 0) + 1
+            WITH request
+            WHERE request.revision = $revision AND request.status = 'open'
+            SET request.status = $status, request.response = $response,
+                request.responded_by = $responded_by,
+                request.revision = request.revision + 1,
+                request.updated_at = $timestamp
+            RETURN request
+            ''', space_id=request.personal_space_id,
+            project_id=request.personal_project_id, request_id=request.request_id,
+            revision=request.expected_revision, response=request.response,
+            status='resolved' if human else 'cancelled',
+            responded_by='human' if human else 'agent', timestamp=timestamp,
+        )
+        if not rows:
+            raise HTTPException(status_code=409, detail='attention changed or is no longer open; reload it')
+        return attention_record(dict(rows[0]['request']))
+
+
+def attention_record(raw):
+    return AgentAttentionRecord(**{
+        key: native_datetime(raw.get(key)) if key in {'created_at', 'updated_at'} else raw.get(key)
+        for key in AgentAttentionRecord.model_fields
+        if key in raw
+    })

package/graph-provider/fuli_graph/store_project_agent_coordination_policy.py

@@ -1,5 +1,7 @@
 """Project-local Agent continuity and recruitment authorization."""
 
+from fastapi import HTTPException
+
 from .personal_project_access import authorize_personal_project
 from .project_agent_coordination_models import (
     ProjectAgentCoordinationPolicyRecord,
@@ -9,7 +11,7 @@ from .provider_values import native_datetime, now_utc, stable_uuid
 
 
 class StoreProjectAgentCoordinationPolicy:
-    """Persist the two user-facing project Agent automation switches."""
+    """Persist project automation and a stable team without absorbing peer roles."""
 
     async def get_project_agent_coordination_policy(
         self,
@@ -53,6 +55,9 @@ class StoreProjectAgentCoordinationPolicy:
                 'auto_reuse_previous_agent',
                 True,
             ),
+            team_lead_agent_id=raw.get('team_lead_agent_id'),
+            auto_grow_team=raw.get('auto_grow_team', True),
+            team_member_agent_ids=raw.get('team_member_agent_ids') or [],
             updated_at=native_datetime(raw.get('updated_at')),
         )
 
@@ -77,8 +82,38 @@ class StoreProjectAgentCoordinationPolicy:
             request.personal_space_id,
             request.personal_project_id,
         )
+        current = await self.get_project_agent_coordination_policy(
+            actor, request.personal_space_id, request.personal_project_id,
+        )
+        if ('expected_updated_at' in request.model_fields_set
+                and request.expected_updated_at != current.updated_at):
+            raise HTTPException(status_code=409, detail='coordination policy changed; reload before saving')
+        lead = (request.team_lead_agent_id if 'team_lead_agent_id' in request.model_fields_set
+                else current.team_lead_agent_id)
+        members = (request.team_member_agent_ids if 'team_member_agent_ids' in request.model_fields_set
+                   else current.team_member_agent_ids)
+        auto_grow = current.auto_grow_team if request.auto_grow_team is None else request.auto_grow_team
+        if members and not lead:
+            raise HTTPException(status_code=422, detail='select a team lead before adding members')
+        if lead in members:
+            raise HTTPException(status_code=422, detail='the team lead cannot also be a team member')
+        if 'team_lead_agent_id' in request.model_fields_set or 'team_member_agent_ids' in request.model_fields_set:
+            for agent_id in ([lead] if lead else []) + members:
+                agent = await self.get_project_agent(
+                    actor, request.personal_space_id, request.personal_project_id, agent_id,
+                )
+                profile = agent.profile
+                active_assignment = any(
+                    assignment.status == 'active'
+                    and assignment.personal_project_id == request.personal_project_id
+                    for assignment in agent.assignments
+                )
+                if (profile.status != 'active' or not active_assignment
+                        or profile.agent_type != 'durable'
+                        or any(cap.startswith('fuli.employee:') for cap in profile.capabilities)):
+                    raise HTTPException(status_code=422, detail='team roles require active durable project assignments; HR and project managers remain peers')
         updated_at = now_utc()
-        await self.runtime.driver.execute_query(
+        written, _, _ = await self.runtime.driver.execute_query(
             '''
             MATCH (:FuliSpace {id: $personal_space_id, kind: 'personal'})-
                   [:CONTAINS_PROJECT]->
@@ -89,23 +124,42 @@ class StoreProjectAgentCoordinationPolicy:
             ON CREATE SET policy.personal_space_id = $personal_space_id,
                           policy.personal_project_id = $personal_project_id,
                           policy.created_at = $updated_at
+            SET policy._fuli_write_lock = true
+            REMOVE policy._fuli_write_lock
+            WITH project, policy
+            WHERE ($expected_updated_at IS NULL AND policy.updated_at IS NULL)
+               OR (policy.updated_at.epochSeconds = $expected_updated_at.epochSeconds
+                   AND policy.updated_at.nanosecond = $expected_updated_at.nanosecond)
             SET policy.ask_before_recruitment = $ask_before_recruitment,
                 policy.auto_reuse_previous_agent = $auto_reuse_previous_agent,
+                policy.auto_grow_team = $auto_grow_team,
+                policy.team_lead_agent_id = $team_lead_agent_id,
+                policy.team_member_agent_ids = $team_member_agent_ids,
                 policy.updated_at = $updated_at
             MERGE (project)-[:HAS_PROJECT_AGENT_COORDINATION_POLICY]->(policy)
+            RETURN policy
             ''',
             policy_id=policy_id,
             personal_space_id=request.personal_space_id,
             personal_project_id=request.personal_project_id,
             ask_before_recruitment=request.ask_before_recruitment,
             auto_reuse_previous_agent=request.auto_reuse_previous_agent,
+            auto_grow_team=auto_grow,
+            team_lead_agent_id=lead,
+            team_member_agent_ids=members,
+            expected_updated_at=current.updated_at,
             updated_at=updated_at,
         )
+        if not written:
+            raise HTTPException(status_code=409, detail='coordination policy changed; reload before saving')
         return ProjectAgentCoordinationPolicyRecord(
             personal_space_id=request.personal_space_id,
             personal_project_id=request.personal_project_id,
             ask_before_recruitment=request.ask_before_recruitment,
             auto_reuse_previous_agent=request.auto_reuse_previous_agent,
+            auto_grow_team=auto_grow,
+            team_lead_agent_id=lead,
+            team_member_agent_ids=members,
             updated_at=updated_at,
         )
 

package/graph-provider/fuli_graph/store_project_agent_executor_learning.py

@@ -22,6 +22,7 @@ from .project_agent_executor_models import (
 from .project_agent_models import ProjectAgentModelStrategy
 from .provider_values import native_datetime, now_utc, stable_uuid
 from .store_transactions import query_store_transaction
+from .system_hr_identity import resolve_hr_alias
 
 
 _TERMINAL_NEUTRAL = {'cancelled'}
@@ -276,6 +277,7 @@ class StoreProjectAgentExecutorLearning:
     ) -> list[ProjectAgentExecutorOutcomeEvidenceRecord]:
         self._require_personal()
         space = await self.authorize(actor, personal_space_id, 'reader')
+        agent_id = await resolve_hr_alias(self, personal_space_id, agent_id)
         await authorize_personal_project(
             self,
             actor,
@@ -334,6 +336,7 @@ class StoreProjectAgentExecutorLearning:
 
         self._require_personal()
         space = await self.authorize(actor, personal_space_id, 'reader')
+        agent_id = await resolve_hr_alias(self, personal_space_id, agent_id)
         if personal_project_id is not None:
             await authorize_personal_project(
                 self,
@@ -367,12 +370,17 @@ class StoreProjectAgentExecutorLearning:
         aggregates: list[ProjectAgentExecutorOutcomeAggregate] = []
         for row in records:
             raw = dict(row.get('aggregate') or {})
+            identity = raw.get('agent_id')
             aggregate_json = raw.get('aggregate_json')
             if aggregate_json:
                 try:
                     raw.update(json.loads(aggregate_json))
                 except (TypeError, ValueError):
                     pass
+            if raw.get('hr_identity_original_refs_json'):
+                raw['agent_id'] = identity
+            raw.pop('hr_identity_original_refs_json', None)
+            raw.pop('hr_identity_original_id', None)
             # Storage identities are intentionally internal: the public model
             # remains the provider-neutral bucket contract.
             raw.pop('id', None)

package/graph-provider/fuli_graph/store_project_agent_memory.py

@@ -16,6 +16,8 @@ from .project_agent_memory_models import (
     ProjectAgentMemoryWrite,
 )
 from .provider_values import now_utc, stable_uuid
+from .project_agent_work_log import read_employee_work_log
+from .system_hr_identity import LEGACY_HR_AGENT_ID, SYSTEM_HR_AGENT_ID, resolve_hr_alias
 
 
 class StoreProjectAgentMemory:
@@ -24,7 +26,7 @@ class StoreProjectAgentMemory:
     ) -> ProjectAgentMemoryView:
         self._require_personal()
         space = await self.authorize(actor, personal_space_id, 'reader')
-        await authorize_project_agent(
+        agent = await authorize_project_agent(
             self, actor, space, personal_project_id, agent_id, require_memory=True,
         )
         records, _, _ = await self.runtime.driver.execute_query(
@@ -34,24 +36,26 @@ class StoreProjectAgentMemory:
             RETURN checkpoint.record_json AS record_json
             ORDER BY checkpoint.revision DESC LIMIT $limit
             ''',
-            memory_id=self._agent_memory_id(
-                personal_space_id, personal_project_id, agent_id,
-            ),
+            memory_id=await self._resolved_agent_memory_id(
+                personal_space_id, personal_project_id, agent['agent_id']),
             limit=max(1, min(limit, 10)),
             routing_='r',
         )
         history = [
-            ProjectAgentMemoryRecord.model_validate_json(row['record_json'])
+            ProjectAgentMemoryRecord.model_validate_json(row['record_json']).model_copy(
+                update={'agent_id': agent['agent_id']})
             for row in records
         ]
         current = history[0] if history else None
         return ProjectAgentMemoryView(
             personal_space_id=personal_space_id,
             personal_project_id=personal_project_id,
-            agent_id=agent_id,
+            agent_id=agent['agent_id'],
             revision=current.revision if current else 0,
             current=current,
             history=history,
+            work_log=await read_employee_work_log(self, personal_space_id,
+                                                  personal_project_id, agent['agent_id']),
         )
 
     async def write_project_agent_memory(
@@ -78,14 +82,14 @@ class StoreProjectAgentMemory:
                 ''',
                 space_id=request.personal_space_id,
                 project_id=request.personal_project_id,
-                agent_id=request.agent_id,
+                agent_id=agent['agent_id'],
                 task_id=request.task_id,
                 routing_='r',
             )
             if not task_rows:
                 raise HTTPException(status_code=404, detail='Agent memory task not found')
-        memory_id = self._agent_memory_id(
-            request.personal_space_id, request.personal_project_id, request.agent_id,
+        memory_id = await self._resolved_agent_memory_id(
+            request.personal_space_id, request.personal_project_id, agent['agent_id'],
         )
         checkpoint_id = stable_uuid(memory_id, request.idempotency_key)
         payload = request.model_dump(mode='json', exclude={
@@ -98,7 +102,7 @@ class StoreProjectAgentMemory:
             checkpoint_id=checkpoint_id,
             personal_space_id=request.personal_space_id,
             personal_project_id=request.personal_project_id,
-            agent_id=request.agent_id,
+            agent_id=agent['agent_id'],
             revision=request.expected_revision + 1,
             memory=request.memory,
             source_application=request.source_application,
@@ -147,7 +151,7 @@ class StoreProjectAgentMemory:
             ''',
             space_id=request.personal_space_id,
             project_id=request.personal_project_id,
-            agent_id=request.agent_id,
+            agent_id=agent['agent_id'],
             memory_id=memory_id,
             checkpoint_id=checkpoint_id,
             expected_revision=request.expected_revision,
@@ -164,9 +168,35 @@ class StoreProjectAgentMemory:
                 status_code=409,
                 detail='Agent memory changed; reload its latest revision before merging notes',
             )
-        if row['payload_hash'] != payload_hash:
+        compatible_hashes = {payload_hash}
+        if LEGACY_HR_AGENT_ID in agent.get('legacy_agent_ids', []):
+            # Old checkpoints keep their exact IDs/JSON/hashes. A canonical
+            # retry of the same input may differ only in the identity spelling.
+            for identity in (LEGACY_HR_AGENT_ID, SYSTEM_HR_AGENT_ID):
+                compatible_hashes.add(hashlib.sha256(json.dumps(
+                    {**payload, 'agent_id': identity}, sort_keys=True,
+                    ensure_ascii=False, separators=(',', ':'),
+                ).encode()).hexdigest())
+        if row['payload_hash'] not in compatible_hashes:
             raise HTTPException(status_code=409, detail='memory idempotency key has different input')
-        return ProjectAgentMemoryRecord.model_validate_json(row['record_json'])
+        return ProjectAgentMemoryRecord.model_validate_json(row['record_json']).model_copy(
+            update={'agent_id': agent['agent_id']})
+
+    async def _resolved_agent_memory_id(self, space_id, project_id, agent_id):
+        agent_id = await resolve_hr_alias(self, space_id, agent_id)
+        if agent_id == SYSTEM_HR_AGENT_ID:
+            rows, _, _ = await self.runtime.driver.execute_query(
+                '''MATCH (:FuliSpace {id: $space_id})-[:HAS_PROJECT_AGENT_IDENTITY]->
+                         (:FuliProjectAgent {agent_id: $agent_id})-[:HAS_WORKING_MEMORY]->
+                         (head:FuliProjectAgentMemory {personal_space_id: $space_id,
+                           personal_project_id: $project_id})
+                   RETURN DISTINCT head.id AS id''',
+                space_id=space_id, project_id=project_id, agent_id=agent_id, routing_='r')
+            if len(rows) > 1:
+                raise HTTPException(409, 'Agent has conflicting memory heads')
+            if rows:
+                return rows[0]['id']
+        return self._agent_memory_id(space_id, project_id, agent_id)
 
     def _agent_memory_id(self, space_id, project_id, agent_id):
         return stable_uuid(

package/graph-provider/fuli_graph/store_project_agent_task_activity.py

@@ -266,7 +266,7 @@ class StoreProjectAgentTaskActivity:
               THEN [1] ELSE [] END |
               SET task.status = $status,
                   task.result_summary = CASE
-                    WHEN $status = 'completed' THEN $summary
+                    WHEN $status IN ['completed', 'awaiting_review', 'failed', 'blocked', 'cancelled'] THEN $summary
                     ELSE task.result_summary END,
                   task.failure_reason = CASE
                     WHEN $status = 'failed' THEN $summary

package/graph-provider/fuli_graph/store_project_agent_task_recruitment.py

@@ -24,7 +24,9 @@ from .project_agent_task_models import (
     ProjectAgentRoutingDecisionRecord,
 )
 from .provider_values import native_datetime, now_utc, stable_uuid
+from .store_project_agents import SYSTEM_HR_AGENT_ID
 from .store_transactions import query_store_transaction
+from .project_agent_team_growth import enroll_recruited_team_member
 
 
 RECRUITMENT_CLAIM_TTL = timedelta(minutes=2)
@@ -744,9 +746,11 @@ class StoreProjectAgentTaskRecruitment:
             MATCH (:FuliSpace {id: $personal_space_id, kind: 'personal'})-
                   [:HAS_PROJECT_AGENT_IDENTITY]->
                   (hr:FuliProjectAgent {agent_type: 'hr', status: 'active'})
-            RETURN hr ORDER BY hr.created_at, hr.agent_id LIMIT 1
+            RETURN hr ORDER BY CASE WHEN hr.agent_id = $system_hr_agent_id
+              THEN 0 ELSE 1 END, hr.created_at, hr.agent_id LIMIT 1
             ''',
             personal_space_id=request.personal_space_id,
+            system_hr_agent_id=SYSTEM_HR_AGENT_ID,
             routing_='r',
         )
         hr_agent_id = (
@@ -1233,6 +1237,7 @@ class StoreProjectAgentTaskRecruitment:
             include_temporary=True,
         )
         selected = next(item for item in assignment_rows if item['agent_id'] == agent_id)
+        await enroll_recruited_team_member(self, raw, profile)
         return selected
 
     async def _get_recruitment(self, personal_space_id, recruitment_id):

package/graph-provider/fuli_graph/store_project_agent_task_staffing.py

@@ -7,6 +7,7 @@ from fastapi import HTTPException
 from .project_agent_access import authorize_project_agent
 from .project_agent_models import ProjectAgentProfile
 from .project_agent_task_models import ProjectAgentParallelPlan
+from .store_project_agents import SYSTEM_HR_AGENT_ID
 
 
 class StoreProjectAgentTaskStaffing:
@@ -61,6 +62,18 @@ class StoreProjectAgentTaskStaffing:
             return [], rows, 'manual_agent_selection', [
                 'project policy requires an explicit @Agent selection',
             ]
+        team_lead = getattr(policy, 'team_lead_agent_id', None)
+        if team_lead:
+            lead = next((row for row in rows if row['agent_id'] == team_lead), None)
+            if lead is None:
+                return [], rows, 'agent_unavailable', ['configured team lead is unavailable; select or replace the lead']
+            member_ids = set(getattr(policy, 'team_member_agent_ids', []))
+            members = [row for row in rows if row['agent_id'] in member_ids]
+            return [lead], [lead, *members], 'project_team_lead', [
+                'project team lead is the stable conversation owner',
+                f'{len(members)} active team member(s) available for explicit workstreams',
+                'HR and project manager remain peer roles',
+            ]
         normalized_work_kind = request.work_kind.casefold()
         required = {item.casefold() for item in request.required_capabilities}
         eligible = [row for row in rows if required.issubset({
@@ -505,16 +518,19 @@ class StoreProjectAgentTaskStaffing:
         request,
         candidates,
         participants,
+        *,
+        team_only=False,
     ):
         capacity = len(request.parallel_plan.workstream_boundaries) - len(participants)
         if capacity <= 0:
             return []
         pool = list(candidates)
         known_ids = {item['agent_id'] for item in pool}
-        for row in await self._assignment_candidates(
+        assignments = [] if team_only else await self._assignment_candidates(
             request.personal_space_id,
             request.personal_project_id,
-        ):
+        )
+        for row in assignments:
             if row['agent_id'] not in known_ids:
                 pool.append(row)
                 known_ids.add(row['agent_id'])
@@ -634,9 +650,11 @@ class StoreProjectAgentTaskStaffing:
             MATCH (space:FuliSpace {id: $personal_space_id, kind: 'personal'})-
                   [:HAS_PROJECT_AGENT_IDENTITY]->
                   (hr:FuliProjectAgent {agent_type: 'hr', status: 'active'})
-            RETURN hr LIMIT 1
+            RETURN hr ORDER BY CASE WHEN hr.agent_id = $system_hr_agent_id
+              THEN 0 ELSE 1 END, hr.created_at, hr.agent_id LIMIT 1
             ''',
             personal_space_id=request.personal_space_id,
+            system_hr_agent_id=SYSTEM_HR_AGENT_ID,
             routing_='r',
         )
         if not hr_records:

package/graph-provider/fuli_graph/store_project_agent_tasks.py

@@ -2,6 +2,7 @@ import json
 from collections import defaultdict
 from datetime import date
 from fastapi import HTTPException
+from .system_hr_identity import resolve_hr_alias
 from .personal_project_access import authorize_personal_project
 from .project_agent_access import authorize_project_agent
 from .project_agent_models import ProjectAgentModelStrategy, ProjectAgentProfile
@@ -146,6 +147,7 @@ class StoreProjectAgentTasks(
                 request,
                 candidates,
                 participants,
+                **({'team_only': True} if reason == 'project_team_lead' else {}),
             )
             candidate_ids = {item['agent_id'] for item in candidates}
             candidates.extend(
@@ -470,6 +472,7 @@ class StoreProjectAgentTasks(
     ) -> list[ProjectAgentTaskRecord]:
         self._require_personal()
         space = await self.authorize(actor, personal_space_id, 'reader')
+        agent_id = await resolve_hr_alias(self, personal_space_id, agent_id)
         if personal_project_id:
             await authorize_personal_project(
                 self,
@@ -510,6 +513,7 @@ class StoreProjectAgentTasks(
     ) -> ProjectAgentActivityResult:
         self._require_personal()
         space = await self.authorize(actor, personal_space_id, 'reader')
+        agent_id = await resolve_hr_alias(self, personal_space_id, agent_id)
         if personal_project_id:
             await authorize_personal_project(
                 self,