fuli-context 0.7.3 → 0.7.4-beta.2

package/graph-provider/fuli_graph/collaboration_context.py

@@ -1,4 +1,5 @@
 from collections import defaultdict
+from math import isfinite
 
 from fastapi import HTTPException
 
@@ -33,12 +34,23 @@ async def read_collaboration_context(
             space,
             personal_project_id,
         )
+    project_scopes = await _project_scopes(
+        store,
+        space,
+        personal_project_id,
+    )
+    inherited_project_ids = [
+        project_id
+        for project_id, scope in project_scopes.items()
+        if scope['scope_distance'] > 0
+    ]
 
     candidate_limit = min(max(limit * 3, 100), store.settings.graph_limit)
     node_records, _, _ = await store.runtime.driver.execute_query(
         _node_query(),
         group_id=space['group_id'],
         project_id=personal_project_id,
+        inherited_project_ids=inherited_project_ids,
         limit=candidate_limit + 1,
         routing_='r',
     )
@@ -46,6 +58,7 @@ async def read_collaboration_context(
         _edge_query(),
         group_id=space['group_id'],
         project_id=personal_project_id,
+        inherited_project_ids=inherited_project_ids,
         limit=candidate_limit + 1,
         routing_='r',
     )
@@ -56,12 +69,12 @@ async def read_collaboration_context(
     nodes = [
         item
         for record in node_records[:candidate_limit]
-        if (item := _node_item(record)) is not None
+        if (item := _node_item(record, project_scopes)) is not None
     ]
     edge_pairs = [
         (record, item)
         for record in edge_records[:candidate_limit]
-        if (item := _edge_item(record)) is not None
+        if (item := _edge_item(record, project_scopes)) is not None
     ]
     edges = [item for _, item in edge_pairs]
     edge_endpoint_ids = {
@@ -84,19 +97,35 @@ async def read_collaboration_context(
     project_preferences = [
         item for item in items if item.preference_scope == 'project'
     ]
-    global_effective, global_conflicts = _conflict_free(global_preferences)
-    project_effective, project_conflicts = _conflict_free(project_preferences)
-    project_keys = {item.preference_key for item in project_preferences}
-    overridden_global_ids = [
+    (
+        authoritative_global,
+        authoritative_project,
+        cross_scope_lower_authority_ids,
+    ) = _highest_authority_by_key(global_preferences, project_preferences)
+    (
+        project_effective,
+        project_conflicts,
+        overridden_inherited_ids,
+        overridden_lower_authority_ids,
+    ) = _scope_conflict_free(authoritative_project)
+    overridden_lower_authority_ids = sorted({
+        *cross_scope_lower_authority_ids,
+        *overridden_lower_authority_ids,
+    })
+    # Any authoritative project-layer claim blocks global fallback for that
+    # semantic key. A same-layer project conflict must remain deferred instead
+    # of silently reviving a global value as effective.
+    project_keys = {item.preference_key for item in authoritative_project}
+    overridden_global_ids = sorted([
         item.id
-        for item in global_effective
+        for item in authoritative_global
         if item.preference_key in project_keys
-    ]
-    effective_preferences = [
-        item
-        for item in global_effective
+    ])
+    global_effective, global_conflicts = _conflict_free([
+        item for item in authoritative_global
         if item.preference_key not in project_keys
-    ] + project_effective
+    ])
+    effective_preferences = [*global_effective, *project_effective]
 
     return CollaborationContextResult(
         personal_space_id=space_id,
@@ -106,10 +135,67 @@ async def read_collaboration_context(
         effective_preferences=effective_preferences,
         conflicts=[*global_conflicts, *project_conflicts],
         overridden_global_ids=overridden_global_ids,
+        overridden_inherited_ids=overridden_inherited_ids,
+        overridden_lower_authority_ids=overridden_lower_authority_ids,
         truncated=truncated,
     )
 
 
+async def _project_scopes(store, space, personal_project_id):
+    if not personal_project_id:
+        return {}
+    scopes = {
+        personal_project_id: {
+            'scope_distance': 0,
+            'scope_path': [personal_project_id],
+        },
+    }
+    records, _, _ = await store.runtime.driver.execute_query(
+        '''
+        MATCH (space:FuliSpace {id: $space_id, kind: 'personal'})-
+              [:CONTAINS_PROJECT]->
+              (active:FuliPersonalProject {project_id: $active_project_id})
+        MATCH path=(active)-[:PERSONAL_PROJECT_RELATION*1..2]->
+              (source:FuliPersonalProject)
+        WHERE all(
+          relation IN relationships(path)
+          WHERE relation.relation_type IN ['PART_OF', 'USES_KNOWLEDGE_FROM']
+            AND relation.status = 'active'
+            AND relation.confirmation_authority = 'human_review'
+        )
+          AND EXISTS {
+            MATCH (space)-[:CONTAINS_PROJECT]->(source)
+          }
+        RETURN source.project_id AS project_id,
+               [node IN nodes(path) | node.project_id] AS scope_path,
+               length(path) AS scope_distance
+        ORDER BY scope_distance ASC, project_id ASC
+        LIMIT $inheritance_limit
+        ''',
+        space_id=space['id'],
+        active_project_id=personal_project_id,
+        inheritance_limit=min(
+            int(getattr(getattr(store, 'settings', None), 'graph_limit', 500)),
+            64,
+        ),
+        routing_='r',
+    )
+    for record in records:
+        project_id = record['project_id']
+        distance = int(record['scope_distance'])
+        path = list(record.get('scope_path') or [])
+        if len(path) != distance + 1 or len(path) != len(set(path)):
+            continue
+        existing = scopes.get(project_id)
+        if existing is not None and existing['scope_distance'] <= distance:
+            continue
+        scopes[project_id] = {
+            'scope_distance': distance,
+            'scope_path': path,
+        }
+    return scopes
+
+
 def _node_query() -> str:
     return '''
         MATCH (node:Entity {group_id: $group_id})
@@ -120,7 +206,19 @@ def _node_query() -> str:
                coalesce(node.fuli_preference_scope, 'global') = 'global'
             OR (
               node.fuli_preference_scope = 'project'
-              AND node.fuli_preference_project_id = $project_id
+              AND (
+                   node.fuli_preference_project_id = $project_id
+                OR (
+                  node.fuli_preference_project_id IN $inherited_project_ids
+                  AND (
+                       node.fuli_inheritance_mode = 'descendants'
+                    OR (
+                      node.fuli_inheritance_mode = 'selected_projects'
+                      AND $project_id IN coalesce(node.fuli_inherited_project_ids, [])
+                    )
+                  )
+                )
+              )
             )
           )
         RETURN node.uuid AS id,
@@ -132,6 +230,9 @@ def _node_query() -> str:
                node.fuli_preference_project_id AS preference_project_id,
                node.fuli_attributes_json AS attributes_json,
                node.fuli_confirmation_basis_json AS confirmation_basis_json,
+               node.fuli_reasoning_summary AS reasoning_summary,
+               coalesce(node.fuli_inheritance_mode, 'local_only') AS inheritance_mode,
+               coalesce(node.fuli_inherited_project_ids, []) AS inherited_project_ids,
                node.fuli_confirmation_status AS confirmation_status,
                node.created_at AS created_at
         ORDER BY node.created_at DESC
@@ -150,7 +251,19 @@ def _edge_query() -> str:
                coalesce(edge.fuli_preference_scope, 'global') = 'global'
             OR (
               edge.fuli_preference_scope = 'project'
-              AND edge.fuli_preference_project_id = $project_id
+              AND (
+                   edge.fuli_preference_project_id = $project_id
+                OR (
+                  edge.fuli_preference_project_id IN $inherited_project_ids
+                  AND (
+                       edge.fuli_inheritance_mode = 'descendants'
+                    OR (
+                      edge.fuli_inheritance_mode = 'selected_projects'
+                      AND $project_id IN coalesce(edge.fuli_inherited_project_ids, [])
+                    )
+                  )
+                )
+              )
             )
           )
         RETURN edge.uuid AS id,
@@ -165,6 +278,9 @@ def _edge_query() -> str:
                edge.fuli_preference_project_id AS preference_project_id,
                edge.fuli_attributes_json AS attributes_json,
                edge.fuli_confirmation_basis_json AS confirmation_basis_json,
+               edge.fuli_reasoning_summary AS reasoning_summary,
+               coalesce(edge.fuli_inheritance_mode, 'local_only') AS inheritance_mode,
+               coalesce(edge.fuli_inherited_project_ids, []) AS inherited_project_ids,
                edge.fuli_confirmation_status AS confirmation_status,
                edge.created_at AS created_at
         ORDER BY edge.created_at DESC
@@ -172,16 +288,17 @@ def _edge_query() -> str:
     '''
 
 
-def _node_item(record) -> CollaborationPreferenceItem | None:
+def _node_item(record, project_scopes) -> CollaborationPreferenceItem | None:
     return _preference_item(
         record,
         item_kind='entity',
         title=record.get('title') or record.get('key') or record.get('id'),
         instruction=record.get('instruction') or record.get('title') or '',
+        project_scopes=project_scopes,
     )
 
 
-def _edge_item(record) -> CollaborationPreferenceItem | None:
+def _edge_item(record, project_scopes) -> CollaborationPreferenceItem | None:
     source = record.get('source_name') or '偏好'
     target = record.get('target_name') or '适用场景'
     return _preference_item(
@@ -189,6 +306,7 @@ def _edge_item(record) -> CollaborationPreferenceItem | None:
         item_kind='relationship',
         title=f'{source} → {target}',
         instruction=record.get('instruction') or '',
+        project_scopes=project_scopes,
     )
 
 
@@ -198,6 +316,7 @@ def _preference_item(
     item_kind: str,
     title: str,
     instruction: str,
+    project_scopes: dict[str, dict],
 ) -> CollaborationPreferenceItem | None:
     basis_data = json_object(record.get('confirmation_basis_json'))
     if not basis_data:
@@ -217,6 +336,35 @@ def _preference_item(
         or attributes.get('preference_key')
         or key
     )
+    project_id = record.get('preference_project_id')
+    scope = project_scopes.get(project_id, {
+        'scope_distance': 0,
+        'scope_path': [],
+    })
+    scope_distance = int(scope['scope_distance'])
+    inheritance_mode = record.get('inheritance_mode') or 'local_only'
+    inherited_project_ids = list(record.get('inherited_project_ids') or [])
+    active_project_id = scope['scope_path'][0] if scope['scope_path'] else None
+    if scope_distance > 0 and (
+        inheritance_mode == 'local_only'
+        or (
+            inheritance_mode == 'selected_projects'
+            and active_project_id not in inherited_project_ids
+        )
+    ):
+        return None
+    weight = attributes.get('weight')
+    if (
+        not isinstance(weight, (int, float))
+        or isinstance(weight, bool)
+        or not isfinite(weight)
+        or weight < 0
+        or weight > 1
+    ):
+        weight = None
+    reason = attributes.get('reason')
+    if not isinstance(reason, str) or not reason.strip():
+        reason = record.get('reasoning_summary') or basis.existence_reason
     return CollaborationPreferenceItem(
         id=str(record['id']),
         item_kind=item_kind,
@@ -226,11 +374,20 @@ def _preference_item(
         instruction=str(instruction),
         profile_aspect=record['profile_aspect'],
         preference_scope=record['preference_scope'],
-        preference_project_id=record.get('preference_project_id'),
+        preference_project_id=project_id,
         attributes=attributes,
+        weight=weight,
+        reason=reason,
+        confirmation_basis=basis,
+        reasoning_summary=record.get('reasoning_summary'),
+        inheritance_mode=inheritance_mode,
+        inherited_project_ids=inherited_project_ids,
         confirmation_status=confirmation_status,
         confirmed_at=basis.confirmed_at,
         created_at=_native_datetime(record.get('created_at')),
+        scope_distance=scope_distance,
+        inherited_from_project_id=project_id if scope_distance > 0 else None,
+        scope_path=list(scope['scope_path']),
     )
 
 
@@ -274,6 +431,84 @@ def _conflict_free(
     return effective, conflicts
 
 
+def _scope_conflict_free(
+    items: list[CollaborationPreferenceItem],
+) -> tuple[
+    list[CollaborationPreferenceItem],
+    list[CollaborationPreferenceConflict],
+    list[str],
+    list[str],
+]:
+    grouped: dict[str, list[CollaborationPreferenceItem]] = defaultdict(list)
+    for item in items:
+        grouped[item.preference_key].append(item)
+
+    effective = []
+    conflicts = []
+    overridden = []
+    lower_authority = []
+    for candidates in grouped.values():
+        strongest_status = (
+            'confirmed'
+            if any(item.confirmation_status == 'confirmed' for item in candidates)
+            else 'agent_confirmed'
+        )
+        authoritative = [
+            item for item in candidates
+            if item.confirmation_status == strongest_status
+        ]
+        lower_authority.extend(
+            item.id for item in candidates
+            if item.confirmation_status != strongest_status
+        )
+        nearest_distance = min(item.scope_distance for item in authoritative)
+        nearest = [
+            item for item in authoritative
+            if item.scope_distance == nearest_distance
+        ]
+        overridden.extend(
+            item.id for item in authoritative
+            if item.scope_distance > nearest_distance
+        )
+        group_effective, group_conflicts = _conflict_free(nearest)
+        effective.extend(group_effective)
+        conflicts.extend(group_conflicts)
+    effective.sort(key=_sort_key)
+    conflicts.sort(key=lambda conflict: conflict.preference_key)
+    return effective, conflicts, sorted(overridden), sorted(lower_authority)
+
+
+def _highest_authority_by_key(
+    global_items: list[CollaborationPreferenceItem],
+    project_items: list[CollaborationPreferenceItem],
+) -> tuple[
+    list[CollaborationPreferenceItem],
+    list[CollaborationPreferenceItem],
+    list[str],
+]:
+    grouped: dict[str, list[CollaborationPreferenceItem]] = defaultdict(list)
+    for item in [*global_items, *project_items]:
+        grouped[item.preference_key].append(item)
+    selected_ids = set()
+    lower_authority_ids = []
+    for candidates in grouped.values():
+        strongest_status = (
+            'confirmed'
+            if any(item.confirmation_status == 'confirmed' for item in candidates)
+            else 'agent_confirmed'
+        )
+        for item in candidates:
+            if item.confirmation_status == strongest_status:
+                selected_ids.add(item.id)
+            else:
+                lower_authority_ids.append(item.id)
+    return (
+        [item for item in global_items if item.id in selected_ids],
+        [item for item in project_items if item.id in selected_ids],
+        sorted(lower_authority_ids),
+    )
+
+
 def _sort_key(item: CollaborationPreferenceItem) -> tuple:
     created = -item.created_at.timestamp() if item.created_at else 0
     return (
@@ -281,6 +516,7 @@ def _sort_key(item: CollaborationPreferenceItem) -> tuple:
         0 if item.confirmation_status == 'confirmed' else 1,
         item.profile_aspect,
         item.preference_key,
+        -(item.weight or 0),
         created,
         item.id,
     )

package/graph-provider/fuli_graph/common_knowledge.py

@@ -224,8 +224,10 @@ async def _direct_child_project_ids(store, space_id, parent_project_id):
         '''
         MATCH (:FuliSpace {id: $space_id, kind: 'personal'})-
               [:CONTAINS_PROJECT]->(child:FuliPersonalProject)-
-              [:PERSONAL_PROJECT_RELATION {relation_type: 'PART_OF'}]->
+              [relation:PERSONAL_PROJECT_RELATION {relation_type: 'PART_OF'}]->
               (parent:FuliPersonalProject {project_id: $parent_project_id})
+        WHERE relation.status = 'active'
+          AND relation.confirmation_authority = 'human_review'
         RETURN child.project_id AS child_project_id
         ORDER BY child.project_id
         ''',
@@ -315,8 +317,10 @@ def _promotion_query(item_kind):
         UNWIND $source_project_ids AS source_project_id
         MATCH (space)-[:CONTAINS_PROJECT]->
               (child:FuliPersonalProject {{project_id: source_project_id}})-
-              [:PERSONAL_PROJECT_RELATION {{relation_type: 'PART_OF'}}]->
+              [relation:PERSONAL_PROJECT_RELATION {{relation_type: 'PART_OF'}}]->
               (parent)
+        WHERE relation.status = 'active'
+          AND relation.confirmation_authority = 'human_review'
         WITH space, parent, collect(DISTINCT child.project_id) AS direct_children
         WHERE size(direct_children) = size($source_project_ids)
         {canonical_match}

package/graph-provider/fuli_graph/config.py

@@ -12,6 +12,11 @@ class Settings(BaseSettings):
     provider_id: str = 'local-personal'
     provider_name: str = 'Fuli Personal Provider'
     bootstrap_token: str = Field(min_length=24)
+    human_review_token: str | None = Field(default=None, min_length=32)
+    workflow_observation_token: str | None = Field(
+        default=None,
+        min_length=32,
+    )
     neo4j_uri: str = 'bolt://neo4j:7687'
     neo4j_user: str = 'neo4j'
     neo4j_password: str = Field(min_length=8)

package/graph-provider/fuli_graph/graph_models.py

@@ -32,6 +32,9 @@ class GraphNode(StrictModel):
     type: str
     group_id: str
     summary: str
+    key: str | None = None
+    preference_key: str | None = None
+    preference_qualifiers: dict[str, Any] = Field(default_factory=dict)
     origin_quadrant: EpistemicQuadrant = 'known_known'
     current_quadrant: EpistemicQuadrant = 'known_known'
     epistemic_status: EpistemicStatus = 'confirmed'
@@ -82,6 +85,9 @@ class GraphEdge(StrictModel):
     target_name: str | None = None
     type: str
     fact: str
+    key: str | None = None
+    preference_key: str | None = None
+    preference_qualifiers: dict[str, Any] = Field(default_factory=dict)
     origin_quadrant: EpistemicQuadrant = 'known_known'
     current_quadrant: EpistemicQuadrant = 'known_known'
     epistemic_status: EpistemicStatus = 'confirmed'

package/graph-provider/fuli_graph/graph_projection.py

@@ -2,6 +2,7 @@ from collections.abc import Iterable
 
 from .graph_models import GraphEdge, GraphNode
 from .models import ProjectProfile
+from .provider_values import native_datetime
 
 
 def management_projection(
@@ -58,6 +59,7 @@ def management_projection(
             target=target_id,
             type=relation['relation_type'],
             fact=_relation_fact(relation),
+            attributes=_relation_attributes(relation),
             valid_at=None,
             invalid_at=None,
         ))
@@ -118,6 +120,7 @@ def personal_project_projection(
             target=related_id if current_is_source else root_id,
             type=relation['relation_type'],
             fact=_relation_fact(relation),
+            attributes=_relation_attributes(relation),
             valid_at=None,
             invalid_at=None,
         ))
@@ -183,6 +186,17 @@ def personal_project_projection(
     return nodes, edges
 
 
+def _relation_attributes(relation: dict) -> dict:
+    return {
+        'status': relation.get('status') or 'pending',
+        'confirmationAuthority': relation.get('confirmation_authority'),
+        'decisionRevision': int(relation.get('decision_revision') or 0),
+        'reviewReason': relation.get('review_reason'),
+        'reviewedBy': relation.get('reviewed_by'),
+        'reviewedAt': native_datetime(relation.get('reviewed_at')),
+    }
+
+
 def coalesce_personal_project_identity(
     project: dict,
     management_nodes: list[GraphNode],

package/graph-provider/fuli_graph/graph_query.py

@@ -12,7 +12,11 @@ from .models import (
 from .knowledge_audit import read_knowledge_audits
 from .knowledge_records import assignment_record, revision_record
 from .personal_project_access import authorize_personal_project
-from .provider_values import json_object, native_datetime as _native_datetime
+from .provider_values import (
+    json_object,
+    native_datetime as _native_datetime,
+    preference_qualifiers,
+)
 from .project_knowledge import (
     read_knowledge_conflicts,
     read_personal_project_relations,
@@ -239,6 +243,7 @@ def _node_query(project_scoped: bool, paginated: bool = False) -> str:
                node.fuli_last_feedback_at AS last_feedback_at,
                coalesce(node.fuli_usage_generation, 1) AS usage_generation,
                coalesce(node.fuli_attributes_json, '{}') AS attributes_json,
+               coalesce(node.fuli_key, node.uuid) AS key,
                [episode IN episodes WHERE episode IS NOT NULL | episode.uuid] AS episodes,
                node.created_at AS created_at,
                node.fuli_invalid_at AS invalid_at,
@@ -358,6 +363,7 @@ def _edge_query(project_scoped: bool, paginated: bool = False) -> str:
                edge.created_at AS created_at,
                edge.fuli_confidence AS confidence,
                coalesce(edge.fuli_attributes_json, '{}') AS attributes_json,
+               coalesce(edge.fuli_key, edge.uuid) AS key,
                coalesce(edge.episodes, []) AS episodes
         ORDER BY created_at DESC, id DESC
     ''' + pagination
@@ -467,12 +473,21 @@ def _graph_node(
     status, basis, confidence, confirmation_explicit = _confirmation_projection(
         record
     )
+    attributes = json_object(record.get('attributes_json'))
     return GraphNode(
         id=record['id'],
         name=record['name'],
         type=record['type'],
         group_id=record['group_id'],
         summary=record['summary'],
+        key=record.get('key') or record['id'],
+        preference_key=(
+            attributes.get('preferenceKey')
+            or attributes.get('preference_key')
+            or record.get('key')
+            or record['id']
+        ),
+        preference_qualifiers=preference_qualifiers(attributes),
         origin_quadrant=record.get('origin_quadrant') or 'known_known',
         current_quadrant=record.get('current_quadrant') or 'known_known',
         epistemic_status=record.get('epistemic_status') or 'confirmed',
@@ -510,7 +525,7 @@ def _graph_node(
         last_feedback_kind=record.get('last_feedback_kind'),
         last_feedback_at=_native_datetime(record.get('last_feedback_at')),
         usage_generation=int(record.get('usage_generation') or 1),
-        attributes=json_object(record.get('attributes_json')),
+        attributes=attributes,
         evidence=[evidence[item] for item in episode_ids if item in evidence],
         created_at=_native_datetime(record.get('created_at')),
         invalid_at=_native_datetime(record.get('invalid_at')),
@@ -537,6 +552,7 @@ def _graph_edge(
     status, basis, confidence, confirmation_explicit = _confirmation_projection(
         record
     )
+    attributes = json_object(record.get('attributes_json'))
     return GraphEdge(
         id=record['id'],
         source=record['source'],
@@ -545,6 +561,14 @@ def _graph_edge(
         target_name=record.get('target_name'),
         type=record['type'],
         fact=record['fact'],
+        key=record.get('key') or record['id'],
+        preference_key=(
+            attributes.get('preferenceKey')
+            or attributes.get('preference_key')
+            or record.get('key')
+            or record['id']
+        ),
+        preference_qualifiers=preference_qualifiers(attributes),
         origin_quadrant=record.get('origin_quadrant') or 'known_known',
         current_quadrant=record.get('current_quadrant') or 'known_known',
         epistemic_status=record.get('epistemic_status') or 'confirmed',
@@ -588,7 +612,7 @@ def _graph_edge(
         replaced_by_item_kind=record.get('replaced_by_item_kind'),
         created_at=_native_datetime(record.get('created_at')),
         confidence=record.get('confidence'),
-        attributes=json_object(record.get('attributes_json')),
+        attributes=attributes,
         episodes=episode_ids,
         evidence=[evidence[item] for item in episode_ids if item in evidence],
         revisions=revisions.get(record['id'], []),

package/graph-provider/fuli_graph/knowledge_management.py

@@ -280,6 +280,21 @@ async def set_preference_scope(
             detail='only personal profile knowledge has a preference scope',
         )
 
+    current_scope = current.get('preference_scope') or 'global'
+    if not (
+        current_scope == 'global'
+        and request.scope == 'project'
+        and request.project_id
+    ):
+        raise HTTPException(
+            status_code=403,
+            detail=(
+                'direct preference scope changes may only narrow a global '
+                'preference to one project; broader or lateral scope changes '
+                'require the independently reviewed convergence workflow'
+            ),
+        )
+
     previous = _snapshot(current, request.item_kind)
     next_value = {
         **previous,
@@ -332,7 +347,10 @@ async def set_preference_scope(
         created_by=actor['id'],
         created_at=created_at,
     )
-    if request.operation_actor == 'human':
+    if (
+        request.operation_actor == 'human'
+        and actor.get('_human_review_verified') is True
+    ):
         await record_human_change(
             store,
             actor,

package/graph-provider/fuli_graph/knowledge_search.py

@@ -10,6 +10,7 @@ from .provider_values import (
     json_object,
     native_datetime as _native_datetime,
     normalized_text as _normalized,
+    preference_qualifiers,
 )
 from .search_projection import (
     effective_confirmation_status,
@@ -255,6 +256,8 @@ async def personal_project_scopes(
         WHERE all(
           relation IN relationships(path)
           WHERE relation.relation_type IN ['PART_OF', 'USES_KNOWLEDGE_FROM']
+            AND relation.status = 'active'
+            AND relation.confirmation_authority = 'human_review'
         )
           AND EXISTS {
             MATCH (space)-[:CONTAINS_PROJECT]->(source)
@@ -634,6 +637,14 @@ def _dedupe_ranked_entities(ranked, active_project_id):
 
 def _entity_search_result(record, score: float, space_id: str) -> EntitySearchResult:
     value = dict(record)
+    attributes = json_object(value.get('attributes_json'))
+    value['preference_key'] = (
+        attributes.get('preferenceKey')
+        or attributes.get('preference_key')
+        or value.get('key')
+        or value.get('id')
+    )
+    value['preference_qualifiers'] = preference_qualifiers(attributes)
     basis = json_object(value.pop('confirmation_basis_json', None))
     source_references = value.pop('source_references', [])
     created_at = _native_datetime(value.pop('created_at', None))