fuli-context 0.3.0 → 0.5.0

package/dist/web/index.html

@@ -9,12 +9,11 @@
     />
     <link rel="icon" type="image/png" href="/assets/fuli-logo-DGuyqchQ.png" />
     <title>复利 · Context Graph</title>
-    <script type="module" crossorigin src="/assets/index-DwUDhQKc.js"></script>
-    <link rel="modulepreload" crossorigin href="/assets/console-tbvTUi6p.js">
-    <link rel="modulepreload" crossorigin href="/assets/runtime-dom.esm-bundler-DttsK21F.js">
-    <link rel="modulepreload" crossorigin href="/assets/paths-B790iniO.js">
-    <link rel="modulepreload" crossorigin href="/assets/vue-router-BYTAoWT3.js">
-    <link rel="stylesheet" crossorigin href="/assets/index-Devf7glZ.css">
+    <script type="module" crossorigin src="/assets/index-DAzeFJSc.js"></script>
+    <link rel="modulepreload" crossorigin href="/assets/console-B_Ena2DS.js">
+    <link rel="modulepreload" crossorigin href="/assets/paths-BkULqmGI.js">
+    <link rel="modulepreload" crossorigin href="/assets/vue-router-DnD3hUm7.js">
+    <link rel="stylesheet" crossorigin href="/assets/index-CpLDx3of.css">
   </head>
   <body>
     <div id="app"></div>

package/graph-provider/fuli_graph/app.py

@@ -7,6 +7,15 @@ from .auth import matches_bootstrap_token
 from .config import Settings, get_settings
 from .graph_models import GraphResult
 from .knowledge_usage_models import KnowledgeUsageCreate, KnowledgeUsageResult
+from .knowledge_feedback_models import (
+    KnowledgeFeedbackCreate,
+    KnowledgeFeedbackResult,
+)
+from .common_knowledge_models import (
+    CommonKnowledgePromotionPreview,
+    CommonKnowledgePromotionRequest,
+    CommonKnowledgePromotionResult,
+)
 from .project_action_models import (
     KnowledgeProjectActionRequest,
     KnowledgeProjectActionResult,
@@ -63,11 +72,16 @@ from .models import (
 )
 from .knowledge_audit import (
     record_agent_views,
+    record_knowledge_feedback,
     record_knowledge_usage,
     review_human_change,
     search_human_changes,
 )
 from .knowledge_batch_confirmation import confirm_knowledge_batch
+from .common_knowledge import (
+    apply_common_knowledge_promotion,
+    preview_common_knowledge_promotion,
+)
 from .knowledge_management import (
     reassign_knowledge_item,
     revise_knowledge_item,
@@ -339,6 +353,16 @@ def create_app(settings: Settings | None = None) -> FastAPI:
     ) -> KnowledgeUsageResult:
         return await record_knowledge_usage(store, actor, request)
 
+    @application.post(
+        '/v1/knowledge/feedback',
+        response_model=KnowledgeFeedbackResult,
+    )
+    async def record_negative_knowledge_evidence(
+        request: KnowledgeFeedbackCreate,
+        actor: Actor,
+    ) -> KnowledgeFeedbackResult:
+        return await record_knowledge_feedback(store, actor, request)
+
     @application.post(
         '/v1/knowledge/items/{item_id}/agent-review',
         response_model=KnowledgeAuditRecord,
@@ -392,6 +416,30 @@ def create_app(settings: Settings | None = None) -> FastAPI:
     ) -> KnowledgeRevisionRecord:
         return await set_preference_scope(store, actor, item_id, request)
 
+    @application.post(
+        '/v1/knowledge/common-promotions/preview',
+        response_model=CommonKnowledgePromotionPreview,
+    )
+    async def preview_common_promotion(
+        request: CommonKnowledgePromotionRequest,
+        actor: Actor,
+    ) -> CommonKnowledgePromotionPreview:
+        return await preview_common_knowledge_promotion(
+            store, actor, request
+        )
+
+    @application.post(
+        '/v1/knowledge/common-promotions',
+        response_model=CommonKnowledgePromotionResult,
+    )
+    async def apply_common_promotion(
+        request: CommonKnowledgePromotionRequest,
+        actor: Actor,
+    ) -> CommonKnowledgePromotionResult:
+        return await apply_common_knowledge_promotion(
+            store, actor, request
+        )
+
     @application.post(
         '/v1/preference-conflicts/defer',
         response_model=PreferenceConflictRecord,

package/graph-provider/fuli_graph/common_knowledge.py

@@ -0,0 +1,443 @@
+import json
+from dataclasses import dataclass
+from datetime import datetime, timezone
+
+from fastapi import HTTPException
+
+from .common_knowledge_models import (
+    CommonKnowledgePromotionPreview,
+    CommonKnowledgePromotionRequest,
+    CommonKnowledgePromotionResult,
+)
+from .knowledge_management import (
+    _read_assignment,
+    _read_item,
+    _snapshot,
+    _implicit_project_id,
+)
+from .personal_project_access import authorize_personal_project
+from .provider_values import stable_uuid
+
+
+@dataclass(frozen=True)
+class _PromotionItem:
+    item_id: str
+    project_id: str
+    previous: dict
+
+
+@dataclass(frozen=True)
+class _PromotionPlan:
+    space: dict
+    canonical: _PromotionItem
+    duplicates: list[_PromotionItem]
+
+    @property
+    def source_project_ids(self) -> list[str]:
+        return sorted([
+            self.canonical.project_id,
+            *(item.project_id for item in self.duplicates),
+        ])
+
+
+async def preview_common_knowledge_promotion(
+    store,
+    actor: dict,
+    request: CommonKnowledgePromotionRequest,
+) -> CommonKnowledgePromotionPreview:
+    plan = await _promotion_plan(store, actor, request)
+    return CommonKnowledgePromotionPreview(
+        status='ready',
+        personal_space_id=request.personal_space_id,
+        parent_project_id=request.parent_project_id,
+        item_kind=request.item_kind,
+        canonical_item_id=request.canonical_item_id,
+        duplicate_item_ids=sorted(request.duplicate_item_ids),
+        source_project_ids=plan.source_project_ids,
+        reason=request.reason,
+        human_confirmation_reason=request.human_confirmation_reason,
+    )
+
+
+async def apply_common_knowledge_promotion(
+    store,
+    actor: dict,
+    request: CommonKnowledgePromotionRequest,
+    *,
+    changed_at: datetime | None = None,
+) -> CommonKnowledgePromotionResult:
+    plan = await _promotion_plan(store, actor, request)
+    promoted_at = changed_at or datetime.now(timezone.utc)
+    promotion_id = stable_uuid(
+        request.personal_space_id,
+        'common-knowledge-promotion',
+        request.parent_project_id,
+        request.item_kind,
+        request.canonical_item_id,
+        promoted_at.isoformat(),
+    )
+    assignment_id = stable_uuid(
+        request.personal_space_id,
+        'knowledge-assignment',
+        request.item_kind,
+        request.canonical_item_id,
+    )
+    canonical_current = {
+        **plan.canonical.previous,
+        'inheritanceMode': 'descendants',
+        'inheritedProjectIds': [],
+    }
+    revision_specs = [{
+        'revision_id': stable_uuid(
+            promotion_id, 'revision', request.canonical_item_id
+        ),
+        'item_id': request.canonical_item_id,
+        'action': 'promote_common',
+        'previous_json': _json(plan.canonical.previous),
+        'current_json': _json(canonical_current),
+    }]
+    duplicate_specs = []
+    for duplicate in plan.duplicates:
+        current = {
+            **duplicate.previous,
+            'invalidAt': promoted_at.isoformat(),
+            'replacedByItemId': request.canonical_item_id,
+            'replacedByItemKind': request.item_kind,
+        }
+        revision_specs.append({
+            'revision_id': stable_uuid(
+                promotion_id, 'revision', duplicate.item_id
+            ),
+            'item_id': duplicate.item_id,
+            'action': 'replace_common_duplicate',
+            'previous_json': _json(duplicate.previous),
+            'current_json': _json(current),
+        })
+        duplicate_specs.append({
+            'item_id': duplicate.item_id,
+            'project_id': duplicate.project_id,
+        })
+
+    query = _promotion_query(request.item_kind)
+    records, _, _ = await store.runtime.driver.execute_query(
+        query,
+        space_id=request.personal_space_id,
+        group_id=plan.space['group_id'],
+        parent_project_id=request.parent_project_id,
+        source_project_ids=plan.source_project_ids,
+        canonical_item_id=request.canonical_item_id,
+        canonical_source_project_id=plan.canonical.project_id,
+        duplicate_specs=duplicate_specs,
+        item_kind=request.item_kind,
+        assignment_id=assignment_id,
+        promotion_id=promotion_id,
+        revision_specs=revision_specs,
+        reason=request.reason,
+        human_confirmation_reason=request.human_confirmation_reason,
+        changed_by=actor['id'],
+        operation_actor=request.operation_actor,
+        changed_at=promoted_at,
+    )
+    if not records:
+        raise HTTPException(
+            status_code=409,
+            detail='common knowledge changed after preview; review it again',
+        )
+    record = records[0]
+    return CommonKnowledgePromotionResult(
+        status='promoted',
+        promotion_id=record.get('promotion_id') or promotion_id,
+        personal_space_id=request.personal_space_id,
+        parent_project_id=request.parent_project_id,
+        item_kind=request.item_kind,
+        canonical_item_id=request.canonical_item_id,
+        invalidated_item_ids=sorted(request.duplicate_item_ids),
+        source_project_ids=plan.source_project_ids,
+        revision_ids=record.get('revision_ids') or [
+            item['revision_id'] for item in revision_specs
+        ],
+        reason=request.reason,
+        human_confirmation_reason=request.human_confirmation_reason,
+    )
+
+
+async def _promotion_plan(store, actor, request) -> _PromotionPlan:
+    store._require_personal()
+    space = await store.authorize(
+        actor, request.personal_space_id, 'maintainer'
+    )
+    if space['kind'] != 'personal':
+        raise HTTPException(
+            status_code=422,
+            detail='common knowledge promotion is personal-only',
+        )
+    await authorize_personal_project(
+        store, actor, space, request.parent_project_id
+    )
+    direct_child_ids = await _direct_child_project_ids(
+        store, space['id'], request.parent_project_id
+    )
+    item_ids = [request.canonical_item_id, *request.duplicate_item_ids]
+    items = []
+    for item_id in item_ids:
+        value = await _read_item(store, space, item_id, request.item_kind)
+        if value is None:
+            raise HTTPException(status_code=404, detail='knowledge item not found')
+        if value.get('profile_aspect'):
+            raise HTTPException(
+                status_code=422,
+                detail='personal profile knowledge cannot become common project knowledge',
+            )
+        if value.get('invalid_at'):
+            raise HTTPException(
+                status_code=409,
+                detail='historical knowledge cannot be promoted as common knowledge',
+            )
+        project_id = await _item_project_id(
+            store, space, item_id, request.item_kind
+        )
+        if project_id not in direct_child_ids:
+            raise HTTPException(
+                status_code=422,
+                detail='every promoted item must belong to a direct PART_OF child',
+            )
+        items.append(_PromotionItem(
+            item_id=item_id,
+            project_id=project_id,
+            previous=_snapshot(value, request.item_kind),
+        ))
+    project_ids = [item.project_id for item in items]
+    if len(set(project_ids)) != len(project_ids):
+        raise HTTPException(
+            status_code=422,
+            detail='common knowledge evidence must come from distinct child projects',
+        )
+    return _PromotionPlan(
+        space=space,
+        canonical=items[0],
+        duplicates=items[1:],
+    )
+
+
+async def _direct_child_project_ids(store, space_id, parent_project_id):
+    records, _, _ = await store.runtime.driver.execute_query(
+        '''
+        MATCH (:FuliSpace {id: $space_id, kind: 'personal'})-
+              [:CONTAINS_PROJECT]->(child:FuliPersonalProject)-
+              [:PERSONAL_PROJECT_RELATION {relation_type: 'PART_OF'}]->
+              (parent:FuliPersonalProject {project_id: $parent_project_id})
+        RETURN child.project_id AS child_project_id
+        ORDER BY child.project_id
+        ''',
+        space_id=space_id,
+        parent_project_id=parent_project_id,
+        routing_='r',
+    )
+    return {record['child_project_id'] for record in records}
+
+
+async def _item_project_id(store, space, item_id, item_kind):
+    assignment = await _read_assignment(
+        store, space['id'], item_id, item_kind
+    )
+    if assignment:
+        return assignment.project_id
+    return await _implicit_project_id(store, space, item_id, item_kind)
+
+
+def _promotion_query(item_kind):
+    canonical_project_guard = _current_project_guard(
+        item_kind,
+        item_variable='canonical',
+        variable_prefix='canonical',
+        item_id_expression='$canonical_item_id',
+        project_id_expression='$canonical_source_project_id',
+    )
+    duplicate_project_guard = _current_project_guard(
+        item_kind,
+        item_variable='duplicate',
+        variable_prefix='duplicate',
+        item_id_expression='duplicate_spec.item_id',
+        project_id_expression='duplicate_spec.project_id',
+    )
+    if item_kind == 'entity':
+        canonical_match = f'''
+        MATCH (canonical:Entity {{
+          uuid: $canonical_item_id,
+          group_id: $group_id
+        }})
+        WHERE canonical.fuli_invalid_at IS NULL
+        {canonical_project_guard}
+        '''
+        duplicate_match = f'''
+        MATCH (duplicate:Entity {{
+          uuid: duplicate_spec.item_id,
+          group_id: $group_id
+        }})
+        WHERE duplicate.fuli_invalid_at IS NULL
+        {duplicate_project_guard}
+        '''
+        duplicate_update = '''
+        FOREACH (pair IN duplicate_pairs |
+          SET pair.item.fuli_invalid_at = $changed_at,
+              pair.item.fuli_replaced_by_item_id = $canonical_item_id,
+              pair.item.fuli_replaced_by_item_kind = $item_kind
+        )
+        '''
+    else:
+        canonical_match = f'''
+        MATCH ()-[canonical:RELATES_TO {{
+          uuid: $canonical_item_id,
+          group_id: $group_id
+        }}]->()
+        WHERE canonical.invalid_at IS NULL
+        {canonical_project_guard}
+        '''
+        duplicate_match = f'''
+        MATCH ()-[duplicate:RELATES_TO {{
+          uuid: duplicate_spec.item_id,
+          group_id: $group_id
+        }}]->()
+        WHERE duplicate.invalid_at IS NULL
+        {duplicate_project_guard}
+        '''
+        duplicate_update = '''
+        FOREACH (pair IN duplicate_pairs |
+          SET pair.item.invalid_at = $changed_at,
+              pair.item.fuli_replaced_by_item_id = $canonical_item_id,
+              pair.item.fuli_replaced_by_item_kind = $item_kind
+        )
+        '''
+    return f'''
+        MATCH (space:FuliSpace {{id: $space_id, kind: 'personal'}})-
+              [:CONTAINS_PROJECT]->
+              (parent:FuliPersonalProject {{project_id: $parent_project_id}})
+        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'}}]->
+              (parent)
+        WITH space, parent, collect(DISTINCT child.project_id) AS direct_children
+        WHERE size(direct_children) = size($source_project_ids)
+        {canonical_match}
+        WITH space, parent, canonical, direct_children
+        UNWIND $duplicate_specs AS duplicate_spec
+        {duplicate_match}
+        WITH space, parent, canonical, direct_children,
+             collect({{item: duplicate, spec: duplicate_spec}}) AS duplicate_pairs
+        WHERE size(duplicate_pairs) = size($duplicate_specs)
+        SET canonical.fuli_inheritance_mode = 'descendants',
+            canonical.fuli_inherited_project_ids = []
+        {duplicate_update}
+        MERGE (assignment:FuliKnowledgeAssignment {{
+          space_id: $space_id,
+          item_kind: $item_kind,
+          item_id: $canonical_item_id
+        }})
+        ON CREATE SET assignment.id = $assignment_id,
+                      assignment.created_at = $changed_at
+        SET assignment.previous_project_id = $canonical_source_project_id,
+            assignment.project_id = $parent_project_id,
+            assignment.reason = $reason,
+            assignment.changed_by = $changed_by,
+            assignment.updated_at = $changed_at
+        WITH space, parent, assignment
+        OPTIONAL MATCH (assignment)-[old:ASSIGNED_TO]->
+                       (:FuliPersonalProject)
+        DELETE old
+        MERGE (assignment)-[:ASSIGNED_TO]->(parent)
+        MERGE (space)-[:HAS_KNOWLEDGE_ASSIGNMENT]->(assignment)
+        CREATE (promotion:FuliCommonKnowledgePromotion {{
+          id: $promotion_id,
+          space_id: $space_id,
+          parent_project_id: $parent_project_id,
+          item_kind: $item_kind,
+          canonical_item_id: $canonical_item_id,
+          duplicate_item_ids: [item IN $duplicate_specs | item.item_id],
+          source_project_ids: $source_project_ids,
+          reason: $reason,
+          human_confirmation_reason: $human_confirmation_reason,
+          operation_actor: $operation_actor,
+          created_by: $changed_by,
+          created_at: $changed_at
+        }})
+        MERGE (space)-[:HAS_COMMON_KNOWLEDGE_PROMOTION]->(promotion)
+        WITH promotion, assignment, space
+        UNWIND $revision_specs AS revision_spec
+        CREATE (revision:FuliKnowledgeRevision {{
+          id: revision_spec.revision_id,
+          space_id: $space_id,
+          item_id: revision_spec.item_id,
+          item_kind: $item_kind,
+          action: revision_spec.action,
+          reason: $reason,
+          previous_json: revision_spec.previous_json,
+          current_json: revision_spec.current_json,
+          created_by: $changed_by,
+          created_at: $changed_at
+        }})
+        MERGE (space)-[:HAS_KNOWLEDGE_REVISION]->(revision)
+        RETURN promotion.id AS promotion_id,
+               assignment.id AS assignment_id,
+               collect(revision.id) AS revision_ids
+    '''
+
+
+def _current_project_guard(
+    item_kind,
+    *,
+    item_variable,
+    variable_prefix,
+    item_id_expression,
+    project_id_expression,
+):
+    if item_kind == 'entity':
+        implicit_project_match = f'''
+          MATCH ({variable_prefix}_episode:Episodic {{group_id: $group_id}})-
+                [:MENTIONS]->({item_variable})
+        '''
+    else:
+        implicit_project_match = f'''
+          UNWIND coalesce({item_variable}.episodes, [])
+                 AS {variable_prefix}_episode_id
+          MATCH ({variable_prefix}_episode:Episodic {{
+            uuid: {variable_prefix}_episode_id,
+            group_id: $group_id
+          }})
+        '''
+    return f'''
+        AND (
+          EXISTS {{
+            MATCH (space)-[:HAS_KNOWLEDGE_ASSIGNMENT]->
+                  ({variable_prefix}_assignment:FuliKnowledgeAssignment {{
+                    item_kind: $item_kind,
+                    item_id: {item_id_expression}
+                  }})
+            WHERE {variable_prefix}_assignment.project_id = {project_id_expression}
+          }}
+          OR (
+            NOT EXISTS {{
+              MATCH (space)-[:HAS_KNOWLEDGE_ASSIGNMENT]->
+                    (:FuliKnowledgeAssignment {{
+                      item_kind: $item_kind,
+                      item_id: {item_id_expression}
+                    }})
+            }}
+            AND EXISTS {{
+              {implicit_project_match}
+              WHERE {variable_prefix}_episode.fuli_personal_project_id
+                    IS NOT NULL
+              WITH collect(DISTINCT
+                     {variable_prefix}_episode.fuli_personal_project_id)
+                   AS {variable_prefix}_project_ids
+              WHERE {variable_prefix}_project_ids =
+                    [{project_id_expression}]
+              RETURN {variable_prefix}_project_ids
+            }}
+          )
+        )
+    '''
+
+
+def _json(value):
+    return json.dumps(value, ensure_ascii=False, sort_keys=True)

package/graph-provider/fuli_graph/common_knowledge_models.py

@@ -0,0 +1,54 @@
+from typing import Literal
+
+from pydantic import Field, model_validator
+
+from .models import KnowledgeItemKind, KnowledgeOperationActor, StrictModel
+
+
+class CommonKnowledgePromotionRequest(StrictModel):
+    personal_space_id: str = Field(min_length=1, max_length=128)
+    parent_project_id: str = Field(min_length=1, max_length=128)
+    item_kind: KnowledgeItemKind
+    canonical_item_id: str = Field(min_length=1, max_length=256)
+    duplicate_item_ids: list[str] = Field(min_length=1, max_length=31)
+    reason: str = Field(min_length=1, max_length=2000)
+    human_confirmation_reason: str = Field(min_length=1, max_length=2000)
+    operation_actor: KnowledgeOperationActor = 'agent'
+
+    @model_validator(mode='after')
+    def validate_item_ids(self):
+        if len(set(self.duplicate_item_ids)) != len(self.duplicate_item_ids):
+            raise ValueError('duplicate item ids must be unique')
+        if self.canonical_item_id in self.duplicate_item_ids:
+            raise ValueError('canonical item cannot also be a duplicate')
+        return self
+
+
+class CommonKnowledgePromotionPreview(StrictModel):
+    status: Literal['ready']
+    personal_space_id: str
+    parent_project_id: str
+    item_kind: KnowledgeItemKind
+    canonical_item_id: str
+    duplicate_item_ids: list[str]
+    source_project_ids: list[str]
+    inheritance_mode: Literal['descendants'] = 'descendants'
+    atomic: bool = True
+    requires_human_confirmation: bool = True
+    reason: str
+    human_confirmation_reason: str
+
+
+class CommonKnowledgePromotionResult(StrictModel):
+    status: Literal['promoted']
+    promotion_id: str
+    personal_space_id: str
+    parent_project_id: str
+    item_kind: KnowledgeItemKind
+    canonical_item_id: str
+    invalidated_item_ids: list[str]
+    source_project_ids: list[str]
+    inheritance_mode: Literal['descendants'] = 'descendants'
+    revision_ids: list[str]
+    reason: str
+    human_confirmation_reason: str

package/graph-provider/fuli_graph/graph_models.py

@@ -13,6 +13,7 @@ from .models import (
     KnowledgeAssignmentRecord,
     KnowledgeAuditRecord,
     KnowledgeInheritanceMode,
+    KnowledgeFeedbackKind,
     KnowledgeItemKind,
     KnowledgeRevisionRecord,
     PersonalProfileAspect,
@@ -55,6 +56,10 @@ class GraphNode(StrictModel):
     qualified_use_count: int = Field(default=0, ge=0)
     distinct_task_count: int = Field(default=0, ge=0)
     last_used_at: datetime | None = None
+    negative_evidence_count: int = Field(default=0, ge=0)
+    requires_attention: bool = False
+    last_feedback_kind: KnowledgeFeedbackKind | None = None
+    last_feedback_at: datetime | None = None
     usage_generation: int = Field(default=1, ge=1)
     attributes: dict[str, Any] = Field(default_factory=dict)
     evidence: list[GraphEvidence] = Field(default_factory=list)
@@ -99,6 +104,10 @@ class GraphEdge(StrictModel):
     qualified_use_count: int = Field(default=0, ge=0)
     distinct_task_count: int = Field(default=0, ge=0)
     last_used_at: datetime | None = None
+    negative_evidence_count: int = Field(default=0, ge=0)
+    requires_attention: bool = False
+    last_feedback_kind: KnowledgeFeedbackKind | None = None
+    last_feedback_at: datetime | None = None
     usage_generation: int = Field(default=1, ge=1)
     valid_at: datetime | None
     invalid_at: datetime | None

package/graph-provider/fuli_graph/graph_query.py

@@ -220,6 +220,12 @@ def _node_query(project_scoped: bool) -> str:
                coalesce(node.fuli_distinct_task_count, 0)
                  AS distinct_task_count,
                node.fuli_last_used_at AS last_used_at,
+               coalesce(node.fuli_negative_evidence_count, 0)
+                 AS negative_evidence_count,
+               coalesce(node.fuli_requires_attention, false)
+                 AS requires_attention,
+               node.fuli_last_feedback_kind AS last_feedback_kind,
+               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,
                [episode IN episodes WHERE episode IS NOT NULL | episode.uuid] AS episodes,
@@ -295,6 +301,12 @@ def _edge_query(project_scoped: bool) -> str:
                coalesce(edge.fuli_distinct_task_count, 0)
                  AS distinct_task_count,
                edge.fuli_last_used_at AS last_used_at,
+               coalesce(edge.fuli_negative_evidence_count, 0)
+                 AS negative_evidence_count,
+               coalesce(edge.fuli_requires_attention, false)
+                 AS requires_attention,
+               edge.fuli_last_feedback_kind AS last_feedback_kind,
+               edge.fuli_last_feedback_at AS last_feedback_at,
                coalesce(edge.fuli_usage_generation, 1) AS usage_generation,
                edge.valid_at AS valid_at, edge.invalid_at AS invalid_at,
                edge.fuli_replaced_by_item_id AS replaced_by_item_id,
@@ -331,6 +343,7 @@ async def _read_evidence(store, episode_ids: list[str]) -> dict[str, GraphEviden
         RETURN episode.uuid AS id, episode.name AS name,
                episode.source_description AS source_description,
                coalesce(episode.fuli_source_kind, 'unknown') AS source_kind,
+               episode.fuli_source_uri AS source_uri,
                coalesce(episode.fuli_summary, '') AS summary,
                episode.fuli_session_id AS session_id,
                episode.fuli_source_application AS source_application,
@@ -446,6 +459,12 @@ def _graph_node(
         qualified_use_count=int(record.get('qualified_use_count') or 0),
         distinct_task_count=int(record.get('distinct_task_count') or 0),
         last_used_at=_native_datetime(record.get('last_used_at')),
+        negative_evidence_count=int(
+            record.get('negative_evidence_count') or 0
+        ),
+        requires_attention=record.get('requires_attention') is True,
+        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')),
         evidence=[evidence[item] for item in episode_ids if item in evidence],
@@ -510,6 +529,12 @@ def _graph_edge(
         qualified_use_count=int(record.get('qualified_use_count') or 0),
         distinct_task_count=int(record.get('distinct_task_count') or 0),
         last_used_at=_native_datetime(record.get('last_used_at')),
+        negative_evidence_count=int(
+            record.get('negative_evidence_count') or 0
+        ),
+        requires_attention=record.get('requires_attention') is True,
+        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),
         valid_at=_native_datetime(record.get('valid_at')),
         invalid_at=_native_datetime(record.get('invalid_at')),