fuli-context 0.11.0 → 0.12.0

package/graph-provider/fuli_graph/knowledge_review_models.py

@@ -1,7 +1,7 @@
 from datetime import datetime
 from typing import Literal
 
-from pydantic import Field, model_validator
+from pydantic import Field, field_validator, model_validator
 
 from .models import (
     ConfirmationStatus,
@@ -11,6 +11,7 @@ from .models import (
     PersonalProfileAspect,
     PreferenceScope,
     StrictModel,
+    SourceApplication,
 )
 
 KnowledgeReviewScope = Literal[
@@ -23,7 +24,7 @@ KnowledgeReviewScope = Literal[
 KnowledgeReviewStatus = Literal['active', 'paused', 'completed']
 KnowledgeReviewDisposition = Literal['paused', 'completed']
 KnowledgeReviewOutcome = Literal[
-    'confirmed', 'updated', 'invalidated', 'deferred', 'delegated_to_ai'
+    'confirmed', 'updated', 'invalidated', 'deferred', 'delegated_to_ai', 'ai_reviewed'
 ]
 KnowledgeReviewReason = Literal[
     'changed_since_last',
@@ -37,6 +38,7 @@ KnowledgeReviewReason = Literal[
 class KnowledgeReviewStart(StrictModel):
     personal_space_id: str = Field(min_length=1, max_length=128)
     scope: KnowledgeReviewScope
+    reviewer: Literal['human', 'tonborg'] = 'human'
     personal_project_id: str | None = Field(default=None, min_length=1, max_length=128)
 
     @model_validator(mode='after')
@@ -55,6 +57,7 @@ class KnowledgeReviewRun(StrictModel):
     scope: KnowledgeReviewScope
     personal_project_id: str | None = None
     scope_key: str
+    reviewer: Literal['human', 'tonborg'] = 'human'
     status: KnowledgeReviewStatus
     previous_completed_at: datetime | None = None
     review_cutoff_at: datetime
@@ -64,6 +67,25 @@ class KnowledgeReviewRun(StrictModel):
     resumed: bool = False
 
 
+class KnowledgeReviewAIAssessment(StrictModel):
+    """The bounded, version-bound result returned by the Tonborg reviewer."""
+
+    outcome: Literal['approve', 'escalate']
+    summary: str = Field(min_length=1, max_length=2000)
+    evidence: list[str] = Field(min_length=1, max_length=8)
+    confidence: float = Field(ge=0, le=1)
+    client: SourceApplication | None = None
+    model: str | None = Field(default=None, min_length=1, max_length=256)
+    session_id: str | None = Field(default=None, min_length=1, max_length=256)
+
+    @field_validator('evidence')
+    @classmethod
+    def validate_evidence(cls, value: list[str]) -> list[str]:
+        if any(not item or len(item) > 1000 for item in value):
+            raise ValueError('AI evidence entries must contain 1 to 1000 characters')
+        return value
+
+
 class KnowledgeReviewCandidate(StrictModel):
     candidate_key: str
     item_id: str
@@ -90,12 +112,18 @@ class KnowledgeReviewCandidate(StrictModel):
     last_feedback_kind: KnowledgeFeedbackKind | None = None
     distinct_session_count: int = Field(ge=0)
     changed_at: datetime | None = None
+    ai_review_evidence_token: str = Field(
+        min_length=64,
+        max_length=64,
+        pattern=r'^[0-9a-f]{64}$',
+    )
 
 
 class KnowledgeReviewCandidateRequest(StrictModel):
     personal_space_id: str = Field(min_length=1, max_length=128)
     review_id: str = Field(min_length=1, max_length=256)
     limit: int = Field(default=10, ge=1, le=50)
+    offset: int = Field(default=0, ge=0, le=1000000)
 
 
 class KnowledgeReviewCandidatePage(StrictModel):
@@ -115,6 +143,28 @@ class KnowledgeReviewProgress(StrictModel):
     )
     outcome: KnowledgeReviewOutcome
     note: str | None = Field(default=None, min_length=1, max_length=2000)
+    ai_review_evidence_token: str | None = Field(
+        default=None,
+        min_length=64,
+        max_length=64,
+        pattern=r'^[0-9a-f]{64}$',
+    )
+    ai_assessment: KnowledgeReviewAIAssessment | None = None
+
+    @model_validator(mode='after')
+    def validate_ai_review_fields(self):
+        has_token = self.ai_review_evidence_token is not None
+        has_assessment = self.ai_assessment is not None
+        if self.outcome == 'ai_reviewed':
+            if not has_token or not has_assessment:
+                raise ValueError(
+                    'ai_reviewed requires an evidence token and assessment'
+                )
+        elif has_token or has_assessment:
+            raise ValueError(
+                'AI assessment fields are only valid for ai_reviewed outcomes'
+            )
+        return self
 
 
 class KnowledgeReviewDecision(StrictModel):
@@ -125,6 +175,15 @@ class KnowledgeReviewDecision(StrictModel):
     note: str | None = None
     created_at: datetime
     updated_at: datetime
+    ai_review_evidence_token: str | None = Field(
+        default=None,
+        min_length=64,
+        max_length=64,
+        pattern=r'^[0-9a-f]{64}$',
+    )
+    ai_assessment: KnowledgeReviewAIAssessment | None = None
+    ai_review_scope: KnowledgeReviewScope | None = None
+    ai_review_project_id: str | None = Field(default=None, min_length=1, max_length=128)
 
 
 class KnowledgeReviewFinish(StrictModel):

package/graph-provider/fuli_graph/personal_global_preferences.py

@@ -1116,7 +1116,9 @@ OPTIONAL MATCH (old_assertion:Entity {
 })
 SET preview.used_at = $changed_at
 FOREACH (_ IN CASE WHEN old_assertion IS NULL THEN [] ELSE [1] END |
-  SET old_assertion.fuli_invalid_at = $changed_at,
+  SET old_assertion.fuli_ai_review_lock_version =
+        coalesce(old_assertion.fuli_ai_review_lock_version, 0) + 1,
+      old_assertion.fuli_invalid_at = $changed_at,
       old_assertion.expired_at = $changed_at
 )
 SET current.candidate_version = $candidate_version,
@@ -1176,6 +1178,8 @@ FOREACH (_ IN CASE WHEN $global_assertion_id IS NULL THEN [] ELSE [1] END |
                 assertion.fuli_distinct_task_count = 0,
                 assertion.fuli_usage_generation = 1,
                 assertion.fuli_invalid_at = null
+  SET assertion.fuli_ai_review_lock_version =
+        coalesce(assertion.fuli_ai_review_lock_version, 0) + 1
   MERGE (episode:Episodic {uuid: $episode_id})
   ON CREATE SET episode.group_id = $group_id,
                 episode.name = 'Personal-global preference human review',

package/graph-provider/fuli_graph/preference_conflicts.py

@@ -19,6 +19,18 @@ from .models import (
 from .provider_values import native_datetime as _native_datetime
 
 
+def _item_match(item_kind: str, variable: str, id_parameter: str) -> str:
+    if item_kind == 'entity':
+        return (
+            f'MATCH ({variable}:Entity '
+            f'{{uuid: ${id_parameter}, group_id: $group_id}})'
+        )
+    return (
+        f'MATCH ()-[{variable}:RELATES_TO '
+        f'{{uuid: ${id_parameter}, group_id: $group_id}}]->()'
+    )
+
+
 async def defer_preference_conflict(
     store,
     actor: dict,
@@ -44,9 +56,42 @@ async def defer_preference_conflict(
     )
     _validate_pair_scope(left, right, request)
     deferred_at = datetime.now(timezone.utc)
+    left_match = _item_match(
+        request.left_item_kind, 'left', 'left_item_id'
+    )
+    right_match = _item_match(
+        request.right_item_kind, 'right', 'right_item_id'
+    )
     records, _, _ = await store.runtime.driver.execute_query(
         '''
         MATCH (space:FuliSpace {id: $space_id, kind: 'personal'})
+        '''
+        + left_match
+        + '\n        '
+        + right_match
+        + '''
+        WITH space,
+             CASE
+               WHEN $left_item_kind + ':' + left.uuid =
+                    $right_item_kind + ':' + right.uuid
+                 THEN [{kind: $left_item_kind, item: left}]
+               WHEN $left_item_kind + ':' + left.uuid <
+                    $right_item_kind + ':' + right.uuid
+                 THEN [
+                   {kind: $left_item_kind, item: left},
+                   {kind: $right_item_kind, item: right}
+                 ]
+               ELSE [
+                 {kind: $right_item_kind, item: right},
+                 {kind: $left_item_kind, item: left}
+               ]
+             END AS lock_items
+        UNWIND lock_items AS lock_item
+        WITH space, lock_item
+        ORDER BY lock_item.kind + ':' + lock_item.item.uuid
+        SET lock_item.item.fuli_ai_review_lock_version =
+              coalesce(lock_item.item.fuli_ai_review_lock_version, 0) + 1
+        WITH space, collect(lock_item) AS _locked_items
         MERGE (conflict:FuliPreferenceConflict {id: $conflict_id})
         ON CREATE SET conflict.personal_space_id = $space_id,
                       conflict.preference_key = $preference_key,
@@ -70,6 +115,7 @@ async def defer_preference_conflict(
         RETURN conflict
         ''',
         space_id=space['id'],
+        group_id=space['group_id'],
         conflict_id=request.conflict_id,
         preference_key=request.preference_key,
         preference_scope=request.preference_scope,
@@ -160,10 +206,12 @@ async def resolve_preference_conflict(
     return await _complete(
         store,
         space['id'],
+        space['group_id'],
         conflict_id,
         request.resolution,
         request.reason,
         request.operation_actor,
+        conflict,
     )
 
 
@@ -179,14 +227,16 @@ async def complete_preference_conflict(
         request.personal_space_id,
         'maintainer',
     )
-    await _read_conflict(store, space['id'], conflict_id)
+    conflict = await _read_conflict(store, space['id'], conflict_id)
     return await _complete(
         store,
         space['id'],
+        space['group_id'],
         conflict_id,
         request.resolution,
         request.reason,
         request.operation_actor,
+        conflict,
     )
 
 
@@ -305,17 +355,52 @@ async def _split_scope(store, actor, space, conflict, left, right, request):
 async def _complete(
     store,
     space_id,
+    group_id,
     conflict_id,
     resolution,
     reason,
     resolved_by,
+    conflict: PreferenceConflictRecord,
 ):
     resolved_at = datetime.now(timezone.utc)
+    left_match = _item_match(
+        conflict.left_item_kind, 'left', 'left_item_id'
+    )
+    right_match = _item_match(
+        conflict.right_item_kind, 'right', 'right_item_id'
+    )
     records, _, _ = await store.runtime.driver.execute_query(
         '''
         MATCH (:FuliSpace {id: $space_id, kind: 'personal'})-
               [:HAS_PREFERENCE_CONFLICT]->
               (conflict:FuliPreferenceConflict {id: $conflict_id})
+        '''
+        + left_match
+        + '\n        '
+        + right_match
+        + '''
+        WITH conflict,
+             CASE
+               WHEN $left_item_kind + ':' + left.uuid =
+                    $right_item_kind + ':' + right.uuid
+                 THEN [{kind: $left_item_kind, item: left}]
+               WHEN $left_item_kind + ':' + left.uuid <
+                    $right_item_kind + ':' + right.uuid
+                 THEN [
+                   {kind: $left_item_kind, item: left},
+                   {kind: $right_item_kind, item: right}
+                 ]
+               ELSE [
+                 {kind: $right_item_kind, item: right},
+                 {kind: $left_item_kind, item: left}
+               ]
+             END AS lock_items
+        UNWIND lock_items AS lock_item
+        WITH conflict, lock_item
+        ORDER BY lock_item.kind + ':' + lock_item.item.uuid
+        SET lock_item.item.fuli_ai_review_lock_version =
+              coalesce(lock_item.item.fuli_ai_review_lock_version, 0) + 1
+        WITH conflict, collect(lock_item) AS _locked_items
         SET conflict.status = 'resolved',
             conflict.resolution = $resolution,
             conflict.resolved_by = $resolved_by,
@@ -325,7 +410,12 @@ async def _complete(
         RETURN conflict
         ''',
         space_id=space_id,
+        group_id=group_id,
         conflict_id=conflict_id,
+        left_item_id=conflict.left_item_id,
+        left_item_kind=conflict.left_item_kind,
+        right_item_id=conflict.right_item_id,
+        right_item_kind=conflict.right_item_kind,
         resolution=resolution,
         resolved_by=resolved_by,
         reason=reason,

package/graph-provider/fuli_graph/project_agent_context_models.py

@@ -1,4 +1,4 @@
-"""Read-only task-entry selection; never submits a task or spawns a worker."""
+"""Task-entry selection and optional invocation claim; never spawns a worker."""
 
 from typing import Literal
 
@@ -13,6 +13,8 @@ class ProjectAgentContextRequest(StrictModel):
     personal_space_id: str = Field(min_length=1, max_length=128)
     personal_project_id: str = Field(min_length=1, max_length=128)
     agent_id: str | None = Field(default=None, min_length=1, max_length=128)
+    delegation_token: str | None = Field(default=None, min_length=32, max_length=128)
+    delegation_session_id: str | None = Field(default=None, min_length=1, max_length=256)
     session_id: str | None = Field(default=None, min_length=1, max_length=256)
     turn_id: str | None = Field(default=None, min_length=1, max_length=256)
     work_kind: str = Field(default='project_context', min_length=1, max_length=128)
@@ -26,4 +28,6 @@ class ProjectAgentContextResolution(StrictModel):
     match_basis: list[str] = Field(default_factory=list)
     candidate_count: int = 0
     agent: ProjectAgentRecord | None = None
+    requested_agent_id: str | None = None
+    reporting_lead_agent_id: str | None = None
     worker_started: Literal[False] = False

package/graph-provider/fuli_graph/project_agent_delegations.py

@@ -0,0 +1,118 @@
+"""Short-lived, session-bound capabilities for a real roundtable invocation."""
+
+from hashlib import sha256
+from secrets import token_urlsafe
+
+from fastapi import HTTPException
+from pydantic import Field
+
+from .models import SourceApplication, StrictModel
+from .personal_project_access import authorize_personal_project
+
+
+class AgentDelegationIssue(StrictModel):
+    personal_space_id: str = Field(min_length=1, max_length=128)
+    task_context_token: str = Field(min_length=1, max_length=256)
+    source_application: SourceApplication
+    agent_id: str = Field(min_length=1, max_length=128)
+    target_application: SourceApplication
+    target_session_id: str | None = Field(default=None, min_length=1, max_length=256)
+    lifetime_seconds: int = Field(default=300, ge=30, le=900)
+
+
+class AgentDelegationCheck(StrictModel):
+    personal_space_id: str = Field(min_length=1, max_length=128)
+    token: str = Field(min_length=32, max_length=128)
+    session_id: str | None = Field(default=None, min_length=1, max_length=256)
+
+
+def token_hash(token):
+    return sha256(token.encode()).hexdigest()
+
+
+class StoreAgentDelegations:
+    async def issue_agent_delegation(self, actor, request):
+        self._require_personal()
+        space = await self.authorize(actor, request.personal_space_id, 'maintainer')
+        context = await self.get_task_context(actor, request.personal_space_id,
+                                             request.task_context_token, request.source_application)
+        project_id = context.get('personal_project_id')
+        if not project_id or (context.get('checkpoint') or {}).get('phase') == 'complete':
+            raise HTTPException(409, 'Delegation requires an active project task')
+        await authorize_personal_project(self, actor, space, project_id)
+        policy = await self.get_project_agent_coordination_policy(actor, request.personal_space_id, project_id)
+        lead = policy.team_lead_agent_id
+        sender = context.get('project_agent_id')
+        if not lead or not sender or (sender != lead and request.agent_id != lead):
+            raise HTTPException(403, 'Members must communicate through the project lead')
+        target = await self.get_project_agent(actor, request.personal_space_id, project_id, request.agent_id)
+        if (target.profile.status != 'active'
+                or request.target_application not in target.profile.allowed_clients):
+            raise HTTPException(403, 'The receiving Agent is unavailable in this client')
+        token = token_urlsafe(32)
+        # Only hashes are stored. A crash leaves a bounded lifetime, never a
+        # reusable authority derived from a public message or thread identifier.
+        await self.runtime.driver.execute_query(
+            '''MATCH (old:FuliAgentDelegation {space_id: $space_id})
+               WHERE old.expires_at <= datetime() DELETE old''', space_id=request.personal_space_id)
+        await self.runtime.driver.execute_query(
+            '''CREATE (:FuliAgentDelegation {token_hash: $token_hash, space_id: $space_id,
+                 project_id: $project_id, agent_id: $agent_id, source_application: $application,
+                 session_id: $session_id, sender_token: $sender_token, lead_agent_id: $lead,
+                 expires_at: datetime() + duration({seconds: $lifetime}), redeemed: false})''',
+            token_hash=token_hash(token), space_id=request.personal_space_id, project_id=project_id,
+            agent_id=request.agent_id, application=request.target_application,
+            session_id=request.target_session_id, sender_token=request.task_context_token,
+            lead=lead, lifetime=request.lifetime_seconds)
+        return {'token': token}
+
+    async def redeem_agent_delegation(self, request, lead):
+        if not request.delegation_token or not request.delegation_session_id or not request.agent_id:
+            return False
+        # Lock before reading the session binding: two different sessions cannot
+        # both claim a fresh capability. Same-session hook/MCP retries are safe.
+        rows, _, _ = await self.runtime.driver.execute_query(
+            '''MATCH (:FuliSpace {id: $space_id})-[:CONTAINS_PROJECT]->
+                  (:FuliPersonalProject {project_id: $project_id})-
+                  [:HAS_PROJECT_AGENT_COORDINATION_POLICY]->(policy:FuliProjectAgentCoordinationPolicy)
+               SET policy._fuli_write_lock = true
+               REMOVE policy._fuli_write_lock
+               WITH policy WHERE policy.team_lead_agent_id = $lead
+               MATCH (grant:FuliAgentDelegation {token_hash: $token_hash, space_id: $space_id,
+                  project_id: $project_id, agent_id: $agent_id, source_application: $application,
+                  lead_agent_id: $lead})
+               SET grant.write_serial = coalesce(grant.write_serial, 0) + 1
+               WITH grant
+               WHERE grant.expires_at > datetime()
+                 AND (grant.session_id IS NULL OR grant.session_id = $session_id)
+               MATCH (session:FuliTaskContextSession)-[:HAS_CONTEXT]->(task:FuliTaskContext)
+               WHERE task.token = grant.sender_token AND session.current_token = task.token
+                 AND NOT task.completed AND task.personal_space_id = grant.space_id
+                 AND task.personal_project_id = grant.project_id
+                 AND (task.project_agent_id = grant.lead_agent_id OR grant.agent_id = grant.lead_agent_id)
+               SET grant.session_id = $session_id, grant.redeemed = true
+               RETURN grant.token_hash AS token_hash''',
+            token_hash=token_hash(request.delegation_token), space_id=request.personal_space_id,
+            project_id=request.personal_project_id, agent_id=request.agent_id,
+            application=request.source_application, lead=lead, session_id=request.delegation_session_id)
+        return bool(rows)
+
+    async def verify_agent_delegation(self, actor, request):
+        self._require_personal()
+        await self.authorize(actor, request.personal_space_id, 'reader')
+        rows, _, _ = await self.runtime.driver.execute_query(
+            '''MATCH (grant:FuliAgentDelegation {token_hash: $token_hash, space_id: $space_id,
+                  session_id: $session_id, redeemed: true})
+               WHERE grant.expires_at > datetime()
+               RETURN grant.token_hash AS token_hash''',
+            token_hash=token_hash(request.token), space_id=request.personal_space_id,
+            session_id=request.session_id)
+        return {'redeemed': bool(rows)}
+
+    async def revoke_agent_delegation(self, actor, request):
+        self._require_personal()
+        await self.authorize(actor, request.personal_space_id, 'maintainer')
+        await self.runtime.driver.execute_query(
+            '''MATCH (grant:FuliAgentDelegation {token_hash: $token_hash, space_id: $space_id})
+               DELETE grant''', token_hash=token_hash(request.token), space_id=request.personal_space_id)
+        return {'revoked': True}

package/graph-provider/fuli_graph/project_agent_employee_numbers.py

@@ -0,0 +1,41 @@
+"""Space-wide FLA employee numbers, assigned in the identity write transaction.
+
+Both identity creation paths take the space lock before touching an Agent.
+The high-water mark survives archives and identity aliases; numbers are never
+reused. Existing identities are backfilled in creation order on upgrade.
+"""
+
+EMPLOYEE_NUMBER_LOCK = '''
+    SET space._employee_number_lock = true
+    REMOVE space._employee_number_lock
+    WITH space
+'''
+
+# Keep outer variables (notably ``agent``) intact. The subquery always returns
+# one row, including when the space has no missing numbers.
+ASSIGN_EMPLOYEE_NUMBERS = '''
+    WITH space, agent
+    CALL {
+      WITH space
+      MATCH (space)-[:HAS_PROJECT_AGENT_IDENTITY]->(employee:FuliProjectAgent)
+      WITH DISTINCT space, employee
+      ORDER BY employee.created_at, employee.agent_id
+      WITH space, collect(employee) AS employees
+      WITH space, employees,
+           [employee IN employees WHERE employee.employee_number IS NULL] AS missing,
+           reduce(high = coalesce(space.fla_employee_sequence, 0), employee IN employees |
+             CASE WHEN coalesce(employee.employee_number, 0) > high
+               THEN employee.employee_number ELSE high END) AS high
+      SET space.fla_employee_sequence = high + size(missing)
+      FOREACH (index IN range(0, size(missing) - 1) |
+        FOREACH (employee IN [missing[index]] |
+          SET employee.employee_number = high + index + 1))
+      FOREACH (employee IN [item IN employees WHERE item.employee_number_space_id IS NULL] |
+        SET employee.employee_number_space_id = space.id)
+      RETURN space.fla_employee_sequence AS employee_sequence
+    }
+'''
+
+
+def employee_number_label(number: int | None) -> str | None:
+    return f'{number:06d}' if number is not None else None

package/graph-provider/fuli_graph/project_agent_memory_routes.py

@@ -15,6 +15,7 @@ from .project_agent_context_models import (
 from .agent_conversation_routes import register_agent_conversation_routes
 from .default_project_lead import DefaultProjectLeadRequest
 from .task_context_routes import register_task_context_routes
+from .project_agent_delegations import AgentDelegationIssue, AgentDelegationCheck
 
 
 def register_project_agent_memory_routes(application, store, Actor):
@@ -26,6 +27,18 @@ def register_project_agent_memory_routes(application, store, Actor):
     async def resolve_context(request: ProjectAgentContextRequest, actor: Actor):
         return await store.resolve_project_agent_context(actor, request)
 
+    @application.post('/v1/project-agent-context/delegations')
+    async def issue_delegation(request: AgentDelegationIssue, actor: Actor):
+        return await store.issue_agent_delegation(actor, request)
+
+    @application.post('/v1/project-agent-context/delegations/verify')
+    async def verify_delegation(request: AgentDelegationCheck, actor: Actor):
+        return await store.verify_agent_delegation(actor, request)
+
+    @application.post('/v1/project-agent-context/delegations/revoke')
+    async def revoke_delegation(request: AgentDelegationCheck, actor: Actor):
+        return await store.revoke_agent_delegation(actor, request)
+
     @application.post(
         '/v1/project-agent-context/default-lead', response_model=ProjectAgentContextResolution,
     )

package/graph-provider/fuli_graph/project_agent_models.py

@@ -277,6 +277,7 @@ class ProjectAgentAssignmentReplaceResult(StrictModel):
 
 class ProjectAgentRecord(StrictModel):
     agent_id: str
+    employee_number: str | None = None
     legacy_agent_ids: list[str] = Field(default_factory=list)
     personal_space_id: str
     personal_project_id: str | None = None

package/graph-provider/fuli_graph/project_agent_task_models.py

@@ -494,6 +494,8 @@ class ProjectAgentTaskRecord(StrictModel):
 
 class ProjectAgentTaskActivityCreate(StrictModel):
     artifact_revision: str | None = Field(default=None, min_length=1, max_length=160)
+    expected_verification_attempt_id: str | None = Field(default=None, min_length=1, max_length=256)
+    judgment_task_context_token: str | None = Field(default=None, min_length=1, max_length=256)
     personal_space_id: str = Field(min_length=1, max_length=128)
     personal_project_id: str = Field(min_length=1, max_length=128)
     task_id: str = Field(min_length=1, max_length=128)

package/graph-provider/fuli_graph/project_agent_team_growth.py

@@ -33,8 +33,8 @@ async def enroll_recruited_team_member(store, recruitment, profile):
              policy.team_lead_agent_id IS NULL AS needs_lead,
              coalesce(policy.team_lead_agent_id = agent.agent_id, false)
                OR agent.agent_id IN members AS already_member
-        WITH *, enabled AND NOT already_member
-                  AND (needs_lead OR size(members) < 32) AS changed
+        WITH *, NOT already_member
+                  AND (needs_lead OR (enabled AND size(members) < 32)) AS changed
         FOREACH (_ IN CASE WHEN changed THEN [1] ELSE [] END |
           SET policy.team_lead_agent_id = CASE WHEN needs_lead
                 THEN agent.agent_id ELSE policy.team_lead_agent_id END,

package/graph-provider/fuli_graph/project_knowledge.py

@@ -578,11 +578,25 @@ async def _upsert_reference(
         space['id'], 'knowledge-reference', item_kind, item_id, project_id
     )
     changed_at = datetime.now(timezone.utc)
+    item_match = (
+        'MATCH (item:Entity {uuid: $item_id, group_id: $group_id})'
+        if item_kind == 'entity'
+        else (
+            'MATCH ()-[item:RELATES_TO '
+            '{uuid: $item_id, group_id: $group_id}]->()'
+        )
+    )
     records, _, _ = await store.runtime.driver.execute_query(
         '''
         MATCH (space:FuliSpace {id: $space_id, kind: 'personal'})
         MATCH (space)-[:CONTAINS_PROJECT]->
               (target:FuliPersonalProject {project_id: $project_id})
+        '''
+        + item_match
+        + '''
+        SET item.fuli_ai_review_lock_version =
+              coalesce(item.fuli_ai_review_lock_version, 0) + 1
+        WITH space, target
         MERGE (reference:FuliKnowledgeProjectReference {
           space_id: $space_id,
           item_kind: $item_kind,
@@ -604,6 +618,7 @@ async def _upsert_reference(
         space_id=space['id'],
         item_kind=item_kind,
         item_id=item_id,
+        group_id=space['group_id'],
         project_id=project_id,
         reference_id=reference_id,
         source_project_id=source_project_id,
@@ -635,6 +650,31 @@ async def _upsert_conflict(
     records, _, _ = await store.runtime.driver.execute_query(
         '''
         MATCH (space:FuliSpace {id: $space_id, kind: 'personal'})
+        MATCH (item:Entity {uuid: $item_id, group_id: $group_id})
+        MATCH (target_item:Entity {
+          uuid: $target_item_id,
+          group_id: $group_id
+        })
+        WITH space,
+             CASE
+               WHEN item.uuid = target_item.uuid
+                 THEN [{kind: 'entity', item: item}]
+               WHEN item.uuid < target_item.uuid
+                 THEN [
+                   {kind: 'entity', item: item},
+                   {kind: 'entity', item: target_item}
+                 ]
+               ELSE [
+                 {kind: 'entity', item: target_item},
+                 {kind: 'entity', item: item}
+               ]
+             END AS lock_items
+        UNWIND lock_items AS lock_item
+        WITH space, lock_item
+        ORDER BY lock_item.kind + ':' + lock_item.item.uuid
+        SET lock_item.item.fuli_ai_review_lock_version =
+              coalesce(lock_item.item.fuli_ai_review_lock_version, 0) + 1
+        WITH space, collect(lock_item) AS _locked_items
         MERGE (conflict:FuliKnowledgeConflict {id: $conflict_id})
         ON CREATE SET conflict.created_at = $changed_at
         SET conflict.space_id = $space_id,
@@ -651,6 +691,7 @@ async def _upsert_conflict(
         RETURN conflict
         ''',
         space_id=space['id'],
+        group_id=space['group_id'],
         conflict_id=conflict_id,
         item_id=item_id,
         target_item_id=target_item_id,

package/graph-provider/fuli_graph/runtime.py

@@ -226,6 +226,10 @@ class GraphitiRuntime:
             'CREATE CONSTRAINT fuli_workflow_review_preview_token IF NOT EXISTS '
             'FOR (n:FuliWorkflowReviewPreview) REQUIRE n.token_hash IS UNIQUE'
         )
+        await self.driver.execute_query(
+            'CREATE CONSTRAINT fuli_agent_delegation_token IF NOT EXISTS '
+            'FOR (n:FuliAgentDelegation) REQUIRE n.token_hash IS UNIQUE'
+        )
         await self.driver.execute_query(
             'CREATE CONSTRAINT fuli_workflow_rule_id IF NOT EXISTS '
             'FOR (n:FuliWorkflowRule) REQUIRE n.id IS UNIQUE'
@@ -285,6 +289,9 @@ class GraphitiRuntime:
             'FOR (n:FuliConversationPolicy) REQUIRE n.id IS UNIQUE',
             'CREATE CONSTRAINT fuli_project_agent_id IF NOT EXISTS '
             'FOR (n:FuliProjectAgent) REQUIRE n.id IS UNIQUE',
+            'CREATE CONSTRAINT fuli_project_agent_employee_number IF NOT EXISTS '
+            'FOR (n:FuliProjectAgent) '
+            'REQUIRE (n.employee_number_space_id, n.employee_number) IS UNIQUE',
             'CREATE CONSTRAINT fuli_agent_attention_id IF NOT EXISTS '
             'FOR (n:FuliAgentAttention) REQUIRE n.id IS UNIQUE',
             'CREATE CONSTRAINT fuli_project_agent_assignment_id IF NOT EXISTS '
@@ -649,6 +656,10 @@ class GraphitiRuntime:
                OR item.fuli_usage_generation IS NULL
                OR item.fuli_inheritance_mode IS NULL
                OR item.fuli_inherited_project_ids IS NULL
+            WITH item
+            ORDER BY 'entity:' + item.uuid
+            SET item.fuli_ai_review_lock_version =
+                  coalesce(item.fuli_ai_review_lock_version, 0) + 1
             SET item.fuli_utility_score =
                   coalesce(item.fuli_utility_score, 0.0),
                 item.fuli_confidence_score = coalesce(
@@ -681,6 +692,10 @@ class GraphitiRuntime:
                OR item.fuli_usage_generation IS NULL
                OR item.fuli_inheritance_mode IS NULL
                OR item.fuli_inherited_project_ids IS NULL
+            WITH item
+            ORDER BY 'relationship:' + item.uuid
+            SET item.fuli_ai_review_lock_version =
+                  coalesce(item.fuli_ai_review_lock_version, 0) + 1
             SET item.fuli_utility_score =
                   coalesce(item.fuli_utility_score, 0.0),
                 item.fuli_confidence_score = coalesce(