fuli-context 0.10.0 → 0.11.1

package/graph-provider/fuli_graph/runtime.py

@@ -226,6 +226,10 @@ class GraphitiRuntime:
             'CREATE CONSTRAINT fuli_workflow_review_preview_token IF NOT EXISTS '
             'FOR (n:FuliWorkflowReviewPreview) REQUIRE n.token_hash IS UNIQUE'
         )
+        await self.driver.execute_query(
+            'CREATE CONSTRAINT fuli_agent_delegation_token IF NOT EXISTS '
+            'FOR (n:FuliAgentDelegation) REQUIRE n.token_hash IS UNIQUE'
+        )
         await self.driver.execute_query(
             'CREATE CONSTRAINT fuli_workflow_rule_id IF NOT EXISTS '
             'FOR (n:FuliWorkflowRule) REQUIRE n.id IS UNIQUE'
@@ -285,6 +289,9 @@ class GraphitiRuntime:
             '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_project_agent_employee_number IF NOT EXISTS '
+            'FOR (n:FuliProjectAgent) '
+            'REQUIRE (n.employee_number_space_id, n.employee_number) IS UNIQUE',
             'CREATE CONSTRAINT fuli_agent_attention_id IF NOT EXISTS '
             'FOR (n:FuliAgentAttention) REQUIRE n.id IS UNIQUE',
             'CREATE CONSTRAINT fuli_project_agent_assignment_id IF NOT EXISTS '
@@ -527,83 +534,10 @@ class GraphitiRuntime:
             "MATCH (space:FuliSpace {kind: 'personal'}) RETURN space.id AS space_id",
             routing_='r',
         )
-        if not records:
-            return
-        from .project_agent_models import ProjectAgentProfile
-        from .provider_values import now_utc, stable_uuid
-
-        coordinator_profile = ProjectAgentProfile(
-            name='项目协调人',
-            responsibility='评估任务、应用用户配置并路由已有 Agent。',
-            agent_type='coordinator',
-            work_kinds=['task-coordination'],
-            capabilities=['任务评估', '策略应用', 'Agent 路由'],
-            initial_preferences=['质量与可验收完成优先于成本和时间'],
-            status='active',
-        )
-        hr_profile = ProjectAgentProfile(
-            name='Bole',
-            occupation_emoji='🔎',
-            responsibility=(
-                '维护 Agent 人员分布、当前工作与可审计招募记录，'
-                '并在需要新角色时执行受策略约束的招募。'
-            ),
-            agent_type='hr',
-            work_kinds=['agent-recruitment', 'staffing-review'],
-            capabilities=[
-                'Agent 招募', '人员分布', '工作状态', '招募审计',
-                'fuli.employee:bole',
-            ],
-            initial_preferences=[
-                '每次招募保留任务、原因、触发来源与时间线。',
-                '只展示 Provider 已记录的人员状态，不推测未上报的工作。',
-            ],
-            status='active',
-        )
-        updated_at = now_utc()
+        from .system_agents import ensure_system_agents
+
         for record in records:
-            space_id = record['space_id']
-            for agent_id, profile in (
-                ('fuli-project-coordinator', coordinator_profile),
-                ('employee.bole', hr_profile),
-            ):
-                node_id = stable_uuid(
-                    self.settings.provider_id,
-                    space_id,
-                    'project-agent',
-                    agent_id,
-                )
-                await self.driver.execute_query(
-                    '''
-                MATCH (space:FuliSpace {id: $space_id, kind: 'personal'})
-                MERGE (agent:FuliProjectAgent {id: $id})
-                ON CREATE SET agent.agent_id = $agent_id,
-                              agent.profile_json = $profile_json,
-                              agent.name = $name,
-                              agent.occupation_emoji = $occupation_emoji,
-                              agent.responsibility = $responsibility,
-                              agent.capabilities = $capabilities,
-                              agent.work_kinds = $work_kinds,
-                              agent.agent_type = $agent_type,
-                              agent.memory_scope = 'reviewed_agent',
-                              agent.status = 'active',
-                              agent.system_managed = true,
-                              agent.created_at = $updated_at,
-                              agent.updated_at = $updated_at
-                MERGE (space)-[:HAS_PROJECT_AGENT_IDENTITY]->(agent)
-                ''',
-                    space_id=space_id,
-                    id=node_id,
-                    agent_id=agent_id,
-                    profile_json=profile.model_dump_json(),
-                    name=profile.name,
-                    occupation_emoji=profile.occupation_emoji,
-                    responsibility=profile.responsibility,
-                    capabilities=profile.capabilities,
-                    work_kinds=profile.work_kinds,
-                    agent_type=profile.agent_type,
-                    updated_at=updated_at,
-                )
+            await ensure_system_agents(self.driver, self.settings.provider_id, record['space_id'])
 
     async def _migrate_personal_project_relation_review_defaults(self) -> None:
         await self.driver.execute_query(

package/graph-provider/fuli_graph/store.py

@@ -9,6 +9,7 @@ from .store_knowledge import StoreKnowledge
 from .store_project_agent_executors import StoreProjectAgentExecutors
 from .store_project_agent_memory import StoreProjectAgentMemory
 from .store_project_agent_context import StoreProjectAgentContext
+from .default_project_lead import StoreDefaultProjectLead
 from .store_project_agents import StoreProjectAgents
 from .store_project_agent_attention import StoreProjectAgentAttention
 from .store_project_agent_tasks import StoreProjectAgentTasks
@@ -28,6 +29,7 @@ class GraphStore(
     StoreProjectAgentAttention,
     StoreProjectAgentMemory,
     StoreProjectAgentContext,
+    StoreDefaultProjectLead,
     StoreTaskContexts,
     StoreProjectAgentExecutors,
     StoreProjectAgentTasks,

package/graph-provider/fuli_graph/store_agent_conversations.py

@@ -5,7 +5,9 @@ import hashlib
 import json
 from fastapi import HTTPException
 from .agent_conversation_models import ConversationPolicy
-from .conversation_context import archived, pack_context
+from .conversation_context import (
+    add_task_result, fold_messages, message_bytes, pack_context, render_digest,
+)
 from .project_agent_access import authorize_project_agent
 from .provider_values import now_utc, stable_uuid
 from .store_transactions import query_store_transaction
@@ -77,13 +79,13 @@ class StoreAgentConversations:
             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'
+        # Recovery starts after the folded range; reading history still sees everything.
+        after = max(request.after, record.get('compacted_through') or 0) if request.mode == 'context' else request.after
         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,
+            f'ORDER BY e.sequence {order} LIMIT $limit', id=record['id'], after=after,
             limit=20 if request.mode == 'context' else request.limit)
         decoded = []
         total = 0
@@ -94,15 +96,52 @@ class StoreAgentConversations:
                 break
             decoded.append(value)
         if request.mode == 'context':
-            return {**view, 'context': pack_context(record.get('summary', ''), list(reversed(decoded)), policy.context_budget)}
+            return {**view, 'context': pack_context(self._digest_text(record), 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),
+            'compacted_through': record.get('compacted_through') or 0,
+            'unfolded_bytes': record.get('unfolded_bytes') or 0,
             'policy': policy.model_dump(), 'raw_retained': True}
 
+    @staticmethod
+    def _digest_text(record):
+        if record.get('digest'):
+            return render_digest(json.loads(record['digest']))
+        return record.get('summary') or ''
+
+    async def _compact_conversation(self, conversation_id, policy):
+        """Fold older messages into the digest, keeping recent ones verbatim."""
+        rows, _, _ = await self.runtime.driver.execute_query(
+            'MATCH (c:FuliConversation {id: $id}) RETURN c', id=conversation_id)
+        record = dict(rows[0]['c'])
+        threshold = policy.compact_after_kb * 1024
+        if (record.get('unfolded_bytes') or 0) <= threshold:
+            return
+        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 '
+            'ORDER BY e.sequence', id=conversation_id, after=record.get('compacted_through') or 0)
+        decoded = [decode_event(event) for event in events]
+        if not decoded:
+            return
+        # The newest event always stays verbatim, then as much as fits a quarter.
+        keep_bytes, cut = threshold // 4, len(decoded) - 1
+        kept = message_bytes(decoded[cut])
+        while cut and kept + message_bytes(decoded[cut - 1]) <= keep_bytes:
+            cut -= 1
+            kept += message_bytes(decoded[cut])
+        if not cut:
+            return
+        digest = json.loads(record['digest']) if record.get('digest') else {}
+        await self.runtime.driver.execute_query(
+            'MATCH (c:FuliConversation {id: $id}) '
+            'SET c.digest=$digest, c.compacted_through=$through, c.unfolded_bytes=$kept',
+            id=conversation_id, digest=json.dumps(fold_messages(digest, decoded[:cut]), ensure_ascii=False),
+            through=decoded[cut - 1]['sequence'], kept=kept)
+
     async def append_conversation(self, actor, request):
         if request.initialize_cursor:
             raise HTTPException(422, 'Initialize transcripts only at a verified task boundary')
@@ -137,6 +176,7 @@ class StoreAgentConversations:
                 "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
+            unfolded = 0
             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)
@@ -148,6 +188,7 @@ class StoreAgentConversations:
                     continue
                 if event.kind == 'checkpoint':
                     new_summary = True
+                unfolded += message_bytes(event.model_dump())
                 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, '
@@ -155,10 +196,21 @@ class StoreAgentConversations:
                     '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 unfolded:
+                await store.runtime.driver.execute_query(
+                    'MATCH (c:FuliConversation {id: $id}) '
+                    'SET c.unfolded_bytes=coalesce(c.unfolded_bytes,0)+$bytes',
+                    id=conversation_id, bytes=unfolded)
             if request.summary is not None and new_summary:
+                rows, _, _ = await store.runtime.driver.execute_query(
+                    'MATCH (c:FuliConversation {id: $id}) RETURN c.digest AS digest', id=conversation_id)
+                digest = json.loads(rows[0]['digest']) if rows[0]['digest'] else {}
+                digest = add_task_result(digest, now, request.status or 'reported', request.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')
+                    'MATCH (c:FuliConversation {id: $id}) SET c.summary=$summary, c.status=$status, c.digest=$digest',
+                    id=conversation_id, summary=request.summary, status=request.status or 'reported',
+                    digest=json.dumps(digest, ensure_ascii=False))
+            await store._compact_conversation(conversation_id, policy)
             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)

package/graph-provider/fuli_graph/store_project_agent_context.py

@@ -4,16 +4,21 @@ from .personal_project_access import authorize_personal_project
 from .project_agent_context_models import ProjectAgentContextResolution
 from .project_agent_task_models import ProjectAgentTaskSubmit
 from .task_context_temporary_owner import temporary_task_owner
+from .project_agent_delegations import StoreAgentDelegations
 
 
-class StoreProjectAgentContext:
+class StoreProjectAgentContext(StoreAgentDelegations):
     async def resolve_project_agent_context(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)
-        temporary_owner = await temporary_task_owner(self, actor, request)
+        temporary_owner = await temporary_task_owner(self, actor, request) if not request.delegation_token else None
         if temporary_owner is not None:
             return temporary_owner
+        policy = await self.get_project_agent_coordination_policy(
+            actor, request.personal_space_id, request.personal_project_id,
+        )
+        project_lead = getattr(policy, 'team_lead_agent_id', None)
         owner = None
         if request.session_id and not request.agent_id:
             rows, _, _ = await self.runtime.driver.execute_query(
@@ -39,7 +44,8 @@ class StoreProjectAgentContext:
             idempotency_key='read-only-task-context',
             title='Resolve task context', objective='Select one existing durable role.',
             work_kind=request.work_kind, required_capabilities=request.required_capabilities,
-            lead_agent_id=request.agent_id or owner, source_application=request.source_application,
+            lead_agent_id=request.agent_id or (project_lead if owner else None),
+            source_application=request.source_application,
             routing_reason='Read-only task-entry context recovery',
         )
         if owner and not request.agent_id:
@@ -71,16 +77,58 @@ class StoreProjectAgentContext:
                     'using project_context for continuity only',
                     *basis,
                 ]
-        if owner and selected:
+        requested_agent_id = None
+        reporting_lead_agent_id = None
+        peer_request = bool(request.agent_id and selected and self._is_implicit_peer(selected[0]))
+        delegated = bool(request.delegation_token)
+        if delegated and (not selected or selected[0]['agent_id'] != request.agent_id):
+            return ProjectAgentContextResolution(status='agent_unavailable', reason='delegation_invalid')
+        if not peer_request:
+            if not project_lead:
+                if delegated:
+                    return ProjectAgentContextResolution(status='agent_unavailable', reason='delegation_invalid')
+                return ProjectAgentContextResolution(
+                    status='unassigned', reason='project_lead_required',
+                    requested_agent_id=request.agent_id,
+                    match_basis=['Every project requires one accountable lead before work begins.'],
+                )
+            if selected and selected[0]['agent_id'] != project_lead:
+                # Validate the named specialist first, then route accountability
+                # through the lead. Never load the specialist's private memory here.
+                rows = await self._assignment_candidates(request.personal_space_id, request.personal_project_id)
+                lead = next((row for row in rows if row['agent_id'] == project_lead
+                             and (delegated or self._agent_client_allowed(row, request.source_application))), None)
+                if not lead:
+                    return ProjectAgentContextResolution(status='agent_unavailable',
+                        reason='team_lead_unavailable', match_basis=['The configured project lead is unavailable.'])
+                if delegated:
+                    # A real lead-to-member worker invocation keeps the member's
+                    # isolated identity; its result returns to the project lead.
+                    reporting_lead_agent_id = project_lead
+                    reason = 'delegated_member'
+                    basis = ['This member worker reports to the configured project lead.']
+                else:
+                    requested_agent_id = request.agent_id
+                    selected = [lead]
+                    reason = 'project_lead_reporting'
+                    basis = ['The project lead owns the task; requested members report results to this lead.']
+        if owner and selected and owner == selected[0]['agent_id']:
             reason, basis = 'active_task_owner', ['reuse the owner of this host session task']
         agent = await self.get_project_agent(
             actor, request.personal_space_id, request.personal_project_id,
             selected[0]['agent_id'],
         ) if selected else None
+        # A reporting lead does not execute in the member's client. Acknowledge
+        # the capability only after the executing role passes selection, so a
+        # failed resolution cannot be accepted as that member's answer.
+        if delegated and (not agent or not await self.redeem_agent_delegation(request, project_lead)):
+            return ProjectAgentContextResolution(status='agent_unavailable', reason='delegation_invalid')
         return ProjectAgentContextResolution(
             status='ready' if agent else (
                 'manual_selection' if reason == 'manual_agent_selection'
                 else 'agent_unavailable' if reason == 'agent_unavailable' else 'unassigned'
             ),
             agent=agent, reason=reason, match_basis=basis, candidate_count=len(candidates),
+            requested_agent_id=requested_agent_id,
+            reporting_lead_agent_id=reporting_lead_agent_id,
         )

package/graph-provider/fuli_graph/store_project_agent_coordination_policy.py

@@ -93,6 +93,8 @@ class StoreProjectAgentCoordinationPolicy:
         members = (request.team_member_agent_ids if 'team_member_agent_ids' in request.model_fields_set
                    else current.team_member_agent_ids)
         auto_grow = current.auto_grow_team if request.auto_grow_team is None else request.auto_grow_team
+        if 'team_lead_agent_id' in request.model_fields_set and not lead:
+            raise HTTPException(status_code=422, detail='each project requires a lead; select a replacement instead of clearing the lead')
         if members and not lead:
             raise HTTPException(status_code=422, detail='select a team lead before adding members')
         if lead in members:
@@ -115,9 +117,21 @@ class StoreProjectAgentCoordinationPolicy:
         updated_at = now_utc()
         written, _, _ = await self.runtime.driver.execute_query(
             '''
-            MATCH (:FuliSpace {id: $personal_space_id, kind: 'personal'})-
+            MATCH (space:FuliSpace {id: $personal_space_id, kind: 'personal'})-
                   [:CONTAINS_PROJECT]->
                   (project:FuliPersonalProject {project_id: $personal_project_id})
+            OPTIONAL MATCH (space)-[:HAS_PROJECT_AGENT_IDENTITY]->(role:FuliProjectAgent)
+            WHERE role.agent_id IN $team_agent_ids
+            WITH project, role ORDER BY role.agent_id
+            FOREACH (locked IN CASE WHEN role IS NULL THEN [] ELSE [role] END |
+              SET locked._task_lifecycle_lock = true
+              REMOVE locked._task_lifecycle_lock)
+            WITH project, collect(role) AS roles
+            WHERE size(roles) = size($team_agent_ids)
+              AND all(role IN roles WHERE role.status = 'active' AND EXISTS {
+                MATCH (project)-[:HAS_PROJECT_AGENT_ASSIGNMENT]->
+                      (:FuliProjectAgentAssignment {status: 'active'})-[:ASSIGNED_AGENT]->(role)
+              })
             MERGE (policy:FuliProjectAgentCoordinationPolicy {
               policy_id: $policy_id
             })
@@ -147,6 +161,7 @@ class StoreProjectAgentCoordinationPolicy:
             auto_grow_team=auto_grow,
             team_lead_agent_id=lead,
             team_member_agent_ids=members,
+            team_agent_ids=([lead] if lead else []) + members,
             expected_updated_at=current.updated_at,
             updated_at=updated_at,
         )

package/graph-provider/fuli_graph/store_project_agent_task_recruitment.py

@@ -761,9 +761,11 @@ class StoreProjectAgentTaskRecruitment:
             request.personal_space_id,
             request.personal_project_id,
         )
+        first_lead = (request.staffing_intent == 'default_lead' and participant_role == 'lead'
+                      and coordination_policy.team_lead_agent_id is None)
         confirmation_mode = (
             'require_confirmation'
-            if coordination_policy.ask_before_recruitment
+            if coordination_policy.ask_before_recruitment and not first_lead
             else 'automatic'
         )
         if not hr_agent_id:

package/graph-provider/fuli_graph/store_project_agent_task_staffing.py

@@ -54,14 +54,15 @@ class StoreProjectAgentTaskStaffing:
             row for row in assignment_rows
             if self._agent_client_allowed(row, request.source_application)
         ]
-        if request.staffing_intent in {'new_durable', 'temporary'}:
+        if request.staffing_intent in {'new_durable', 'temporary', 'default_lead'}:
             return (
                 [],
                 rows,
                 'explicit_temporary_agent'
                 if request.staffing_intent == 'temporary'
                 else 'explicit_new_agent',
-                ['user explicitly requested recruitment'],
+                ['project requires an accountable lead' if request.staffing_intent == 'default_lead'
+                 else 'user explicitly requested recruitment'],
             )
         policy = await self.get_project_agent_coordination_policy(
             actor,

package/graph-provider/fuli_graph/store_project_agent_tasks.py

@@ -347,13 +347,16 @@ class StoreProjectAgentTasks(
                 reason = 'hr_unavailable'
         self._verify_parallel_plan(request.parallel_plan, participants)
 
-        executor_decision = await self._resolve_executor_if_available(
-            actor,
-            request,
-            lead,
-            model_strategy,
-            model_source,
-            task_id,
+        # Staffing a default lead executes nothing, so it needs no executor.
+        executor_decision = None if request.staffing_intent == 'default_lead' else (
+            await self._resolve_executor_if_available(
+                actor,
+                request,
+                lead,
+                model_strategy,
+                model_source,
+                task_id,
+            )
         )
         if lead and executor_decision and self._executor_decision_blocked(executor_decision):
             routing_outcome = 'blocked'
@@ -904,7 +907,8 @@ class StoreProjectAgentTasks(
             lead_agent_id=lead_agent_id,
             complexity=complexity,
             complexity_basis=complexity_basis,
-            verification_required=request.verification_required,
+            # A staffing record has no artifact to verify.
+            verification_required=request.staffing_intent != 'default_lead',
             model_strategy_json=model_strategy.model_dump_json() if model_strategy else None,
             task_model_strategy_override_json=(
                 request.model_strategy_override.model_dump_json()