fuli-context 0.8.0 → 0.8.1

package/graph-provider/fuli_graph/agent_verification_models.py

@@ -0,0 +1,22 @@
+from typing import Annotated, Literal
+from pydantic import Field
+from .models import StrictModel, SourceApplication
+
+
+class AgentQualityQuery(StrictModel):
+    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)
+    artifact_revision: str = Field(min_length=1, max_length=160)
+
+
+class AgentVerification(AgentQualityQuery):
+    run_id: str = Field(min_length=1, max_length=128)
+    task_context_token: str = Field(min_length=1, max_length=160)
+    source_application: SourceApplication
+    attempt_id: str = Field(min_length=8, max_length=128)
+    outcome: Literal['pass', 'fail']
+    evidence_refs: list[Annotated[str, Field(min_length=1, max_length=512, pattern=r'\S')]] = Field(min_length=1, max_length=12)
+    executor_id: str = Field(min_length=1, max_length=128)
+    provider: str = Field(min_length=1, max_length=128)
+    model: str = Field(min_length=1, max_length=256)

package/graph-provider/fuli_graph/conversation_context.py

@@ -0,0 +1,30 @@
+"""Deterministic recovery: no model calls, conservative UTF-8 byte accounting."""
+import json
+from datetime import datetime, timezone
+
+
+def archived(last_activity, idle_days, *, now=None):
+    current = datetime.fromisoformat(now) if now else datetime.now(timezone.utc)
+    previous = datetime.fromisoformat(last_activity)
+    return (current - previous).total_seconds() >= idle_days * 86400
+
+
+def pack_context(summary, events, budget):
+    result = {'summary': '', 'messages': [], 'truncated': False}
+    def size():
+        return len(json.dumps(result, ensure_ascii=False, separators=(',', ':')).encode())
+    result['summary'] = summary or ''
+    # Reserve half for recent messages; Unicode slicing never splits codepoints.
+    while len(result['summary'].encode()) > budget // 2:
+        result['summary'] = result['summary'][:max(0, len(result['summary']) - 64)]
+        result['truncated'] = True
+    for event in reversed(events):
+        if event['role'] not in ('user', 'assistant') or event.get('kind', 'message') != 'message':
+            continue
+        item = {'role': event['role'], 'content': event['content']}
+        result['messages'].insert(0, item)
+        if size() > budget:
+            result['messages'].pop(0)
+            result['truncated'] = True
+            break
+    return result

package/graph-provider/fuli_graph/project_agent_executor_models.py

@@ -150,6 +150,8 @@ class ProjectAgentExecutorModelRecord(StrictModel):
     provider: str = Field(min_length=1, max_length=128)
     model: str = Field(min_length=1, max_length=256)
     capabilities: list[str] = Field(default_factory=list, max_length=32)
+    capability_tier: int | None = Field(default=None, ge=1, le=3)
+    cost_rank: float | None = Field(default=None, ge=0, allow_inf_nan=False)
     strategy_modes: list[Literal['adaptive', 'fast', 'balanced', 'deep']] = Field(
         default_factory=list,
         max_length=4,
@@ -456,6 +458,7 @@ class ProjectAgentExecutorSelection(StrictModel):
 
 
 class ProjectAgentExecutorActualReport(StrictModel):
+    artifact_revision: str | None = Field(default=None, min_length=1, max_length=160)
     personal_space_id: str = Field(min_length=1, max_length=128)
     personal_project_id: str = Field(min_length=1, max_length=128)
     task_id: str = Field(min_length=1, max_length=128)

package/graph-provider/fuli_graph/project_agent_memory_routes.py

@@ -12,11 +12,13 @@ from .project_agent_memory_models import (
 from .project_agent_context_models import (
     ProjectAgentContextRequest, ProjectAgentContextResolution,
 )
+from .agent_conversation_routes import register_agent_conversation_routes
 from .task_context_routes import register_task_context_routes
 
 
 def register_project_agent_memory_routes(application, store, Actor):
     register_task_context_routes(application, store, Actor)
+    register_agent_conversation_routes(application, store, Actor)
     @application.post(
         '/v1/project-agent-context/resolve', response_model=ProjectAgentContextResolution,
     )

package/graph-provider/fuli_graph/project_agent_models.py

@@ -88,6 +88,14 @@ class ProjectAgentExecutorPolicy(StrictModel):
         return self
 
 
+class ProjectAgentCharacter(StrictModel):
+    """Configured role intent, not a claim about demonstrated performance."""
+
+    judgment: str = Field(default='', max_length=2048)
+    taste: str = Field(default='', max_length=2048)
+    personality: str = Field(default='', max_length=2048)
+
+
 class ProjectAgentProfile(StrictModel):
     name: str = Field(min_length=1, max_length=160)
     display_name: str | None = Field(default=None, min_length=1, max_length=160)
@@ -101,6 +109,8 @@ class ProjectAgentProfile(StrictModel):
         validation_alias=AliasChoices('occupation_emoji', 'occupationEmoji'),
     )
     responsibility: str = Field(min_length=1, max_length=4096)
+    character: ProjectAgentCharacter = Field(default_factory=ProjectAgentCharacter)
+    expectations: str = Field(default='', max_length=4096)
     agent_type: ProjectAgentType = 'durable'
     work_kinds: list[str] = Field(default_factory=list, max_length=32)
     capabilities: list[str] = Field(default_factory=list, max_length=32)

package/graph-provider/fuli_graph/project_agent_task_models.py

@@ -141,6 +141,9 @@ class ProjectAgentParallelPlan(StrictModel):
 
 
 class ProjectAgentTaskSubmit(StrictModel):
+    # All newly submitted tasks use the quality gate, including legacy public
+    # entry points. Existing graph records without this field remain readable.
+    verification_required: Literal[True] = True
     personal_space_id: str = Field(min_length=1, max_length=128)
     personal_project_id: str = Field(min_length=1, max_length=128)
     idempotency_key: str = Field(min_length=8, max_length=256)
@@ -486,6 +489,7 @@ class ProjectAgentTaskRecord(StrictModel):
 
 
 class ProjectAgentTaskActivityCreate(StrictModel):
+    artifact_revision: str | None = Field(default=None, min_length=1, max_length=160)
     personal_space_id: str = Field(min_length=1, max_length=128)
     personal_project_id: str = Field(min_length=1, max_length=128)
     task_id: str = Field(min_length=1, max_length=128)

package/graph-provider/fuli_graph/runtime.py

@@ -269,6 +269,20 @@ class GraphitiRuntime:
         # safe for upgraded stores as well as fresh databases.
         await self._migrate_project_agent_executor_learning_buckets()
         for query in (
+            'CREATE CONSTRAINT fuli_agent_verification_id IF NOT EXISTS '
+            'FOR (n:FuliAgentVerification) REQUIRE n.id IS UNIQUE',
+            'CREATE CONSTRAINT fuli_agent_loan_id IF NOT EXISTS '
+            'FOR (n:FuliAgentLoan) REQUIRE n.id IS UNIQUE',
+            'CREATE CONSTRAINT fuli_transcript_cursor_id IF NOT EXISTS '
+            'FOR (n:FuliTranscriptCursor) REQUIRE n.id IS UNIQUE',
+            'CREATE CONSTRAINT fuli_conversation_id IF NOT EXISTS '
+            'FOR (n:FuliConversation) REQUIRE n.id IS UNIQUE',
+            'CREATE CONSTRAINT fuli_conversation_event IF NOT EXISTS '
+            'FOR (n:FuliConversationEvent) REQUIRE n.id IS UNIQUE',
+            'CREATE CONSTRAINT fuli_conversation_binding IF NOT EXISTS '
+            'FOR (n:FuliConversationBinding) REQUIRE n.id IS UNIQUE',
+            'CREATE CONSTRAINT fuli_conversation_policy IF NOT EXISTS '
+            'FOR (n:FuliConversationPolicy) REQUIRE n.id IS UNIQUE',
             'CREATE CONSTRAINT fuli_project_agent_id IF NOT EXISTS '
             'FOR (n:FuliProjectAgent) REQUIRE n.id IS UNIQUE',
             'CREATE CONSTRAINT fuli_agent_attention_id IF NOT EXISTS '

package/graph-provider/fuli_graph/store.py

@@ -2,6 +2,9 @@ from .config import Settings
 from .provider_values import graphiti_group_id, native_datetime
 from .runtime import GraphitiRuntime
 from .store_identity import StoreIdentity
+from .store_agent_conversations import StoreAgentConversations
+from .store_agent_loans import StoreAgentLoans
+from .store_agent_verification import StoreAgentVerification
 from .store_knowledge import StoreKnowledge
 from .store_project_agent_executors import StoreProjectAgentExecutors
 from .store_project_agent_memory import StoreProjectAgentMemory
@@ -17,6 +20,9 @@ from .store_task_contexts import StoreTaskContexts
 
 class GraphStore(
     StoreIdentity,
+    StoreAgentConversations,
+    StoreAgentLoans,
+    StoreAgentVerification,
     StoreProjects,
     StoreProjectAgents,
     StoreProjectAgentAttention,

package/graph-provider/fuli_graph/store_agent_conversations.py

@@ -0,0 +1,206 @@
+"""Transactional conversation journal in the private graph; no LLM/embeddings."""
+import base64
+import gzip
+import hashlib
+import json
+from fastapi import HTTPException
+from .agent_conversation_models import ConversationPolicy
+from .conversation_context import archived, pack_context
+from .project_agent_access import authorize_project_agent
+from .provider_values import now_utc, stable_uuid
+from .store_transactions import query_store_transaction
+
+
+def encode_event(event):
+    raw = json.dumps(event.model_dump(), ensure_ascii=False, sort_keys=True).encode()
+    return hashlib.sha256(raw).hexdigest(), base64.b64encode(gzip.compress(raw, mtime=0)).decode()
+
+
+def decode_event(row):
+    return {**json.loads(gzip.decompress(base64.b64decode(row['payload']))), 'sequence': row['sequence']}
+
+
+class StoreAgentConversations:
+    async def _conversation_scope(self, actor, request, *, write=False):
+        self._require_personal()
+        space = await self.authorize(actor, request.personal_space_id, 'maintainer' if write else 'reader')
+        agent = await authorize_project_agent(self, actor, space, request.personal_project_id,
+            request.agent_id, require_active=write, require_memory=True)
+        if request.source_application is not None and request.source_application not in json.loads(agent['profile_json']).get('allowed_clients', []):
+            raise HTTPException(403, 'Agent is not allowed in this client')
+        return stable_uuid('conversation-scope', space['id'], request.personal_project_id, agent['agent_id'])
+
+    async def _conversation_task(self, actor, request):
+        await self.runtime.driver.execute_query(
+            'MATCH (s:FuliTaskContextSession {id: $id}) SET s.conversation_serial=coalesce(s.conversation_serial,0)+1',
+            id=self._task_session_id(request.personal_space_id, request.source_application, request.session_id))
+        task = await self.get_task_context(actor, request.personal_space_id,
+            request.task_context_token, request.source_application)
+        if (task['session_id'], task['personal_project_id'], task['project_agent_id']) != (
+            request.session_id, request.personal_project_id, request.agent_id):
+            raise HTTPException(409, 'Conversation does not match the current task Agent and session')
+
+    async def _conversation_policy(self, scope):
+        rows, _, _ = await self.runtime.driver.execute_query(
+            'MATCH (p:FuliConversationPolicy {id: $scope}) RETURN p.policy AS policy', scope=scope)
+        return ConversationPolicy.model_validate_json(rows[0]['policy']) if rows else ConversationPolicy()
+
+    async def write_conversation_policy(self, actor, request):
+        scope = await self._conversation_scope(actor, request, write=True)
+        await self.runtime.driver.execute_query(
+            'MERGE (p:FuliConversationPolicy {id: $scope}) SET p.policy=$policy',
+            scope=scope, policy=request.policy.model_dump_json())
+        return request.policy.model_dump()
+
+    async def query_conversations(self, actor, request):
+        scope = await self._conversation_scope(actor, request)
+        policy = await self._conversation_policy(scope)
+        if request.mode == 'policy':
+            return policy.model_dump()
+        if request.mode == 'session':
+            rows, _, _ = await self.runtime.driver.execute_query(
+                'OPTIONAL MATCH (b:FuliConversationBinding {id: $id}) '
+                'OPTIONAL MATCH (s:FuliTranscriptCursor {id: $stream}) '
+                'RETURN b.conversation_id AS conversation_id, coalesce(s.cursor,0) AS cursor, '
+                'coalesce(s.initialized, s.cursor > 0, false) AS initialized',
+                stream=stable_uuid(request.personal_space_id, request.source_application, request.session_id or ''),
+                id=stable_uuid(scope, request.source_application, request.session_id or ''))
+            return dict(rows[0]) if rows else {'conversation_id': None, 'cursor': 0, 'initialized': False}
+        if request.mode == 'list':
+            rows, _, _ = await self.runtime.driver.execute_query(
+                'MATCH (c:FuliConversation {scope: $scope}) RETURN c ORDER BY c.last_activity DESC, c.id LIMIT $limit',
+                scope=scope, limit=request.limit)
+            return {'conversations': [self._conversation_view(dict(r['c']), policy) for r in rows]}
+        rows, _, _ = await self.runtime.driver.execute_query(
+            'MATCH (c:FuliConversation {scope: $scope, id: $id}) RETURN c', scope=scope, id=request.conversation_id)
+        if not rows:
+            raise HTTPException(404, 'Conversation not found in this Agent and project')
+        record = dict(rows[0]['c'])
+        view = self._conversation_view(record, policy)
+        if request.mode == 'context' and view['archived']:
+            return {**view, 'context': pack_context(record.get('summary', ''), [], policy.context_budget)}
+        order = 'DESC' if request.mode == 'context' else 'ASC'
+        events, _, _ = await self.runtime.driver.execute_query(
+            'MATCH (c:FuliConversation {id: $id})-[:HAS_EVENT]->(e:FuliConversationEvent) '
+            'WHERE e.sequence > $after RETURN e.payload AS payload, e.sequence AS sequence '
+            f'ORDER BY e.sequence {order} LIMIT $limit', id=record['id'], after=request.after,
+            limit=20 if request.mode == 'context' else request.limit)
+        decoded = []
+        total = 0
+        for event in events:
+            value = decode_event(event)
+            total += len(json.dumps(value, ensure_ascii=False).encode())
+            if total > 512 * 1024 and decoded:
+                break
+            decoded.append(value)
+        if request.mode == 'context':
+            return {**view, 'context': pack_context(record.get('summary', ''), list(reversed(decoded)), policy.context_budget)}
+        cursor = decoded[-1]['sequence'] if decoded else request.after
+        return {**view, 'events': decoded, 'next_cursor': cursor, 'has_more': cursor < record['revision']}
+
+    def _conversation_view(self, record, policy):
+        return {key: record.get(key) for key in ('id', 'summary', 'status', 'revision', 'last_activity')} | {
+            'archived': archived(record['last_activity'], policy.idle_days),
+            'policy': policy.model_dump(), 'raw_retained': True}
+
+    async def append_conversation(self, actor, request):
+        if request.initialize_cursor:
+            raise HTTPException(422, 'Initialize transcripts only at a verified task boundary')
+        async with query_store_transaction(self) as store:
+            scope = await store._conversation_scope(actor, request, write=True)
+            await store._conversation_task(actor, request)
+            policy = await store._conversation_policy(scope)
+            if not policy.enabled:
+                return {'status': 'capture_disabled'}
+            stream = stable_uuid(request.personal_space_id, request.source_application, request.session_id)
+            streams, _, _ = await store.runtime.driver.execute_query(
+                'MERGE (s:FuliTranscriptCursor {id: $id}) ON CREATE SET s.cursor=0, s.owner_scope=$scope '
+                'SET s.serial=coalesce(s.serial,0)+1 RETURN s.cursor AS cursor, s.owner_scope AS owner_scope, '
+                'coalesce(s.initialized, s.cursor > 0, false) AS initialized', id=stream, scope=scope)
+            binding = stable_uuid(scope, request.source_application, request.session_id)
+            rows, _, _ = await store.runtime.driver.execute_query(
+                'MERGE (b:FuliConversationBinding {id: $id}) '
+                'ON CREATE SET b.conversation_id=$conversation_id, b.cursor=0 '
+                'SET b.serial=coalesce(b.serial,0)+1 RETURN b.conversation_id AS id, b.cursor AS cursor',
+                id=binding, conversation_id=stable_uuid('conversation', binding))
+            conversation_id = rows[0]['id']
+            cursor = streams[0]['cursor']
+            if request.expected_cursor is not None and not streams[0]['initialized']:
+                raise HTTPException(409, 'Transcript must start at a verified task boundary')
+            if request.expected_cursor is not None and streams[0]['owner_scope'] not in (None, scope):
+                raise HTTPException(409, 'Transcript scope changed without a verified prompt boundary; do not import the old tail')
+            if request.expected_cursor is not None and cursor != request.expected_cursor:
+                raise HTTPException(409, 'Transcript cursor changed; reload before retrying')
+            now = now_utc().isoformat()
+            await store.runtime.driver.execute_query(
+                'MERGE (c:FuliConversation {id: $id}) ON CREATE SET c.scope=$scope, c.revision=0, '
+                "c.last_activity=$now, c.summary='', c.status='reported' "
+                'SET c.serial=coalesce(c.serial,0)+1', id=conversation_id, scope=scope, now=now)
+            new_summary = False
+            for event in request.events:
+                digest, payload = encode_event(event)
+                event_id = stable_uuid(conversation_id, request.source_application, request.session_id, event.event_id)
+                existing, _, _ = await store.runtime.driver.execute_query(
+                    'MATCH (e:FuliConversationEvent {id: $id}) RETURN e.digest AS digest', id=event_id)
+                if existing:
+                    if existing[0]['digest'] != digest:
+                        raise HTTPException(409, 'Conversation event ID has different content')
+                    continue
+                if event.kind == 'checkpoint':
+                    new_summary = True
+                await store.runtime.driver.execute_query(
+                    'MATCH (c:FuliConversation {id: $id}) SET c.revision=c.revision+1, c.last_activity=$now '
+                    'CREATE (e:FuliConversationEvent {id: $event_id, digest: $digest, payload: $payload, '
+                    'sequence: c.revision, source_application: $source, task_context_token: $task}) '
+                    'CREATE (c)-[:HAS_EVENT]->(e)', id=conversation_id, event_id=event_id,
+                    digest=digest, payload=payload, now=now, source=request.source_application,
+                    task=request.task_context_token)
+            if request.summary is not None and new_summary:
+                await store.runtime.driver.execute_query(
+                    'MATCH (c:FuliConversation {id: $id}) SET c.summary=$summary, c.status=$status',
+                    id=conversation_id, summary=request.summary, status=request.status or 'reported')
+            if request.cursor is not None:
+                await store.runtime.driver.execute_query(
+                    'MATCH (s:FuliTranscriptCursor {id: $id}) SET s.cursor=$cursor, s.owner_scope=$scope', id=stream, cursor=request.cursor, scope=scope)
+            rows, _, _ = await store.runtime.driver.execute_query(
+                'MATCH (c:FuliConversation {id: $id}) RETURN c.revision AS revision', id=conversation_id)
+            return {'status': 'saved', 'conversation_id': conversation_id, 'revision': rows[0]['revision']}
+
+    async def resume_conversation(self, actor, request):
+        async with query_store_transaction(self) as store:
+            scope = await store._conversation_scope(actor, request, write=True)
+            await store._conversation_task(actor, request)
+            rows, _, _ = await store.runtime.driver.execute_query(
+                'MATCH (c:FuliConversation {id: $id, scope: $scope}) RETURN c.id AS id',
+                id=request.conversation_id, scope=scope)
+            if not rows:
+                raise HTTPException(404, 'Conversation not found in this Agent and project')
+            await store.runtime.driver.execute_query(
+                'MERGE (b:FuliConversationBinding {id: $id}) ON CREATE SET b.cursor=0 '
+                'SET b.conversation_id=$conversation_id', id=stable_uuid(scope, request.source_application, request.session_id),
+                conversation_id=request.conversation_id)
+            return {'status': 'resumed', 'conversation_id': request.conversation_id}
+
+    async def claim_conversation_boundary(self, actor, request):
+        if request.events or request.cursor is None or (not request.initialize_cursor and request.cursor != request.expected_cursor):
+            raise HTTPException(422, 'A scope boundary cannot import events or skip bytes')
+        async with query_store_transaction(self) as store:
+            scope = await store._conversation_scope(actor, request, write=True)
+            await store._conversation_task(actor, request)
+            stream = stable_uuid(request.personal_space_id, request.source_application, request.session_id)
+            if request.initialize_cursor:
+                # First hook sync has no journal entry yet. Create only after authorization;
+                # a failed CAS rolls this back in the same transaction.
+                await store.runtime.driver.execute_query(
+                    'MERGE (s:FuliTranscriptCursor {id:$id}) '
+                    'ON CREATE SET s.cursor=0, s.initialized=false', id=stream)
+            rows, _, _ = await store.runtime.driver.execute_query(
+                'MATCH (s:FuliTranscriptCursor {id:$id}) SET s.serial=coalesce(s.serial,0)+1 '
+                'WITH s WHERE s.cursor=$expected AND '
+                '($initialize=false OR (s.cursor=0 AND coalesce(s.initialized,false)=false)) '
+                'SET s.owner_scope=$scope, s.cursor=$cursor, s.initialized=true RETURN s.cursor AS cursor',
+                id=stream,
+                cursor=request.cursor, expected=request.expected_cursor, initialize=request.initialize_cursor, scope=scope)
+            if not rows:
+                raise HTTPException(409, 'Transcript cursor changed before scope boundary')
+            return {'status': 'bound', 'cursor': request.cursor}

package/graph-provider/fuli_graph/store_agent_loans.py

@@ -0,0 +1,146 @@
+import json
+from fastapi import HTTPException
+from .personal_project_access import authorize_personal_project
+from .project_agent_access import authorize_project_agent
+from .project_agent_models import ProjectAgentAssignmentCreate, ProjectAgentAssignmentEnd
+from .provider_values import now_utc, stable_uuid
+from .store_transactions import query_store_transaction
+
+
+class StoreAgentLoans:
+    async def _loan_lead(self, actor, request):
+        self._require_personal()
+        space = await self.authorize(actor, request.personal_space_id, 'maintainer')
+        task = await self.get_task_context(actor, request.personal_space_id,
+            request.task_context_token, request.source_application)
+        policy = await self.get_project_agent_coordination_policy(actor,
+            request.personal_space_id, task['personal_project_id'])
+        if not policy.team_lead_agent_id or task['project_agent_id'] != policy.team_lead_agent_id:
+            raise HTTPException(403, 'Ask the current project team lead to coordinate this loan')
+        lead = await authorize_project_agent(self, actor, space, task['personal_project_id'],
+            task['project_agent_id'], require_active=True)
+        if request.source_application not in json.loads(lead['profile_json']).get('allowed_clients', []):
+            raise HTTPException(403, 'Team lead is not allowed in this client')
+        return task
+
+    async def list_agent_loans(self, actor, request):
+        self._require_personal()
+        space = await self.authorize(actor, request.personal_space_id, 'reader')
+        await authorize_personal_project(self, actor, space, request.personal_project_id)
+        rows, _, _ = await self.runtime.driver.execute_query(
+            'MATCH (l:FuliAgentLoan {space: $space}) WHERE l.source_project=$project OR l.target_project=$project '
+            'RETURN l.record_json AS record_json ORDER BY l.updated_at DESC LIMIT 30',
+            space=request.personal_space_id, project=request.personal_project_id)
+        return {'loans': [json.loads(row['record_json']) for row in rows]}
+
+    async def request_agent_loan(self, actor, request):
+        async with query_store_transaction(self) as store:
+            task = await store._loan_lead(actor, request)
+            if task['personal_project_id'] == request.source_project_id:
+                raise HTTPException(422, 'Use an existing project assignment for a local specialist')
+            space = await store.authorize(actor, request.personal_space_id, 'maintainer')
+            specialist = await authorize_project_agent(store, actor, space, request.source_project_id,
+                request.specialist_id, require_active=True, require_memory=True)
+            source_policy = await store.get_project_agent_coordination_policy(actor,
+                request.personal_space_id, request.source_project_id)
+            if not source_policy.team_lead_agent_id:
+                raise HTTPException(409, 'The source project needs a team lead before a loan')
+            if request.specialist_id == source_policy.team_lead_agent_id:
+                raise HTTPException(409, 'Keep project team leads available; request a specialist member')
+            profile = json.loads(specialist['profile_json'])
+            if request.source_application not in profile.get('allowed_clients', []):
+                raise HTTPException(403, 'Specialist is not allowed in the destination client')
+            rows, _, _ = await store.runtime.driver.execute_query(
+                'MATCH (t:FuliProjectAgentTask {task_id:$task, personal_space_id:$space, personal_project_id:$project}) '
+                'SET t.loan_serial=coalesce(t.loan_serial,0)+1 WITH t '
+                "WHERE NOT t.status IN ['completed','cancelled','failed'] RETURN t.work_kind AS work_kind",
+                task=request.target_task_id, space=request.personal_space_id, project=task['personal_project_id'])
+            if not rows:
+                raise HTTPException(404, 'Active destination task not found')
+            loan_id = stable_uuid('agent-loan', request.personal_space_id, request.idempotency_key)
+            record = dict(loan_id=loan_id, personal_space_id=request.personal_space_id,
+                source_project_id=request.source_project_id, target_project_id=task['personal_project_id'],
+                source_lead_id=source_policy.team_lead_agent_id, target_lead_id=task['project_agent_id'],
+                specialist_id=request.specialist_id, target_task_id=request.target_task_id,
+                objective=request.objective, work_kind=rows[0]['work_kind'], status='requested',
+                source_application=request.source_application, assignment_id=None)
+            fingerprint = store._payload_hash(request)
+            result, _, _ = await store.runtime.driver.execute_query(
+                'MERGE (l:FuliAgentLoan {id:$id}) ON CREATE SET l.space=$space, l.source_project=$source, '
+                'l.target_project=$target, l.task_id=$task, l.fingerprint=$fingerprint, '
+                'l.record_json=$record, l.updated_at=$now RETURN l.record_json AS record_json, l.fingerprint AS fingerprint',
+                id=loan_id, space=request.personal_space_id, source=request.source_project_id,
+                target=task['personal_project_id'], task=request.target_task_id, fingerprint=fingerprint,
+                record=json.dumps(record), now=now_utc().isoformat())
+            if result[0]['fingerprint'] != fingerprint:
+                raise HTTPException(409, 'Loan idempotency key has different input')
+            return json.loads(result[0]['record_json'])
+
+    async def decide_agent_loan(self, actor, request):
+        async with query_store_transaction(self) as store:
+            task = await store._loan_lead(actor, request)
+            rows, _, _ = await store.runtime.driver.execute_query(
+                'MATCH (l:FuliAgentLoan {id:$id, space:$space}) '
+                'MATCH (t:FuliProjectAgentTask {task_id:l.task_id, personal_space_id:$space}) '
+                'SET t.loan_serial=coalesce(t.loan_serial,0)+1 WITH l,t '
+                'SET l.serial=coalesce(l.serial,0)+1 RETURN l.record_json AS record_json, t.status AS task_status', id=request.loan_id, space=request.personal_space_id)
+            if not rows:
+                raise HTTPException(404, 'Loan not found')
+            record = json.loads(rows[0]['record_json'])
+            source_lead = task['personal_project_id'] == record['source_project_id'] and task['project_agent_id'] == record['source_lead_id']
+            target_lead = task['personal_project_id'] == record['target_project_id'] and task['project_agent_id'] == record['target_lead_id']
+            if not source_lead and not (request.decision == 'close' and target_lead):
+                raise HTTPException(403, 'The source team lead must decide this loan')
+            if request.decision == 'close':
+                return await store._close_agent_loan(actor, record)
+            if request.decision == 'approve' and rows[0]['task_status'] in ('completed', 'cancelled', 'failed'):
+                raise HTTPException(409, 'Destination task has ended')
+            expected = 'approved' if request.decision == 'approve' else 'rejected'
+            if record['status'] == expected:
+                return record
+            if record['status'] != 'requested':
+                raise HTTPException(409, 'Loan already decided')
+            if request.decision == 'approve':
+                space = await store.authorize(actor, request.personal_space_id, 'maintainer')
+                specialist = await authorize_project_agent(store, actor, space, record['source_project_id'],
+                    record['specialist_id'], require_active=True, require_memory=True)
+                if record['source_application'] not in json.loads(specialist['profile_json']).get('allowed_clients', []):
+                    raise HTTPException(403, 'Specialist is no longer allowed in the destination client')
+                assignment = await store.create_project_agent_assignment(actor, ProjectAgentAssignmentCreate(
+                    personal_space_id=record['personal_space_id'], personal_project_id=record['target_project_id'],
+                    agent_id=record['specialist_id'], idempotency_key=f"loan:{record['loan_id']}",
+                    responsibility=record['objective'], work_kinds=[record['work_kind']],
+                    reason='Task-scoped specialist loan approved by both project leads',
+                    source_application=record['source_application']))
+                record['assignment_id'] = assignment.assignment_id
+            record['status'] = expected
+            await store._save_agent_loan(record)
+            return record
+
+    async def _save_agent_loan(self, record):
+        await self.runtime.driver.execute_query('MATCH (l:FuliAgentLoan {id:$id}) SET l.record_json=$record, l.updated_at=$now',
+            id=record['loan_id'], record=json.dumps(record), now=now_utc().isoformat())
+
+    async def _close_agent_loan(self, actor, record):
+        if record['status'] == 'closed':
+            return record
+        if record.get('assignment_id') and record['status'] == 'approved':
+            assignments, _, _ = await self.runtime.driver.execute_query(
+                'MATCH (a:FuliProjectAgentAssignment {assignment_id:$id}) RETURN a.status AS status, a.revision AS revision',
+                id=record['assignment_id'])
+            if assignments and assignments[0]['status'] == 'active':
+                await self.end_project_agent_assignment(actor, ProjectAgentAssignmentEnd(
+                    personal_space_id=record['personal_space_id'], personal_project_id=record['target_project_id'],
+                    assignment_id=record['assignment_id'], expected_revision=assignments[0]['revision'], reason='Specialist loan finished'))
+        record['status'] = 'closed'
+        await self._save_agent_loan(record)
+        return record
+
+    async def close_task_agent_loans(self, actor, space_id, task_id):
+        rows, _, _ = await self.runtime.driver.execute_query(
+            'MATCH (l:FuliAgentLoan {space:$space, task_id:$task}) SET l.serial=coalesce(l.serial,0)+1 '
+            'RETURN l.record_json AS record_json', space=space_id, task=task_id)
+        for row in rows:
+            record = json.loads(row['record_json'])
+            if record['status'] in ('requested', 'approved'):
+                await self._close_agent_loan(actor, record)

package/graph-provider/fuli_graph/store_agent_verification.py

@@ -0,0 +1,111 @@
+import json
+from fastapi import HTTPException
+from .agent_quality_policy import evaluate_quality_policy
+from .personal_project_access import authorize_personal_project
+from .project_agent_access import authorize_project_agent
+from .project_agent_models import ProjectAgentModelStrategy
+from .provider_values import now_utc, stable_uuid
+from .store_transactions import query_store_transaction
+
+
+class StoreAgentVerification:
+    async def _quality_task(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)
+        rows, _, _ = await self.runtime.driver.execute_query(
+            'MATCH (t:FuliProjectAgentTask {task_id:$task, personal_space_id:$space, personal_project_id:$project}) RETURN t',
+            task=request.task_id, space=request.personal_space_id, project=request.personal_project_id)
+        if not rows:
+            raise HTTPException(404, 'Quality gate task not found')
+        return dict(rows[0]['t'])
+
+    async def _quality_models(self, actor, request, task):
+        executors = await self.list_project_agent_executors(actor, request.personal_space_id, available_only=True)
+        models = []
+        strategy = ProjectAgentModelStrategy.model_validate_json(task.get('effective_model_strategy_json') or '{}')
+        policy = json.loads(task.get('executor_policy_json') or '{}')
+        locked = policy.get('locked_executor_ids', []) if policy.get('mode') == 'locked' else None
+        for executor in executors:
+            if locked is not None and executor.executor_id not in locked:
+                continue
+            if (executor.permission_status != 'authorized' or executor.preflight_status != 'passed'
+                or executor.registration_status != 'registered' or not executor.workspace_permission
+                or executor.health_status == 'unhealthy'
+                or (executor.health_required and executor.health_status != 'healthy')):
+                continue
+            for model in executor.available_models:
+                if self._select_model([model], strategy) is not None:
+                    models.append({**model.model_dump(), 'executor_id': executor.executor_id})
+        return models
+
+    async def query_agent_quality(self, actor, request):
+        task = await self._quality_task(actor, request)
+        rows, _, _ = await self.runtime.driver.execute_query(
+            'MATCH (t:FuliProjectAgentTask {task_id:$task, personal_space_id:$space})-[:HAS_VERIFICATION]->(v:FuliAgentVerification) '
+            'RETURN v.record_json AS record_json ORDER BY v.sequence', task=request.task_id, space=request.personal_space_id)
+        models = await self._quality_models(actor, request, task)
+        result = evaluate_quality_policy(complexity=task.get('complexity') or 'standard',
+            current_strategy=json.loads(task.get('effective_model_strategy_json') or '{"mode":"adaptive"}'),
+            artifact_revision=request.artifact_revision,
+            attempts=[json.loads(row['record_json']) for row in rows], available_models=models)
+        selected = result['selected_model']
+        if selected:
+            selected['executor_id'] = next(model['executor_id'] for model in models
+                if all(model.get(key) == selected[key] for key in ('provider', 'model', 'capability_tier', 'cost_rank')))
+        return {**result, 'evidence_authority': 'host_reported_test_evidence',
+            'execution_started': False, 'guidance': 'Only complete the task after passed for the current artifact revision. Blocked means no authorized preflighted model proves the required capability tier. Model selection does not prove execution.'}
+
+    async def record_agent_verification(self, actor, request):
+        async with query_store_transaction(self) as store:
+            task = await store._quality_task(actor, request)
+            context = await store.get_task_context(actor, request.personal_space_id,
+                request.task_context_token, request.source_application)
+            if context['personal_project_id'] != request.personal_project_id or not context['project_agent_id']:
+                raise HTTPException(403, 'Verifier needs a current Agent in the task project')
+            space = await store.authorize(actor, request.personal_space_id, 'maintainer')
+            verifier = await authorize_project_agent(store, actor, space, request.personal_project_id,
+                context['project_agent_id'], require_active=True)
+            if request.source_application not in json.loads(verifier['profile_json']).get('allowed_clients', []):
+                raise HTTPException(403, 'Verifier is not allowed in this client')
+            await store.runtime.driver.execute_query(
+                'MATCH (t:FuliProjectAgentTask {task_id:$task, personal_space_id:$space}) '
+                'SET t.verification_serial=coalesce(t.verification_serial,0)+1',
+                task=request.task_id, space=request.personal_space_id)
+            models = await store._quality_models(actor, request, task)
+            observed = next((model for model in models if model['executor_id'] == request.executor_id
+                and model['provider'] == request.provider and model['model'] == request.model), None)
+            if not observed or not observed.get('capability_tier'):
+                raise HTTPException(409, 'Verification model needs preflighted capability metadata')
+            # A host must report a real execution, not just the configured model.
+            execution, _, _ = await store.runtime.driver.execute_query(
+                'MATCH (t:FuliProjectAgentTask {task_id:$task, personal_space_id:$space})-[:HAS_EXECUTOR_OBSERVATION]->'
+                '(o:FuliProjectAgentExecutorObservation {agent_id:$agent, executor_id:$executor, provider:$provider, model:$model, run_id:$run, artifact_revision:$revision}) RETURN o LIMIT 1',
+                task=request.task_id, space=request.personal_space_id, agent=context['project_agent_id'],
+                executor=request.executor_id, provider=request.provider, model=request.model, run=request.run_id, revision=request.artifact_revision)
+            if not execution:
+                raise HTTPException(409, 'Report the verifier actual executor run before recording verification')
+            used, _, _ = await store.runtime.driver.execute_query(
+                'MATCH (t:FuliProjectAgentTask {task_id:$task, personal_space_id:$space})-[:HAS_VERIFICATION]->(v:FuliAgentVerification {run_id:$run}) '
+                'RETURN v.attempt_id AS attempt_id', task=request.task_id, space=request.personal_space_id, run=request.run_id)
+            if used and used[0]['attempt_id'] != request.attempt_id:
+                raise HTTPException(409, 'An execution run cannot count as two verification attempts')
+            identifier = stable_uuid('verification', request.personal_space_id, request.task_id, request.attempt_id)
+            record = dict(attempt_id=request.attempt_id, outcome=request.outcome, artifact_revision=request.artifact_revision,
+                evidence_refs=request.evidence_refs, capability_tier=observed['capability_tier'], verifier_id=context['project_agent_id'])
+            fingerprint = store._payload_hash(request)
+            rows, _, _ = await store.runtime.driver.execute_query(
+                'MATCH (t:FuliProjectAgentTask {task_id:$task, personal_space_id:$space}) '
+                'MERGE (v:FuliAgentVerification {id:$id}) ON CREATE SET v.record_json=$record, v.fingerprint=$fingerprint, '
+                'v.sequence=t.verification_serial, v.created_at=$now, v.run_id=$run, v.attempt_id=$attempt '
+                'MERGE (t)-[:HAS_VERIFICATION]->(v) RETURN v.fingerprint AS fingerprint',
+                task=request.task_id, space=request.personal_space_id, id=identifier,
+                record=json.dumps(record), fingerprint=fingerprint, now=now_utc().isoformat(), run=request.run_id, attempt=request.attempt_id)
+            if rows[0]['fingerprint'] != fingerprint:
+                raise HTTPException(409, 'Verification attempt ID has different evidence')
+            result = await store.query_agent_quality(actor, request)
+            await store.runtime.driver.execute_query(
+                'MATCH (t:FuliProjectAgentTask {task_id:$task, personal_space_id:$space}) '
+                'SET t.quality_gate=$status, t.verified_artifact_revision=$revision',
+                task=request.task_id, space=request.personal_space_id, status=result['status'], revision=request.artifact_revision)
+            return result