fuli-context 0.11.1 → 0.12.1

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_delegations.py

@@ -20,6 +20,23 @@ class AgentDelegationIssue(StrictModel):
     lifetime_seconds: int = Field(default=300, ge=30, le=900)
 
 
+class AgentRemoteDelegationIssue(StrictModel):
+    """One attempt of a signed ask from another paired device.
+
+    The local runner has already verified the device signature and the owner's
+    share. This authority still decides project, receiver, client and lifetime.
+    """
+    personal_space_id: str = Field(min_length=1, max_length=128)
+    personal_project_id: str = Field(min_length=1, max_length=128)
+    agent_id: str = Field(min_length=1, max_length=128)
+    target_application: SourceApplication
+    target_session_id: str | None = Field(default=None, min_length=1, max_length=256)
+    lifetime_seconds: int = Field(default=300, ge=30, le=900)
+    origin_node: str = Field(pattern=r'^[0-9a-f]{64}$')
+    origin_message_id: str = Field(min_length=1, max_length=128, pattern=r'^[A-Za-z0-9][A-Za-z0-9._:-]*$')
+    origin_attempt_id: str = Field(min_length=1, max_length=128, pattern=r'^[A-Za-z0-9][A-Za-z0-9._:-]*$')
+
+
 class AgentDelegationCheck(StrictModel):
     personal_space_id: str = Field(min_length=1, max_length=128)
     token: str = Field(min_length=32, max_length=128)
@@ -66,6 +83,51 @@ class StoreAgentDelegations:
             lead=lead, lifetime=request.lifetime_seconds)
         return {'token': token}
 
+    async def issue_remote_agent_delegation(self, actor, request):
+        self._require_personal()
+        space = await self.authorize(actor, request.personal_space_id, 'maintainer')
+        await authorize_personal_project(self, actor, space, request.personal_project_id)
+        policy = await self.get_project_agent_coordination_policy(
+            actor, request.personal_space_id, request.personal_project_id)
+        lead = policy.team_lead_agent_id
+        # Remote asks keep the receiving project's accountable lead: in this
+        # version only that lead can be woken, never a member directly.
+        if not lead or request.agent_id != lead:
+            raise HTTPException(403, 'Remote devices can only ask the project lead')
+        target = await self.get_project_agent(
+            actor, request.personal_space_id, request.personal_project_id, request.agent_id)
+        if (target.profile.status != 'active'
+                or request.target_application not in target.profile.allowed_clients):
+            raise HTTPException(403, 'The receiving Agent is unavailable in this client')
+        token = token_urlsafe(32)
+        await self.runtime.driver.execute_query(
+            '''MATCH (old:FuliAgentDelegation {space_id: $space_id})
+               WHERE old.expires_at <= datetime() DELETE old''', space_id=request.personal_space_id)
+        # The attempt record is durable history and is never deleted, so one
+        # claimed attempt can obtain authority at most once.
+        rows, _, _ = await self.runtime.driver.execute_query(
+            '''MERGE (attempt:FuliRemoteDelegationAttempt {space_id: $space_id, origin_node: $origin_node,
+                     origin_message_id: $message_id, origin_attempt_id: $attempt_id})
+               ON CREATE SET attempt.issued_at = datetime(), attempt.project_id = $project_id,
+                     attempt.agent_id = $agent_id, attempt._created = true
+               WITH attempt, coalesce(attempt._created, false) AS created
+               REMOVE attempt._created
+               WITH attempt, created WHERE created
+               CREATE (:FuliAgentDelegation {token_hash: $token_hash, space_id: $space_id,
+                 project_id: $project_id, agent_id: $agent_id, source_application: $application,
+                 session_id: $session_id, sender_token: null, lead_agent_id: $lead, origin: 'remote',
+                 origin_node: $origin_node, origin_message_id: $message_id, origin_attempt_id: $attempt_id,
+                 expires_at: datetime() + duration({seconds: $lifetime}), redeemed: false})
+               RETURN attempt.issued_at AS issued_at''',
+            space_id=request.personal_space_id, origin_node=request.origin_node,
+            message_id=request.origin_message_id, attempt_id=request.origin_attempt_id,
+            project_id=request.personal_project_id, agent_id=request.agent_id,
+            token_hash=token_hash(token), application=request.target_application,
+            session_id=request.target_session_id, lead=lead, lifetime=request.lifetime_seconds)
+        if not rows:
+            raise HTTPException(409, 'This remote delivery attempt already received authority')
+        return {'token': token}
+
     async def redeem_agent_delegation(self, request, lead):
         if not request.delegation_token or not request.delegation_session_id or not request.agent_id:
             return False
@@ -85,11 +147,17 @@ class StoreAgentDelegations:
                WITH grant
                WHERE grant.expires_at > datetime()
                  AND (grant.session_id IS NULL OR grant.session_id = $session_id)
-               MATCH (session:FuliTaskContextSession)-[:HAS_CONTEXT]->(task:FuliTaskContext)
-               WHERE task.token = grant.sender_token AND session.current_token = task.token
+               OPTIONAL MATCH (session:FuliTaskContextSession)-[:HAS_CONTEXT]->(task:FuliTaskContext)
+               WHERE grant.origin IS NULL
+                 AND task.token = grant.sender_token AND session.current_token = task.token
                  AND NOT task.completed AND task.personal_space_id = grant.space_id
                  AND task.personal_project_id = grant.project_id
                  AND (task.project_agent_id = grant.lead_agent_id OR grant.agent_id = grant.lead_agent_id)
+               WITH grant, count(task) AS live_sender
+               // A local grant needs its live sender task; a remote grant has no
+               // local sender and may only ever restore the current lead.
+               WHERE (grant.origin IS NULL AND live_sender > 0)
+                  OR (grant.origin = 'remote' AND grant.agent_id = grant.lead_agent_id)
                SET grant.session_id = $session_id, grant.redeemed = true
                RETURN grant.token_hash AS token_hash''',
             token_hash=token_hash(request.delegation_token), space_id=request.personal_space_id,

package/graph-provider/fuli_graph/project_agent_memory_routes.py

@@ -15,7 +15,10 @@ from .project_agent_context_models import (
 from .agent_conversation_routes import register_agent_conversation_routes
 from .default_project_lead import DefaultProjectLeadRequest
 from .task_context_routes import register_task_context_routes
-from .project_agent_delegations import AgentDelegationIssue, AgentDelegationCheck
+from .project_agent_delegations import (
+    AgentDelegationCheck, AgentDelegationIssue, AgentRemoteDelegationIssue,
+)
+from .project_agent_remote_origins import AgentRemoteOriginIssue
 
 
 def register_project_agent_memory_routes(application, store, Actor):
@@ -31,6 +34,20 @@ def register_project_agent_memory_routes(application, store, Actor):
     async def issue_delegation(request: AgentDelegationIssue, actor: Actor):
         return await store.issue_agent_delegation(actor, request)
 
+    @application.post('/v1/project-agent-context/remote-delegations')
+    async def issue_remote_delegation(request: AgentRemoteDelegationIssue, actor: Actor):
+        return await store.issue_remote_agent_delegation(actor, request)
+
+    @application.post('/v1/project-agent-context/remote-origins')
+    async def issue_remote_origin(request: AgentRemoteOriginIssue, actor: Actor):
+        return await store.issue_remote_agent_origin(actor, request)
+
+    @application.get('/v1/project-agent-context/remote-origin-authority')
+    async def remote_origin_authority(
+        actor: Actor, personal_space_id: Annotated[str, Query(min_length=1, max_length=128)],
+    ):
+        return await store.remote_origin_authority(actor, personal_space_id)
+
     @application.post('/v1/project-agent-context/delegations/verify')
     async def verify_delegation(request: AgentDelegationCheck, actor: Actor):
         return await store.verify_agent_delegation(actor, request)

package/graph-provider/fuli_graph/project_agent_remote_origins.py

@@ -0,0 +1,154 @@
+"""Origin proof for asks this installation sends to Agents on other devices.
+
+A device signature only proves which installation sent a message. The
+receiving device also needs proof that this authority, not merely the device,
+let the current project lead's live task send exactly that message. This
+authority signs that statement with a key that never leaves it; the receiver
+checks it with the public key it bound when the owners paired the devices.
+"""
+
+import json
+from base64 import urlsafe_b64decode, urlsafe_b64encode
+from datetime import datetime, timedelta, timezone
+from hashlib import sha256
+
+from fastapi import HTTPException
+from nacl.signing import SigningKey
+from neo4j.exceptions import ConstraintError
+from pydantic import Field
+
+from .models import SourceApplication, StrictModel
+from .personal_project_access import authorize_personal_project
+
+OPAQUE = r'^[A-Za-z0-9][A-Za-z0-9._:-]*$'
+DIGEST = r'^[0-9a-f]{64}$'
+CANONICAL_TIME = r'^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$'
+PROOF_VERSION = 'fuli-remote-origin/1'
+MAX_LIFETIME = timedelta(minutes=30)
+
+
+class AgentRemoteOriginIssue(StrictModel):
+    personal_space_id: str = Field(min_length=1, max_length=128)
+    task_context_token: str = Field(min_length=1, max_length=256)
+    source_application: SourceApplication
+    message_id: str = Field(min_length=1, max_length=128, pattern=OPAQUE)
+    digest: str = Field(pattern=DIGEST)
+    target_node: str = Field(pattern=DIGEST)
+    binding_id: str = Field(min_length=1, max_length=128, pattern=OPAQUE)
+    expires_at: str = Field(pattern=CANONICAL_TIME)
+
+
+def _encode(value):
+    return urlsafe_b64encode(value).rstrip(b'=').decode()
+
+
+def _decode(value):
+    return urlsafe_b64decode(value + '=' * (-len(value) % 4))
+
+
+def canonical_time(value):
+    return value.astimezone(timezone.utc).strftime('%Y-%m-%dT%H:%M:%S.') + f'{value.microsecond // 1000:03d}Z'
+
+
+class StoreRemoteAgentOrigins:
+    async def remote_origin_authority(self, actor, personal_space_id):
+        """Public half of this space's origin key; created once and never rotated silently."""
+        self._require_personal()
+        await self.authorize(actor, personal_space_id, 'maintainer')
+        key = await self._remote_origin_key(personal_space_id)
+        return {'algorithm': 'Ed25519', 'key_id': key['key_id'], 'public_key': key['public_key']}
+
+    async def _remote_origin_key(self, space_id):
+        candidate = SigningKey.generate()
+        public = bytes(candidate.verify_key)
+        try:
+            rows, _, _ = await self.runtime.driver.execute_query(
+                '''MERGE (key:FuliRemoteOriginKey {space_id: $space_id})
+                   ON CREATE SET key.private_key = $private_key, key.public_key = $public_key,
+                     key.key_id = $key_id, key.created_at = datetime()
+                   RETURN key.private_key AS private_key, key.public_key AS public_key, key.key_id AS key_id''',
+                space_id=space_id, private_key=_encode(bytes(candidate)),
+                public_key=_encode(public), key_id=sha256(public).hexdigest()[:32])
+        except ConstraintError:
+            # A concurrent first use created the key; everyone must use that one.
+            rows, _, _ = await self.runtime.driver.execute_query(
+                '''MATCH (key:FuliRemoteOriginKey {space_id: $space_id})
+                   RETURN key.private_key AS private_key, key.public_key AS public_key, key.key_id AS key_id''',
+                space_id=space_id)
+        return rows[0]
+
+    async def issue_remote_agent_origin(self, actor, request):
+        self._require_personal()
+        space = await self.authorize(actor, request.personal_space_id, 'maintainer')
+        expires = datetime.fromisoformat(request.expires_at.replace('Z', '+00:00'))
+        now = datetime.now(timezone.utc)
+        if expires <= now or expires - now > MAX_LIFETIME:
+            raise HTTPException(422, 'A remote ask needs a lifetime of at most 30 minutes')
+        context = await self.get_task_context(actor, request.personal_space_id,
+                                              request.task_context_token, request.source_application)
+        agent_id = context.get('project_agent_id')
+        project_id = context.get('personal_project_id')
+        if not agent_id or not project_id or (context.get('checkpoint') or {}).get('phase') == 'complete':
+            raise HTTPException(409, 'A remote ask requires an active project task of a FULI Agent')
+        await authorize_personal_project(self, actor, space, project_id)
+        policy = await self.get_project_agent_coordination_policy(actor, request.personal_space_id, project_id)
+        # Members reach other devices through their own lead, never directly.
+        if not policy.team_lead_agent_id or agent_id != policy.team_lead_agent_id:
+            raise HTTPException(403, 'Only the project lead can ask Agents on other devices')
+        agent = await self.get_project_agent(actor, request.personal_space_id, project_id, agent_id)
+        if agent.profile.status != 'active':
+            raise HTTPException(403, 'The sending Agent is not active')
+        task_hash = sha256(request.task_context_token.encode()).hexdigest()
+        # The checks above can be overtaken by a new task turn or a lead handoff.
+        # Those writers lock the session, the role and the policy; this takes the
+        # same locks and re-checks under them before recording the origin.
+        rows, _, _ = await self.runtime.driver.execute_query(
+            '''MATCH (space:FuliSpace {id: $space_id, kind: 'personal'})-[:HAS_TASK_CONTEXT_SESSION]->
+                     (session:FuliTaskContextSession)-[:HAS_CONTEXT]->(task:FuliTaskContext {token: $token})
+               SET session._fuli_write_lock = true REMOVE session._fuli_write_lock
+               WITH space, session, task
+               MATCH (space)-[:CONTAINS_PROJECT]->(project:FuliPersonalProject {project_id: $project_id})
+               MATCH (space)-[:HAS_PROJECT_AGENT_IDENTITY]->(role:FuliProjectAgent {agent_id: $agent_id})
+               SET role._task_lifecycle_lock = true REMOVE role._task_lifecycle_lock
+               WITH space, session, task, project, role
+               MATCH (project)-[:HAS_PROJECT_AGENT_COORDINATION_POLICY]->(policy:FuliProjectAgentCoordinationPolicy)
+               SET policy._fuli_write_lock = true REMOVE policy._fuli_write_lock
+               WITH session.current_token = task.token AND NOT coalesce(task.completed, false)
+                      AND task.personal_project_id = $project_id AND task.project_agent_id = $agent_id AS live_task,
+                    policy.team_lead_agent_id = $agent_id AS lead,
+                    role.status = 'active' AND EXISTS {
+                      MATCH (project)-[:HAS_PROJECT_AGENT_ASSIGNMENT]->
+                            (:FuliProjectAgentAssignment {status: 'active'})-[:ASSIGNED_AGENT]->(role)
+                    } AS assigned
+               WITH live_task, lead, assigned, live_task AND lead AND assigned AS allowed
+               FOREACH (ignored IN CASE WHEN allowed THEN [1] ELSE [] END |
+                 MERGE (origin:FuliRemoteAgentOrigin {space_id: $space_id, message_id: $message_id})
+                 ON CREATE SET origin.digest = $digest, origin.agent_id = $agent_id, origin.project_id = $project_id,
+                   origin.target_node = $target_node, origin.binding_id = $binding_id, origin.task_hash = $task_hash,
+                   origin.issued_at = datetime(), origin.expires_at = datetime($expires_at))
+               WITH live_task, lead, assigned, allowed
+               OPTIONAL MATCH (origin:FuliRemoteAgentOrigin {space_id: $space_id, message_id: $message_id})
+               WITH live_task, lead, assigned,
+                    allowed AND origin.digest = $digest AND origin.agent_id = $agent_id AND origin.task_hash = $task_hash
+                      AND origin.target_node = $target_node AND origin.binding_id = $binding_id AS same
+               RETURN live_task, lead, assigned, same''',
+            space_id=request.personal_space_id, token=request.task_context_token, message_id=request.message_id,
+            digest=request.digest, agent_id=agent_id, project_id=project_id, target_node=request.target_node,
+            binding_id=request.binding_id, task_hash=task_hash, expires_at=request.expires_at)
+        row = rows[0] if rows else None
+        if not row or not row['live_task']:
+            raise HTTPException(404, 'The sending task is no longer current')
+        if not row['lead'] or not row['assigned']:
+            raise HTTPException(403, 'Only the project lead can ask Agents on other devices')
+        if not row['same']:
+            raise HTTPException(409, 'This message ID already belongs to a different remote ask')
+        key = await self._remote_origin_key(request.personal_space_id)
+        payload = json.dumps({
+            'version': PROOF_VERSION, 'key_id': key['key_id'], 'space_id': request.personal_space_id,
+            'project_id': project_id, 'agent_id': agent_id, 'task_hash': task_hash,
+            'message_id': request.message_id, 'digest': request.digest, 'target_node': request.target_node,
+            'binding_id': request.binding_id, 'issued_at': canonical_time(now), 'expires_at': request.expires_at,
+        }, sort_keys=True, separators=(',', ':')).encode()
+        signature = SigningKey(_decode(key['private_key'])).sign(payload).signature
+        return {'agent_id': agent_id, 'agent_name': agent.profile.display_name or agent.profile.name or agent_id,
+                'proof': {'payload': _encode(payload), 'signature': _encode(signature)}}

package/graph-provider/fuli_graph/project_agent_task_models.py

@@ -21,7 +21,7 @@ ProjectAgentTaskDuration = Literal['ongoing', 'one_off']
 ProjectAgentStaffingIntent = Literal[
     'reuse_preferred',
     # Like reuse_preferred, but a project without a team lead hires its first
-    # lead through HR without waiting for confirmation.
+    # lead through AR without waiting for confirmation.
     'default_lead',
     'new_durable',
     'temporary',
@@ -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)