fuli-context 0.11.1 → 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_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_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

@@ -656,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(
@@ -688,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(

package/graph-provider/fuli_graph/store_agent_verification.py

@@ -43,7 +43,7 @@ class StoreAgentVerification:
         task = await self._quality_task(actor, request)
         rows, _, _ = await self.runtime.driver.execute_query(
             'MATCH (t:FuliProjectAgentTask {task_id:$task, personal_space_id:$space})-[:HAS_VERIFICATION]->(v:FuliAgentVerification) '
-            'RETURN v.record_json AS record_json ORDER BY v.sequence', task=request.task_id, space=request.personal_space_id)
+            'RETURN v.record_json AS record_json, v.run_id AS run_id ORDER BY v.sequence', task=request.task_id, space=request.personal_space_id)
         models = await self._quality_models(actor, request, task)
         result = evaluate_quality_policy(complexity=task.get('complexity') or 'standard',
             current_strategy=json.loads(task.get('effective_model_strategy_json') or '{"mode":"adaptive"}'),
@@ -53,7 +53,12 @@ class StoreAgentVerification:
         if selected:
             selected['executor_id'] = next(model['executor_id'] for model in models
                 if all(model.get(key) == selected[key] for key in ('provider', 'model', 'capability_tier', 'cost_rank')))
-        return {**result, 'evidence_authority': 'host_reported_test_evidence',
+        verified = next((row for row in rows if json.loads(row['record_json']).get('attempt_id') == result['verified_attempt_id']), None)
+        attempt = json.loads(verified['record_json']) if verified else None
+        if attempt:
+            attempt = {key: attempt.get(key) for key in ('attempt_id', 'artifact_revision', 'outcome', 'evidence_refs', 'verifier_id', 'executor_id', 'provider', 'model')}
+            attempt['run_id'] = verified.get('run_id')
+        return {**result, 'verified_attempt': attempt, 'evidence_authority': 'host_reported_test_evidence',
             'execution_started': False, 'guidance': 'Only complete the task after passed for the current artifact revision. Blocked means no authorized preflighted model proves the required capability tier. Model selection does not prove execution.'}
 
     async def record_agent_verification(self, actor, request):
@@ -92,7 +97,8 @@ class StoreAgentVerification:
                 raise HTTPException(409, 'An execution run cannot count as two verification attempts')
             identifier = stable_uuid('verification', request.personal_space_id, request.task_id, request.attempt_id)
             record = dict(attempt_id=request.attempt_id, outcome=request.outcome, artifact_revision=request.artifact_revision,
-                evidence_refs=request.evidence_refs, capability_tier=observed['capability_tier'], verifier_id=context['project_agent_id'])
+                evidence_refs=request.evidence_refs, capability_tier=observed['capability_tier'], verifier_id=context['project_agent_id'],
+                executor_id=request.executor_id, provider=request.provider, model=request.model)
             fingerprint = store._payload_hash(request)
             rows, _, _ = await store.runtime.driver.execute_query(
                 'MATCH (t:FuliProjectAgentTask {task_id:$task, personal_space_id:$space}) '
@@ -106,6 +112,7 @@ class StoreAgentVerification:
             result = await store.query_agent_quality(actor, request)
             await store.runtime.driver.execute_query(
                 'MATCH (t:FuliProjectAgentTask {task_id:$task, personal_space_id:$space}) '
-                'SET t.quality_gate=$status, t.verified_artifact_revision=$revision',
-                task=request.task_id, space=request.personal_space_id, status=result['status'], revision=request.artifact_revision)
+                'SET t.quality_gate=$status, t.verified_artifact_revision=$revision, t.verified_attempt_id=$attempt',
+                task=request.task_id, space=request.personal_space_id, status=result['status'], revision=request.artifact_revision,
+                attempt=result.get('verified_attempt_id'))
             return result

package/graph-provider/fuli_graph/store_knowledge.py

@@ -325,6 +325,8 @@ class StoreKnowledge:
             await self.runtime.driver.execute_query(
                 '''
                 UNWIND $entities AS row
+                WITH row
+                ORDER BY 'entity:' + row.uuid
                 MERGE (entity:Entity {uuid: row.uuid})
                 ON CREATE SET entity.group_id = $group_id,
                     entity.name = row.name,
@@ -365,6 +367,8 @@ class StoreKnowledge:
                     entity.fuli_preference_project_id = row.preference_project_id,
                     entity.fuli_preference_agent_id = row.preference_agent_id,
                     entity.fuli_attributes_json = row.attributes_json
+                SET entity.fuli_ai_review_lock_version =
+                      coalesce(entity.fuli_ai_review_lock_version, 0) + 1
                 WITH count(entity) AS entity_count
                 CREATE (episode:Episodic {
                   uuid: $episode_id,
@@ -392,12 +396,95 @@ class StoreKnowledge:
                 })
                 WITH episode
                 UNWIND $entities AS row
+                WITH episode, row
+                ORDER BY 'entity:' + row.uuid
                 MATCH (entity:Entity {uuid: row.uuid})
                 MERGE (episode)-[mention:MENTIONS {uuid: row.mention_uuid}]->(entity)
                 SET mention.group_id = $group_id,
                     mention.created_at = $created_at
                 WITH episode
+                CALL {
+                  WITH episode
+                  OPTIONAL MATCH ()-[old:RELATES_TO {group_id: $group_id}]->()
+                  WITH collect(old) AS candidate_olds
+                  UNWIND candidate_olds AS old
+                  WITH old
+                  WHERE old IS NOT NULL
+                    AND old.invalid_at IS NULL
+                    AND NOT (old.uuid IN $relationship_ids)
+                    AND (
+                      EXISTS {
+                        MATCH (:FuliSpace {id: $space_id})-
+                              [:HAS_KNOWLEDGE_ASSIGNMENT]->
+                              (assignment:FuliKnowledgeAssignment {
+                                item_kind: 'relationship',
+                                item_id: old.uuid
+                              })
+                        WHERE assignment.project_id = $personal_project_id
+                      }
+                      OR (
+                        NOT EXISTS {
+                          MATCH (:FuliSpace {id: $space_id})-
+                                [:HAS_KNOWLEDGE_ASSIGNMENT]->
+                                (:FuliKnowledgeAssignment {
+                                  item_kind: 'relationship',
+                                  item_id: old.uuid
+                                })
+                        }
+                        AND EXISTS {
+                          MATCH (old_episode:Episodic {group_id: $group_id})
+                          WHERE old_episode.uuid IN coalesce(old.episodes, [])
+                            AND (
+                              old_episode.fuli_personal_project_id =
+                                $personal_project_id
+                              OR (
+                                old_episode.fuli_personal_project_id IS NULL
+                                AND $personal_project_id IS NULL
+                              )
+                            )
+                        }
+                      )
+                    )
+                    AND EXISTS {
+                      MATCH (agent_episode:Episodic {group_id: $group_id})
+                      WHERE agent_episode.uuid IN coalesce(old.episodes, [])
+                        AND (
+                          agent_episode.fuli_project_agent_id = $project_agent_id
+                          OR (
+                            agent_episode.fuli_project_agent_id IS NULL
+                            AND $project_agent_id IS NULL
+                          )
+                        )
+                    }
+                    AND any(
+                      replacement IN $superseded_relationships
+                      WHERE replacement.key = old.fuli_key
+                    )
+                  WITH collect(old) AS superseded_edges
+                  OPTIONAL MATCH ()-[existing:RELATES_TO {
+                    group_id: $group_id
+                  }]->()
+                  WITH superseded_edges, collect(existing) AS candidate_existing
+                  RETURN superseded_edges,
+                         [edge IN candidate_existing
+                          WHERE edge IS NOT NULL
+                            AND edge.uuid IN $relationship_ids]
+                           AS existing_edges
+                }
+                CALL {
+                  WITH superseded_edges, existing_edges
+                  UNWIND superseded_edges + existing_edges AS lock_edge
+                  WITH lock_edge
+                  WHERE lock_edge IS NOT NULL
+                  ORDER BY 'relationship:' + lock_edge.uuid
+                  SET lock_edge.fuli_ai_review_lock_version =
+                        coalesce(lock_edge.fuli_ai_review_lock_version, 0) + 1
+                  RETURN count(*) AS _locked_relationship_count
+                }
+                WITH episode, superseded_edges
                 UNWIND $relationships AS row
+                WITH episode, superseded_edges, row
+                ORDER BY 'relationship:' + row.uuid
                 MATCH (source:Entity {uuid: row.source_uuid})
                 MATCH (target:Entity {uuid: row.target_uuid})
                 MERGE (source)-[edge:RELATES_TO {uuid: row.uuid}]->(target)
@@ -435,73 +522,26 @@ class StoreKnowledge:
                     edge.fuli_workflow_confirmation_authority =
                       row.workflow_confirmation_authority,
                     edge.fuli_workflow_session_authority =
-                      row.workflow_session_authority
+                      row.workflow_session_authority,
+                    edge.fuli_ai_review_lock_version = 1
                 SET edge.episodes =
                   CASE WHEN $episode_id IN coalesce(edge.episodes, [])
                        THEN edge.episodes
                        ELSE coalesce(edge.episodes, []) + $episode_id END
-                WITH count(edge) AS edge_count
-                OPTIONAL MATCH ()-[old:RELATES_TO {group_id: $group_id}]->()
-                WHERE old.invalid_at IS NULL
-                  AND NOT (old.uuid IN $relationship_ids)
-                  AND (
-                    EXISTS {
-                      MATCH (:FuliSpace {id: $space_id})-
-                            [:HAS_KNOWLEDGE_ASSIGNMENT]->
-                            (assignment:FuliKnowledgeAssignment {
-                              item_kind: 'relationship',
-                              item_id: old.uuid
-                            })
-                      WHERE assignment.project_id = $personal_project_id
-                    }
-                    OR (
-                      NOT EXISTS {
-                        MATCH (:FuliSpace {id: $space_id})-
-                              [:HAS_KNOWLEDGE_ASSIGNMENT]->
-                              (:FuliKnowledgeAssignment {
-                                item_kind: 'relationship',
-                                item_id: old.uuid
-                              })
-                      }
-                      AND EXISTS {
-                        MATCH (old_episode:Episodic {group_id: $group_id})
-                        WHERE old_episode.uuid IN coalesce(old.episodes, [])
-                          AND (
-                            old_episode.fuli_personal_project_id =
-                              $personal_project_id
-                            OR (
-                              old_episode.fuli_personal_project_id IS NULL
-                              AND $personal_project_id IS NULL
-                            )
-                          )
-                      }
-                    )
-                  )
-                  AND EXISTS {
-                    MATCH (agent_episode:Episodic {group_id: $group_id})
-                    WHERE agent_episode.uuid IN coalesce(old.episodes, [])
-                      AND (
-                        agent_episode.fuli_project_agent_id = $project_agent_id
-                        OR (
-                          agent_episode.fuli_project_agent_id IS NULL
-                          AND $project_agent_id IS NULL
-                        )
-                      )
-                  }
-                  AND any(
+                WITH episode, superseded_edges, count(edge) AS edge_count
+                CALL {
+                  WITH superseded_edges
+                  UNWIND superseded_edges AS old
+                  WITH old, head([
                     replacement IN $superseded_relationships
-                    WHERE replacement.key = old.fuli_key
-                  )
-                WITH edge_count, old, head([
-                  replacement IN $superseded_relationships
-                  WHERE replacement.key = old.fuli_key | replacement
-                ]) AS replacement
-                FOREACH (_ IN CASE WHEN old IS NULL THEN [] ELSE [1] END |
+                    WHERE replacement.key = old.fuli_key | replacement
+                  ]) AS replacement
                   SET old.invalid_at = $reference_time,
                       old.expired_at = $created_at,
                       old.fuli_replaced_by_item_id = replacement.replacement_id,
                       old.fuli_replaced_by_item_kind = 'relationship'
-                )
+                  RETURN count(*) AS _superseded_relationship_count
+                }
                 RETURN edge_count
                 ''',
                 entities=[

package/graph-provider/fuli_graph/store_project_agent_attention.py

@@ -24,7 +24,7 @@ class StoreProjectAgentAttention:
             self, actor, space, request.personal_project_id, agent_id,
             require_active=True,
             allow_unassigned=agent_id in {
-                'employee.bole', 'employee.jefa', 'fuli-project-coordinator',
+                'employee.bole', 'employee.jefa', 'employee.tonborg', 'fuli-project-coordinator',
             },
         )
         if request.task_id: