fuli-context 0.2.0 → 0.4.0

package/graph-provider/fuli_graph/knowledge_audit.py

@@ -9,6 +9,11 @@ from .knowledge_usage_models import (
     KnowledgeUsageItemResult,
     KnowledgeUsageResult,
 )
+from .knowledge_feedback_models import (
+    KnowledgeFeedbackCreate,
+    KnowledgeFeedbackItemResult,
+    KnowledgeFeedbackResult,
+)
 from .models import (
     KnowledgeAgentReviewCreate,
     KnowledgeAgentViewCreate,
@@ -29,6 +34,12 @@ USAGE_WEIGHTS = {
     'cited': (0.12, 0.04),
     'applied': (0.18, 0.06),
 }
+NEGATIVE_EVIDENCE_WEIGHTS = {
+    'rejected': (0.35, 0.25),
+    'validation_failed': (0.35, 0.30),
+    'contradicted': (0.45, 0.40),
+    'outdated': (0.20, 0.20),
+}
 
 
 async def record_human_change(
@@ -147,6 +158,130 @@ async def record_knowledge_usage(
     )
 
 
+async def record_knowledge_feedback(
+    store,
+    actor: dict,
+    request: KnowledgeFeedbackCreate,
+) -> KnowledgeFeedbackResult:
+    """Record bounded negative evidence without overriding human authority."""
+    store._require_personal()
+    space = await store.authorize(actor, request.personal_space_id, 'maintainer')
+    if space['kind'] != 'personal':
+        raise HTTPException(status_code=422, detail='knowledge feedback is personal-only')
+
+    lock = store._group_locks.setdefault(space['group_id'], asyncio.Lock())
+    results = []
+    async with lock:
+        for item in request.items:
+            results.append(await _record_one_knowledge_feedback(
+                store, actor, space, request, item
+            ))
+    return KnowledgeFeedbackResult(
+        recorded_count=sum(result.recorded for result in results),
+        duplicate_count=sum(not result.recorded for result in results),
+        items=results,
+    )
+
+
+async def _record_one_knowledge_feedback(store, actor, space, request, item):
+    state = await _read_usage_state(
+        store, space, item.item_id, item.item_kind
+    )
+    if state is None:
+        raise HTTPException(status_code=404, detail='knowledge item not found')
+    if state.get('invalid_at') is not None:
+        raise HTTPException(
+            status_code=409,
+            detail='historical knowledge cannot receive new feedback evidence',
+        )
+    generation = int(state.get('usage_generation') or 1)
+    previous_status = state.get('confirmation_status') or 'pending'
+    trusted_reporter = item.reported_by_kind in {
+        'user', 'authoritative_source'
+    }
+    next_status = (
+        'pending'
+        if previous_status == 'agent_confirmed' and trusted_reporter
+        else previous_status
+    )
+    basis = json_object(state.get('confirmation_basis_json'))
+    if next_status == 'pending' and previous_status == 'agent_confirmed':
+        basis = _pending_feedback_basis(basis, item.reason)
+    utility_weight, confidence_weight = NEGATIVE_EVIDENCE_WEIGHTS[
+        item.feedback_kind
+    ]
+    utility_score = round(max(
+        0.0,
+        float(state.get('utility_score') or 0) - utility_weight,
+    ), 4)
+    confidence_score = round(max(
+        0.0,
+        float(
+            state['confidence_score']
+            if state.get('confidence_score') is not None else 0.5
+        ) - confidence_weight,
+    ), 4)
+    feedback_at = datetime.now(timezone.utc)
+    audit_id = stable_uuid(
+        space['id'],
+        'knowledge-feedback',
+        item.item_kind,
+        item.item_id,
+        str(generation),
+        request.task_id,
+        item.feedback_kind,
+    )
+    records, _, _ = await store.runtime.driver.execute_query(
+        _knowledge_feedback_query(item.item_kind),
+        space_id=space['id'],
+        group_id=space['group_id'],
+        item_id=item.item_id,
+        item_kind=item.item_kind,
+        audit_id=audit_id,
+        task_id=request.task_id,
+        session_id=request.session_id,
+        tool_name=request.tool_name,
+        feedback_kind=item.feedback_kind,
+        reported_by_kind=item.reported_by_kind,
+        reason=item.reason,
+        evidence_summary=item.evidence_summary,
+        source_uri=item.source_uri,
+        usage_generation=generation,
+        next_confirmation_status=next_status,
+        next_confirmation_basis_json=(
+            json.dumps(basis, ensure_ascii=False, sort_keys=True)
+            if basis else None
+        ),
+        utility_score=utility_score,
+        confidence_score=confidence_score,
+        created_by=actor['id'],
+        feedback_at=feedback_at,
+    )
+    if not records:
+        raise HTTPException(
+            status_code=409,
+            detail='knowledge changed while feedback evidence was recorded; retry',
+        )
+    record = dict(records[0])
+    return KnowledgeFeedbackItemResult(
+        item_id=item.item_id,
+        item_kind=item.item_kind,
+        feedback_kind=item.feedback_kind,
+        recorded=record.get('recorded') is True,
+        confirmation_status=record.get('confirmation_status') or next_status,
+        utility_score=float(record.get('utility_score') or 0),
+        confidence_score=float(
+            record['confidence_score']
+            if record.get('confidence_score') is not None else 0.5
+        ),
+        negative_evidence_count=int(
+            record.get('negative_evidence_count') or 0
+        ),
+        requires_attention=record.get('requires_attention') is True,
+        usage_generation=generation,
+    )
+
+
 async def _record_one_knowledge_use(store, actor, space, request, item):
     state = await _read_usage_state(
         store,
@@ -470,6 +605,10 @@ def _audit_record(value: dict) -> KnowledgeAuditRecord:
         task_id=value.get('task_id'),
         session_id=value.get('session_id'),
         use_kind=value.get('use_kind'),
+        feedback_kind=value.get('feedback_kind'),
+        reported_by_kind=value.get('reported_by_kind'),
+        evidence_summary=value.get('evidence_summary'),
+        source_uri=value.get('source_uri'),
         usage_generation=(
             int(value['usage_generation'])
             if value.get('usage_generation') is not None else None
@@ -592,6 +731,10 @@ async def _read_usage_state(store, space, item_id, item_kind):
                  AS confirmation_status,
                item.fuli_confirmation_basis_json AS confirmation_basis_json,
                coalesce(item.fuli_usage_generation, 1) AS usage_generation,
+               coalesce(item.fuli_utility_score, 0.0) AS utility_score,
+               coalesce(item.fuli_confidence_score, 0.5) AS confidence_score,
+               coalesce(item.fuli_negative_evidence_count, 0)
+                 AS negative_evidence_count,
                {
                  "item.fuli_invalid_at"
                  if item_kind == "entity" else "item.invalid_at"
@@ -649,6 +792,60 @@ def _knowledge_use_query(item_kind: str) -> str:
     '''
 
 
+def _knowledge_feedback_query(item_kind: str) -> str:
+    return f'''
+        MATCH (space:FuliSpace {{id: $space_id, kind: 'personal'}})
+        {_item_match(item_kind)}
+        WHERE coalesce(item.fuli_usage_generation, 1) = $usage_generation
+        MERGE (audit:FuliKnowledgeAudit {{id: $audit_id}})
+        ON CREATE SET audit.space_id = $space_id,
+                      audit.item_id = $item_id,
+                      audit.item_kind = $item_kind,
+                      audit.action = 'knowledge_feedback',
+                      audit.human_change_version = 0,
+                      audit.task_id = $task_id,
+                      audit.session_id = $session_id,
+                      audit.tool_name = $tool_name,
+                      audit.feedback_kind = $feedback_kind,
+                      audit.reported_by_kind = $reported_by_kind,
+                      audit.reason = $reason,
+                      audit.evidence_summary = $evidence_summary,
+                      audit.source_uri = $source_uri,
+                      audit.usage_generation = $usage_generation,
+                      audit.outcome = 'requires_attention',
+                      audit.created_by = $created_by,
+                      audit.created_at = $feedback_at
+        MERGE (space)-[:HAS_KNOWLEDGE_AUDIT]->(audit)
+        WITH item, audit, audit.created_at = $feedback_at AS recorded
+        FOREACH (_ IN CASE WHEN recorded THEN [1] ELSE [] END |
+          SET item.fuli_utility_score = $utility_score,
+              item.fuli_confidence_score = $confidence_score,
+              item.fuli_confirmation_status = $next_confirmation_status,
+              item.fuli_confirmation_basis_json =
+                $next_confirmation_basis_json,
+              item.fuli_epistemic_status =
+                CASE WHEN $next_confirmation_status = 'confirmed'
+                     THEN 'confirmed'
+                     WHEN item.fuli_origin_quadrant = 'unknown_unknown'
+                     THEN 'exploratory'
+                     ELSE 'observed' END,
+              item.fuli_negative_evidence_count =
+                coalesce(item.fuli_negative_evidence_count, 0) + 1,
+              item.fuli_requires_attention = true,
+              item.fuli_last_feedback_kind = $feedback_kind,
+              item.fuli_last_feedback_at = $feedback_at
+        )
+        RETURN recorded,
+               item.fuli_confirmation_status AS confirmation_status,
+               coalesce(item.fuli_utility_score, 0.0) AS utility_score,
+               coalesce(item.fuli_confidence_score, 0.5) AS confidence_score,
+               coalesce(item.fuli_negative_evidence_count, 0)
+                 AS negative_evidence_count,
+               coalesce(item.fuli_requires_attention, false)
+                 AS requires_attention
+    '''
+
+
 def _usage_score_update_query(item_kind: str) -> str:
     return f'''
         {_item_match(item_kind)}
@@ -698,6 +895,20 @@ def _agent_confirmation_basis(value: dict, confirmed_at: datetime) -> dict:
     }
 
 
+def _pending_feedback_basis(value: dict, reason: str) -> dict:
+    result = dict(value or {})
+    result.setdefault('existence_reason', reason)
+    result.setdefault(
+        'quadrant_reason',
+        'The immutable discovery quadrant is unchanged by negative evidence.',
+    )
+    result.setdefault('proposed_by', {'kind': 'agent', 'label': 'Fuli'})
+    result['confirmed_by'] = None
+    result['confirmed_at'] = None
+    result.pop('agent_policy_version', None)
+    return result
+
+
 _HUMAN_ENTITY_SEARCH = '''
 MATCH (item:Entity {group_id: $group_id})
 WHERE item.fuli_human_edited = true

package/graph-provider/fuli_graph/knowledge_feedback_models.py

@@ -0,0 +1,69 @@
+from typing import Literal
+
+from pydantic import Field, field_validator, model_validator
+
+from .models import (
+    ConfirmationStatus,
+    KnowledgeFeedbackKind,
+    KnowledgeItemKind,
+    StrictModel,
+    _validated_source_uri,
+)
+
+KnowledgeFeedbackReporterKind = Literal[
+    'user',
+    'agent',
+    'authoritative_source',
+]
+
+
+class KnowledgeFeedbackItem(StrictModel):
+    item_id: str = Field(min_length=1, max_length=256)
+    item_kind: KnowledgeItemKind
+    feedback_kind: KnowledgeFeedbackKind
+    reason: str = Field(min_length=1, max_length=2000)
+    evidence_summary: str = Field(min_length=1, max_length=4096)
+    reported_by_kind: KnowledgeFeedbackReporterKind
+    source_uri: str | None = Field(default=None, min_length=1, max_length=2048)
+
+    @field_validator('source_uri')
+    @classmethod
+    def validate_source_uri(cls, value):
+        return _validated_source_uri(value) if value is not None else None
+
+
+class KnowledgeFeedbackCreate(StrictModel):
+    personal_space_id: str = Field(min_length=1, max_length=128)
+    task_id: str = Field(min_length=1, max_length=256)
+    session_id: str | None = Field(default=None, min_length=1, max_length=256)
+    tool_name: str | None = Field(default=None, min_length=1, max_length=128)
+    items: list[KnowledgeFeedbackItem] = Field(min_length=1, max_length=200)
+
+    @model_validator(mode='after')
+    def validate_feedback_items(self):
+        identities = {
+            (item.item_kind, item.item_id, item.feedback_kind)
+            for item in self.items
+        }
+        if len(identities) != len(self.items):
+            raise ValueError('knowledge feedback items must be unique')
+        return self
+
+
+class KnowledgeFeedbackItemResult(StrictModel):
+    item_id: str
+    item_kind: KnowledgeItemKind
+    feedback_kind: KnowledgeFeedbackKind
+    recorded: bool
+    confirmation_status: ConfirmationStatus
+    utility_score: float = Field(ge=0, le=1)
+    confidence_score: float = Field(ge=0, le=1)
+    negative_evidence_count: int = Field(ge=0)
+    requires_attention: bool
+    usage_generation: int = Field(ge=1)
+
+
+class KnowledgeFeedbackResult(StrictModel):
+    recorded_count: int = Field(ge=0, le=200)
+    duplicate_count: int = Field(ge=0, le=200)
+    items: list[KnowledgeFeedbackItemResult] = Field(max_length=200)

package/graph-provider/fuli_graph/knowledge_management.py

@@ -390,6 +390,12 @@ async def _read_item(store, space: dict, item_id: str, item_kind: str):
                  AS distinct_task_count,
                item.fuli_last_used_at AS last_used_at,
                coalesce(item.fuli_usage_generation, 1) AS usage_generation,
+               coalesce(item.fuli_negative_evidence_count, 0)
+                 AS negative_evidence_count,
+               coalesce(item.fuli_requires_attention, false)
+                 AS requires_attention,
+               item.fuli_last_feedback_kind AS last_feedback_kind,
+               item.fuli_last_feedback_at AS last_feedback_at,
                item.fuli_replaced_by_item_id AS replaced_by_item_id,
                item.fuli_replaced_by_item_kind AS replaced_by_item_kind
         '''
@@ -426,6 +432,12 @@ async def _read_item(store, space: dict, item_id: str, item_kind: str):
                  AS distinct_task_count,
                item.fuli_last_used_at AS last_used_at,
                coalesce(item.fuli_usage_generation, 1) AS usage_generation,
+               coalesce(item.fuli_negative_evidence_count, 0)
+                 AS negative_evidence_count,
+               coalesce(item.fuli_requires_attention, false)
+                 AS requires_attention,
+               item.fuli_last_feedback_kind AS last_feedback_kind,
+               item.fuli_last_feedback_at AS last_feedback_at,
                item.fuli_replaced_by_item_id AS replaced_by_item_id,
                item.fuli_replaced_by_item_kind AS replaced_by_item_kind
         '''
@@ -525,6 +537,12 @@ def _snapshot(value: dict, item_kind: str) -> dict:
         'distinctTaskCount': int(value.get('distinct_task_count') or 0),
         'lastUsedAt': _iso(value.get('last_used_at')),
         'usageGeneration': int(value.get('usage_generation') or 1),
+        'negativeEvidenceCount': int(
+            value.get('negative_evidence_count') or 0
+        ),
+        'requiresAttention': value.get('requires_attention') is True,
+        'lastFeedbackKind': value.get('last_feedback_kind'),
+        'lastFeedbackAt': _iso(value.get('last_feedback_at')),
         'replacedByItemId': value.get('replaced_by_item_id'),
         'replacedByItemKind': value.get('replaced_by_item_kind'),
     }
@@ -610,6 +628,11 @@ def _next_snapshot(previous: dict, request: KnowledgeRevisionCreate, changed_at:
             value['qualifiedUseCount'] = 0
             value['distinctTaskCount'] = 0
             value['lastUsedAt'] = None
+        if content_changed or classification_changed:
+            value['negativeEvidenceCount'] = 0
+            value['requiresAttention'] = False
+            value['lastFeedbackKind'] = None
+            value['lastFeedbackAt'] = None
         if request.reasoning_summary is not None:
             value['reasoningSummary'] = request.reasoning_summary or None
         if request.profile_aspect is not None:
@@ -691,6 +714,10 @@ async def _update_item(store, space, item_id, item_kind, value, embedding):
             item.fuli_distinct_task_count = $distinct_task_count,
             item.fuli_last_used_at = $last_used_at,
             item.fuli_usage_generation = $usage_generation,
+            item.fuli_negative_evidence_count = $negative_evidence_count,
+            item.fuli_requires_attention = $requires_attention,
+            item.fuli_last_feedback_kind = $last_feedback_kind,
+            item.fuli_last_feedback_at = $last_feedback_at,
             item.fuli_replaced_by_item_id = $replaced_by_item_id,
             item.fuli_replaced_by_item_kind = $replaced_by_item_kind,
             item.name_embedding = coalesce($embedding, item.name_embedding)
@@ -718,6 +745,10 @@ async def _update_item(store, space, item_id, item_kind, value, embedding):
             item.fuli_distinct_task_count = $distinct_task_count,
             item.fuli_last_used_at = $last_used_at,
             item.fuli_usage_generation = $usage_generation,
+            item.fuli_negative_evidence_count = $negative_evidence_count,
+            item.fuli_requires_attention = $requires_attention,
+            item.fuli_last_feedback_kind = $last_feedback_kind,
+            item.fuli_last_feedback_at = $last_feedback_at,
             item.fuli_replaced_by_item_id = $replaced_by_item_id,
             item.fuli_replaced_by_item_kind = $replaced_by_item_kind,
             item.fact_embedding = coalesce($embedding, item.fact_embedding)
@@ -752,6 +783,12 @@ async def _update_item(store, space, item_id, item_kind, value, embedding):
         distinct_task_count=int(value.get('distinctTaskCount') or 0),
         last_used_at=_parse_datetime(value.get('lastUsedAt')),
         usage_generation=int(value.get('usageGeneration') or 1),
+        negative_evidence_count=int(
+            value.get('negativeEvidenceCount') or 0
+        ),
+        requires_attention=value.get('requiresAttention') is True,
+        last_feedback_kind=value.get('lastFeedbackKind'),
+        last_feedback_at=_parse_datetime(value.get('lastFeedbackAt')),
         replaced_by_item_id=value.get('replacedByItemId'),
         replaced_by_item_kind=value.get('replacedByItemKind'),
         embedding=embedding,

package/graph-provider/fuli_graph/knowledge_search.py

@@ -16,6 +16,7 @@ from .search_projection import (
     fact_result,
     is_default_retrievable,
     read_edge_epistemic_metadata,
+    source_uris_from_references,
 )
 
 MIN_TERM_COVERAGE = 0.25
@@ -390,7 +391,20 @@ async def _personal_entities(
                  AS qualified_use_count,
                coalesce(node.fuli_distinct_task_count, 0)
                  AS distinct_task_count,
-               node.fuli_last_used_at AS last_used_at
+               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,
+               [episode IN episodes
+                 WHERE episode.fuli_source_uri IS NOT NULL |
+                 {
+                   uri: episode.fuli_source_uri,
+                   reference_time: episode.valid_at,
+                   created_at: episode.created_at
+                 }] AS source_references
         ORDER BY node.name, node.uuid
         LIMIT $candidate_limit
         ''',
@@ -565,12 +579,14 @@ def _ranked_relevance(base_score: float, metadata) -> float:
     confidence_factor = 0.75 + min(max(confidence, 0), 1) * 0.25
     utility_factor = 0.95 + min(max(utility, 0), 1) * 0.1
     scope_factor = max(0.65, 1.0 - scope_distance * 0.15)
+    attention_factor = 0.6 if metadata.get('requires_attention') else 1.0
     return round(
         base_score
         * status_factor
         * confidence_factor
         * utility_factor
-        * scope_factor,
+        * scope_factor
+        * attention_factor,
         4,
     )
 
@@ -618,6 +634,7 @@ def _dedupe_ranked_entities(ranked, active_project_id):
 def _entity_search_result(record, score: float, space_id: str) -> EntitySearchResult:
     value = dict(record)
     basis = json_object(value.pop('confirmation_basis_json', None))
+    source_references = value.pop('source_references', [])
     created_at = _native_datetime(value.pop('created_at', None))
     last_human_changed_at = _native_datetime(
         value.pop('last_human_changed_at', None)
@@ -629,6 +646,9 @@ def _entity_search_result(record, score: float, space_id: str) -> EntitySearchRe
         value.pop('last_agent_reviewed_at', None)
     )
     last_used_at = _native_datetime(value.pop('last_used_at', None))
+    last_feedback_at = _native_datetime(
+        value.pop('last_feedback_at', None)
+    )
     for field in (
         'assignment_project_id',
         'episode_project_ids',
@@ -645,9 +665,11 @@ def _entity_search_result(record, score: float, space_id: str) -> EntitySearchRe
         last_agent_viewed_at=last_agent_viewed_at,
         last_agent_reviewed_at=last_agent_reviewed_at,
         last_used_at=last_used_at,
+        last_feedback_at=last_feedback_at,
         confirmation_basis=(
             ConfirmationBasis.model_validate(basis) if basis else None
         ),
+        source_uris=source_uris_from_references(source_references),
         score=score,
     )
 

package/graph-provider/fuli_graph/models.py

@@ -1,5 +1,6 @@
 from datetime import datetime
 from typing import Any, Literal
+from urllib.parse import urlsplit
 
 from pydantic import (
     AliasChoices,
@@ -59,8 +60,15 @@ KnowledgeAuditAction = Literal[
     'agent_view',
     'agent_review',
     'knowledge_used',
+    'knowledge_feedback',
 ]
 KnowledgeUseKind = Literal['cited', 'applied']
+KnowledgeFeedbackKind = Literal[
+    'rejected',
+    'validation_failed',
+    'contradicted',
+    'outdated',
+]
 KnowledgeInheritanceMode = Literal[
     'local_only',
     'descendants',
@@ -74,6 +82,8 @@ KnowledgeRevisionAction = Literal[
     'restore',
     'scope_change',
     'batch_confirm',
+    'promote_common',
+    'replace_common_duplicate',
 ]
 KnowledgeContentRevisionAction = Literal[
     'confirm',
@@ -103,10 +113,39 @@ PreferenceConflictResolutionAction = Literal[
 ]
 SourceApplication = Literal['codex', 'claude_code', 'cursor', 'kiro', 'other']
 
+
 class StrictModel(BaseModel):
     model_config = ConfigDict(extra='forbid', str_strip_whitespace=True)
 
 
+def _validated_source_uri(value: str) -> str:
+    if any(
+        character.isspace() or ord(character) < 32 or ord(character) == 127
+        for character in value
+    ):
+        raise ValueError(
+            'source_uri must be an absolute HTTP(S) URI without credentials'
+        )
+    try:
+        parsed = urlsplit(value)
+        hostname = parsed.hostname
+    except ValueError as error:
+        raise ValueError(
+            'source_uri must be an absolute HTTP(S) URI without credentials'
+        ) from error
+    if (
+        parsed.scheme.casefold() not in {'http', 'https'}
+        or not parsed.netloc
+        or not hostname
+        or parsed.username is not None
+        or parsed.password is not None
+    ):
+        raise ValueError(
+            'source_uri must be an absolute HTTP(S) URI without credentials'
+        )
+    return value
+
+
 def _validate_inheritance(
     mode: KnowledgeInheritanceMode,
     project_ids: list[str],
@@ -501,6 +540,7 @@ class StructuredEpisode(StrictModel):
     name: str = Field(min_length=1, max_length=512)
     source_kind: str = Field(min_length=1, max_length=128)
     source_description: str = Field(min_length=1, max_length=1024)
+    source_uri: str | None = Field(default=None, min_length=1, max_length=2048)
     source_application: SourceApplication | None = None
     source_turn_id: str | None = Field(default=None, min_length=1, max_length=256)
     source_excerpt: str | None = Field(default=None, min_length=1, max_length=2048)
@@ -510,6 +550,11 @@ class StructuredEpisode(StrictModel):
     entities: list[EntityInput] = Field(min_length=1, max_length=128)
     relationships: list[RelationshipInput] = Field(default_factory=list, max_length=256)
 
+    @field_validator('source_uri')
+    @classmethod
+    def validate_source_uri(cls, value: str | None) -> str | None:
+        return _validated_source_uri(value) if value is not None else None
+
     @model_validator(mode='after')
     def complete_confirmation_state(self):
         proposer = ConfirmationActor(
@@ -722,9 +767,14 @@ class EntitySearchResult(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
     scope_distance: int = Field(default=0, ge=0, le=8)
     inherited_from_project_id: str | None = None
     scope_path: list[str] = Field(default_factory=list, max_length=9)
+    source_uris: list[str] = Field(default_factory=list, max_length=20)
     score: float | None = None
 
 
@@ -764,9 +814,14 @@ class FactResult(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
     scope_distance: int = Field(default=0, ge=0, le=8)
     inherited_from_project_id: str | None = None
     scope_path: list[str] = Field(default_factory=list, max_length=9)
+    source_uris: list[str] = Field(default_factory=list, max_length=20)
     score: float | None = None
 
 
@@ -892,6 +947,7 @@ class GraphEvidence(StrictModel):
     name: str
     source_description: str
     source_kind: str
+    source_uri: str | None = Field(default=None, min_length=1, max_length=2048)
     summary: str
     session_id: str | None = None
     source_application: SourceApplication | None = None
@@ -901,6 +957,11 @@ class GraphEvidence(StrictModel):
     reference_time: datetime | None = None
     created_at: datetime | None = None
 
+    @field_validator('source_uri')
+    @classmethod
+    def validate_source_uri(cls, value: str | None) -> str | None:
+        return _validated_source_uri(value) if value is not None else None
+
 
 class KnowledgeRevisionCreate(StrictModel):
     personal_space_id: str = Field(min_length=1, max_length=128)
@@ -1100,6 +1161,14 @@ class KnowledgeAuditRecord(StrictModel):
     task_id: str | None = None
     session_id: str | None = None
     use_kind: KnowledgeUseKind | None = None
+    feedback_kind: KnowledgeFeedbackKind | None = None
+    reported_by_kind: Literal[
+        'user',
+        'agent',
+        'authoritative_source',
+    ] | None = None
+    evidence_summary: str | None = None
+    source_uri: str | None = None
     usage_generation: int | None = Field(default=None, ge=1)
     conflict_check: Literal['no_conflict', 'conflict'] | None = None
     classification_check: Literal['reasonable', 'needs_change'] | None = None